tag:
	 *
	 *     // Displays the type and value of each variable
	 *     echo Kohana::debug($foo, $bar, $baz);
	 *
	 * @param   mixed   variable to debug
	 * @param   ...
	 * @return  string
	 */
	public static function debug()
	{
		if (func_num_args() === 0)
			return;

		// Get all passed variables
		$variables = func_get_args();

		$output = array();
		foreach ($variables as $var)
		{
			$type = gettype($var);

			switch ($type)
			{
				case 'null':
					$var = 'NULL';
				break;
				case 'boolean':
					$var = $var ? 'TRUE' : 'FALSE';
				break;
				default:
					$var = htmlspecialchars(print_r($var, TRUE), NULL, self::$charset, TRUE);
				break;
			}

			$output[] = '
('.$type.') '.$var.'
';
		}

		return implode("\n", $output);
	}

	/**
	 * Removes application, system, modpath, or docroot from a filename,
	 * replacing them with the plain text equivalents. Useful for debugging
	 * when you want to display a shorter path.
	 *
	 *     // Displays SYSPATH/classes/kohana.php
	 *     echo Kohana::debug_path(Kohana::find_file('classes', 'kohana'));
	 *
	 * @param   string  path to debug
	 * @return  string
	 */
	public static function debug_path($file)
	{
		if (strpos($file, APPPATH) === 0)
		{
			$file = 'APPPATH/'.substr($file, strlen(APPPATH));
		}
		elseif (strpos($file, SYSPATH) === 0)
		{
			$file = 'SYSPATH/'.substr($file, strlen(SYSPATH));
		}
		elseif (strpos($file, MODPATH) === 0)
		{
			$file = 'MODPATH/'.substr($file, strlen(MODPATH));
		}
		elseif (strpos($file, DOCROOT) === 0)
		{
			$file = 'DOCROOT/'.substr($file, strlen(DOCROOT));
		}

		return $file;
	}

	/**
	 * Returns an HTML string, highlighting a specific line of a file, with some
	 * number of lines padded above and below.
	 *
	 *     // Highlights the current line of the current file
	 *     echo Kohana::debug_source(__FILE__, __LINE__);
	 *
	 * @param   string   file to open
	 * @param   integer  line number to highlight
	 * @param   integer  number of padding lines
	 * @return  string
	 */
	public static function debug_source($file, $line_number, $padding = 3)
	{
		// Open the file and set the line position
		$file = fopen($file, 'r');
		$line = 0;

		// Set the reading range
		$range = array('start' => $line_number - $padding, 'end' => $line_number + $padding);

		$source = array();
		while (($row = fgets($file)) !== FALSE)
		{
			// Increment the line number
			if (++$line > $range['end'])
				break;

			if ($line >= $range['start'])
			{
				// Trim whitespace and sanitize the row
				$row = htmlspecialchars(rtrim($row));

				if ($line === $line_number)
				{
					// Apply highlighting to the row
					$row = ''.$row.'';
				}

				// Add to the captured source
				$source[] = $row;
			}
		}

		// Close the file
		fclose($file);

		return implode("\n", $source);
	}

	/**
	 * Returns a single line representation of a variable. Internally, this is
	 * used only for showing function arguments in stack traces.
	 *
	 *     echo Kohana::debug_var($my_var);
	 *
	 * @param   mixed  variable to debug
	 * @return  string
	 */
	public static function debug_var($var)
	{
		switch (gettype($var))
		{
			case 'null':
				return 'NULL';
			break;
			case 'boolean':
				return $var ? 'TRUE' : 'FALSE';
			break;
			case 'string':
				return var_export($var, TRUE);
			break;
			case 'object':
				return 'object '.get_class($var);
			break;
			case 'array':
				if (arr::is_assoc($var))
					return print_r($var, TRUE);

				return 'array('.implode(', ', array_map(array(__CLASS__, __FUNCTION__), $var)).')';
			break;
			default:
				return var_export($var, TRUE);
			break;
		}
	}

	/**
	 * Returns an array of HTML strings that represent each step in the backtrace.
	 *
	 *     // Displays the entire current backtrace
	 *     echo implode('
', Kohana::trace());
	 *
	 * @param   string  path to debug
	 * @return  string
	 */
	public static function trace(array $trace = NULL)
	{
		if ($trace === NULL)
		{
			// Start a new trace
			$trace = debug_backtrace();
		}

		// Non-standard function calls
		$statements = array('include', 'include_once', 'require', 'require_once');

		$output = array();
		foreach ($trace as $step)
		{
			if ( ! (isset($step['function']) AND isset($step['file'])))
			{
				// Ignore this line, it has unusable data
				continue;
			}

			// Set the function name
			$function = $step['function'];

			// Set the file and line
			$file = self::debug_path($step['file']);
			$line = $step['line'];

			if (isset($step['class']))
			{
				// Change the function to a method
				$function = $step['class'].$step['type'].$function;
			}

			if (isset($step['args']))
			{
				if (in_array($function, $statements))
				{
					// Sanitize the path name
					$function .= ' '.self::debug_path($step['args'][0]);
				}
				else
				{
					// Sanitize the function arguments
					$function .= '('.implode(', ', $args = array_map('Kohana::debug_var', $step['args'])).')';
				}
			}

			$output[] = array(
				'function' => $function,
				'file'     => self::debug_path($step['file']),
				'line'     => $step['line']);
		}

		return $output;
	}

	private function __construct()
	{
		// This is a static class
	}

} // End Kohana