Kohana_Core

Class Contents

Constants

VERSION
CODENAME
ERROR
DEBUG
INFO
CRITICAL
STRACE
ALERT
PRODUCTION
STAGING
TESTING
DEVELOPMENT
FILE_SECURITY
FILE_CACHE

Class declared in SYSPATH/classes/kohana/core.php on line 16.

Constants

VERSION

string(5) "3.0.8"

CODENAME

string(14) "großen jäger"

ERROR

string(5) "ERROR"

DEBUG

string(5) "DEBUG"

INFO

string(4) "INFO"

CRITICAL

string(8) "CRITICAL"

STRACE

string(6) "STRACE"

ALERT

string(5) "ALERT"

PRODUCTION

string(10) "production"

STAGING

string(7) "staging"

TESTING

string(7) "testing"

DEVELOPMENT

string(11) "development"

FILE_SECURITY

string(60) "<?php defined('SYSPATH') or die('No direct script access.');"

FILE_CACHE

string(26) ":header 

// :name

:data
"

Properties

public static $base_url

string(1) "/"

public static $cache_dir

string(64) "/home/b/biakaveron/ko3.biakaveron.tmweb.ru/ko3/application/cache"

public static $cache_life

integer 60

public static $caching

bool FALSE

public static $charset

string(5) "utf-8"

public static $config

object Kohana_Config(1) {
    protected _readers => array(1) (
        0 => object Kohana_Config_File(0) {
        }
    )
}

public static $debug_escape_quotes

bool FALSE

public static $environment

string(11) "development"

public static $error_view

string(12) "kohana/error"

public static $errors

bool TRUE

public static $index_file

string(0) ""

public static $is_cli

bool FALSE

public static $is_windows

bool FALSE

public static $log

object Kohana_Log(2) {
    private _messages => array(0) 
    private _writers => array(1) (
        "0e62e86ada2bd30b64e325fc8b967d5f" => array(2) (
            "object" => object Kohana_Log_File(1) {
                protected _directory => string(64) "/home/b/biakaveron/ko3.biakaveron.tmweb.ru/ko3/application/logs/"
            }
            "types" => NULL
        )
    )
}

public static $log_errors

bool FALSE

public static $magic_quotes

bool TRUE

public static $php_errors

array(8) (
    1 => string(11) "Fatal Error"
    256 => string(10) "User Error"
    4 => string(11) "Parse Error"
    2 => string(7) "Warning"
    512 => string(12) "User Warning"
    2048 => string(6) "Strict"
    8 => string(6) "Notice"
    4096 => string(17) "Recoverable Error"
)

public static $profiling

bool TRUE

public static $safe_mode

bool FALSE

public static $shutdown_errors

array(3) (
    0 => integer 4
    1 => integer 1
    2 => integer 256
)

Methods

protected static _dump( )
› Kohana_Core

Source Code

protected static function _dump( & $var, $length = 128, $level = 0)
{
	if ($var === NULL)
	{
		return '<small>NULL</small>';
	}
	elseif (is_bool($var))
	{
		return '<small>bool</small> '.($var ? 'TRUE' : 'FALSE');
	}
	elseif (is_float($var))
	{
		return '<small>float</small> '.$var;
	}
	elseif (is_resource($var))
	{
		if (($type = get_resource_type($var)) === 'stream' AND $meta = stream_get_meta_data($var))
		{
			$meta = stream_get_meta_data($var);

			if (isset($meta['uri']))
			{
				$file = $meta['uri'];

				if (function_exists('stream_is_local'))
				{
					// Only exists on PHP >= 5.2.4
					if (stream_is_local($file))
					{
						$file = Kohana::debug_path($file);
					}
				}

				return '<small>resource</small><span>('.$type.')</span> '.htmlspecialchars($file, ENT_NOQUOTES, Kohana::$charset);
			}
		}
		else
		{
			return '<small>resource</small><span>('.$type.')</span>';
		}
	}
	elseif (is_string($var))
	{
		// Clean invalid multibyte characters. iconv is only invoked
		// if there are non ASCII characters in the string, so this
		// isn't too much of a hit.
		$var = UTF8::clean($var, Kohana::$charset);

		if (UTF8::strlen($var) > $length)
		{
			// Encode the truncated string
			$str = htmlspecialchars(UTF8::substr($var, 0, $length), ENT_NOQUOTES, Kohana::$charset).'&nbsp;&hellip;';
		}
		else
		{
			// Encode the string
			$str = htmlspecialchars($var, ENT_NOQUOTES, Kohana::$charset);
		}

		if (Kohana::$debug_escape_quotes)
		{
			// Escape strings (for syntax highlighters, mostly)
			$str = str_replace('"', '\\"', $str);
		}

		return '<small>string</small><span>('.strlen($var).')</span> "'.$str.'"';
	}
	elseif (is_array($var))
	{
		$output = array();

		// Indentation for this variable
		$space = str_repeat($s = '    ', $level);

		static $marker;

		if ($marker === NULL)
		{
			// Make a unique marker
			$marker = uniqid("\x00");
		}

		if (empty($var))
		{
			// Do nothing
		}
		elseif (isset($var[$marker]))
		{
			$output[] = "(\n$space$s*RECURSION*\n$space)";
		}
		elseif ($level < 5)
		{
			$output[] = "<span>(";

			$var[$marker] = TRUE;
			foreach ($var as $key => & $val)
			{
				if ($key === $marker) continue;
				if ( ! is_int($key))
				{
					$key = '"'.htmlspecialchars($key, ENT_NOQUOTES, self::$charset).'"';
				}

				$output[] = "$space$s$key => ".Kohana::_dump($val, $length, $level + 1);
			}
			unset($var[$marker]);

			$output[] = "$space)</span>";
		}
		else
		{
			// Depth too great
			$output[] = "(\n$space$s...\n$space)";
		}

		return '<small>array</small><span>('.count($var).')</span> '.implode("\n", $output);
	}
	elseif (is_object($var))
	{
		// Copy the object as an array
		$array = (array) $var;

		$output = array();

		// Indentation for this variable
		$space = str_repeat($s = '    ', $level);

		$hash = spl_object_hash($var);

		// Objects that are being dumped
		static $objects = array();

		if (empty($var))
		{
			// Do nothing
		}
		elseif (isset($objects[$hash]))
		{
			$output[] = "{\n$space$s*RECURSION*\n$space}";
		}
		elseif ($level < 10)
		{
			$output[] = "<code>{";

			$objects[$hash] = TRUE;
			foreach ($array as $key => & $val)
			{
				if ($key[0] === "\x00")
				{
					// Determine if the access is protected or protected
					$access = '<small>'.(($key[1] === '*') ? 'protected' : 'private').'</small>';

					// Remove the access level from the variable name
					$key = substr($key, strrpos($key, "\x00") + 1);
				}
				else
				{
					$access = '<small>public</small>';
				}

				$output[] = "$space$s$access $key => ".Kohana::_dump($val, $length, $level + 1);
			}
			unset($objects[$hash]);

			$output[] = "$space}</code>";
		}
		else
		{
			// Depth too great
			$output[] = "{\n$space$s...\n$space}";
		}

		return '<small>object</small> <span>'.get_class($var).'('.count($array).')</span> '.implode("\n", $output);
	}
	else
	{
		return '<small>'.gettype($var).'</small> '.htmlspecialchars(print_r($var, TRUE), ENT_NOQUOTES, Kohana::$charset);
	}
}

public static auto_load( )
› Kohana_Core

Source Code

public static function auto_load($class)
{
	try
	{
		// Transform the class name into a path
		$file = str_replace('_', '/', strtolower($class));

		if ($path = Kohana::find_file('classes', $file))
		{
			// Load the class file
			require $path;

			// Class has been found
			return TRUE;
		}

		// Class is not in the filesystem
		return FALSE;
	}
	catch (Exception $e)
	{
		Kohana::exception_handler($e);
		die;
	}
}

public static cache( )
› Kohana_Core

Source Code

public static function cache($name, $data = NULL, $lifetime = NULL)
{
	// Cache file is a hash of the name
	$file = sha1($name).'.txt';

	// Cache directories are split by keys to prevent filesystem overload
	$dir = Kohana::$cache_dir.DIRECTORY_SEPARATOR.$file[0].$file[1].DIRECTORY_SEPARATOR;

	if ($lifetime === NULL)
	{
		// Use the default lifetime
		$lifetime = Kohana::$cache_life;
	}

	if ($data === NULL)
	{
		if (is_file($dir.$file))
		{
			if ((time() - filemtime($dir.$file)) < $lifetime)
			{
				// Return the cache
				try
				{
					return unserialize(file_get_contents($dir.$file));
				}
				catch (Exception $e)
				{
					// Cache is corrupt, let return happen normally.
				}
			}
			else
			{
				try
				{
					// Cache has expired
					unlink($dir.$file);
				}
				catch (Exception $e)
				{
					// Cache has mostly likely already been deleted,
					// let return happen normally.
				}
			}
		}

		// Cache not found
		return NULL;
	}

	if ( ! is_dir($dir))
	{
		// Create the cache directory
		mkdir($dir, 0777, TRUE);

		// Set permissions (must be manually set to fix umask issues)
		chmod($dir, 0777);
	}

	// Force the data to be a string
	$data = serialize($data);

	try
	{
		// Write the cache
		return (bool) file_put_contents($dir.$file, $data, LOCK_EX);
	}
	catch (Exception $e)
	{
		// Failed to write cache
		return FALSE;
	}
}

public static config( )
› Kohana_Core

Source Code

public static function config($group)
{
	static $config;

	if (strpos($group, '.') !== FALSE)
	{
		// Split the config group and path
		list ($group, $path) = explode('.', $group, 2);
	}

	if ( ! isset($config[$group]))
	{
		// Load the config group into the cache
		$config[$group] = Kohana::$config->load($group);
	}

	if (isset($path))
	{
		return Arr::path($config[$group], $path, NULL, '.');
	}
	else
	{
		return $config[$group];
	}
}

public static debug( )
› Kohana_Core

Source Code

public static function debug()
{
	if (func_num_args() === 0)
		return;

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

	$output = array();
	foreach ($variables as $var)
	{
		$output[] = Kohana::_dump($var, 1024);
	}

	return '<pre class="debug">'.implode("\n", $output).'</pre>';
}

public static debug_path( )
› Kohana_Core

Source Code

public static function debug_path($file)
{
	if (strpos($file, APPPATH) === 0)
	{
		$file = 'APPPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(APPPATH));
	}
	elseif (strpos($file, SYSPATH) === 0)
	{
		$file = 'SYSPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(SYSPATH));
	}
	elseif (strpos($file, MODPATH) === 0)
	{
		$file = 'MODPATH'.DIRECTORY_SEPARATOR.substr($file, strlen(MODPATH));
	}
	elseif (strpos($file, DOCROOT) === 0)
	{
		$file = 'DOCROOT'.DIRECTORY_SEPARATOR.substr($file, strlen(DOCROOT));
	}

	return $file;
}

public static debug_source( )
› Kohana_Core

Source Code

public static function debug_source($file, $line_number, $padding = 5)
{
	if ( ! $file OR ! is_readable($file))
	{
		// Continuing will cause errors
		return FALSE;
	}

	// 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);

	// Set the zero-padding amount for line numbers
	$format = '% '.strlen($range['end']).'d';

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

		if ($line >= $range['start'])
		{
			// Make the row safe for output
			$row = htmlspecialchars($row, ENT_NOQUOTES, Kohana::$charset);

			// Trim whitespace and sanitize the row
			$row = '<span class="number">'.sprintf($format, $line).'</span> '.$row;

			if ($line === $line_number)
			{
				// Apply highlighting to this row
				$row = '<span class="line highlight">'.$row.'</span>';
			}
			else
			{
				$row = '<span class="line">'.$row.'</span>';
			}

			// Add to the captured source
			$source .= $row;
		}
	}

	// Close the file
	fclose($file);

	return '<pre class="source"><code>'.$source.'</code></pre>';
}

public static deinit( )
› Kohana_Core

Source Code

public static function deinit()
{
	if (Kohana::$_init)
	{
		// Removed the autoloader
		spl_autoload_unregister(array('Kohana', 'auto_load'));

		if (Kohana::$errors)
		{
			// Go back to the previous error handler
			restore_error_handler();

			// Go back to the previous exception handler
			restore_exception_handler();
		}

		// Destroy objects created by init
		Kohana::$log = Kohana::$config = NULL;

		// Reset internal storage
		Kohana::$_modules = Kohana::$_files = array();
		Kohana::$_paths   = array(APPPATH, SYSPATH);

		// Reset file cache status
		Kohana::$_files_changed = FALSE;

		// Kohana is no longer initialized
		Kohana::$_init = FALSE;
	}
}

public static dump( )
› Kohana_Core

Source Code

public static function dump($value, $length = 128)
{
	return Kohana::_dump($value, $length);
}

public static error_handler( )
› Kohana_Core

Source Code

public static function error_handler($code, $error, $file = NULL, $line = NULL)
{
	if (error_reporting() & $code)
	{
		// This error is not suppressed by current error reporting settings
		// Convert the error into an ErrorException
		throw new ErrorException($error, $code, 0, $file, $line);
	}

	// Do not execute the PHP error handler
	return TRUE;
}

public static exception_handler( )
› Kohana_Core

Source Code

public static function exception_handler(Exception $e)
{
	try
	{
		// Get the exception information
		$type    = get_class($e);
		$code    = $e->getCode();
		$message = $e->getMessage();
		$file    = $e->getFile();
		$line    = $e->getLine();

		// Create a text version of the exception
		$error = Kohana::exception_text($e);

		if (is_object(Kohana::$log))
		{
			// Add this exception to the log
			Kohana::$log->add(Kohana::ERROR, $error);

			// Make sure the logs are written
			Kohana::$log->write();
		}

		if (Kohana::$is_cli)
		{
			// Just display the text of the exception
			echo "\n{$error}\n";

			return TRUE;
		}

		// Get the exception backtrace
		$trace = $e->getTrace();

		if ($e instanceof ErrorException)
		{
			if (isset(Kohana::$php_errors[$code]))
			{
				// Use the human-readable error name
				$code = Kohana::$php_errors[$code];
			}

			if (version_compare(PHP_VERSION, '5.3', '<'))
			{
				// Workaround for a bug in ErrorException::getTrace() that exists in
				// all PHP 5.2 versions. @see http://bugs.php.net/bug.php?id=45895
				for ($i = count($trace) - 1; $i > 0; --$i)
				{
					if (isset($trace[$i - 1]['args']))
					{
						// Re-position the args
						$trace[$i]['args'] = $trace[$i - 1]['args'];

						// Remove the args
						unset($trace[$i - 1]['args']);
					}
				}
			}
		}

		if ( ! headers_sent())
		{
			// Make sure the proper content type is sent with a 500 status
			header('Content-Type: text/html; charset='.Kohana::$charset, TRUE, 500);
		}

		// Start an output buffer
		ob_start();

		// Include the exception HTML
		include Kohana::find_file('views', Kohana::$error_view);

		// Display the contents of the output buffer
		echo ob_get_clean();

		return TRUE;
	}
	catch (Exception $e)
	{
		// Clean the output buffer if one exists
		ob_get_level() and ob_clean();

		// Display the exception text
		echo Kohana::exception_text($e), "\n";

		// Exit with an error status
		exit(1);
	}
}

public static exception_text( )
› Kohana_Core

Source Code

public static function exception_text(Exception $e)
{
	return sprintf('%s [ %s ]: %s ~ %s [ %d ]',
		get_class($e), $e->getCode(), strip_tags($e->getMessage()), Kohana::debug_path($e->getFile()), $e->getLine());
}

public static find_file( )
› Kohana_Core

Source Code

public static function find_file($dir, $file, $ext = NULL, $array = FALSE)
{
	if ($ext === NULL)
	{
		// Use the default extension
		$ext = EXT;
	}
	elseif ($ext)
	{
		// Prefix the extension with a period
		$ext = ".{$ext}";
	}
	else
	{
		// Use no extension
		$ext = '';
	}

	// Create a partial path of the filename
	$path = $dir.DIRECTORY_SEPARATOR.$file.$ext;

	if (Kohana::$caching === TRUE AND isset(Kohana::$_files[$path]))
	{
		// This path has been cached
		return Kohana::$_files[$path];
	}

	if (Kohana::$profiling === TRUE AND class_exists('Profiler', FALSE))
	{
		// Start a new benchmark
		$benchmark = Profiler::start('Kohana', __FUNCTION__);
	}

	if ($array OR $dir === 'config' OR $dir === 'i18n' OR $dir === 'messages')
	{
		// Include paths must be searched in reverse
		$paths = array_reverse(Kohana::$_paths);

		// Array of files that have been found
		$found = array();

		foreach ($paths as $dir)
		{
			if (is_file($dir.$path))
			{
				// This path has a file, add it to the list
				$found[] = $dir.$path;
			}
		}
	}
	else
	{
		// The file has not been found yet
		$found = FALSE;

		foreach (Kohana::$_paths as $dir)
		{
			if (is_file($dir.$path))
			{
				// A path has been found
				$found = $dir.$path;

				// Stop searching
				break;
			}
		}
	}

	if (Kohana::$caching === TRUE)
	{
		// Add the path to the cache
		Kohana::$_files[$path] = $found;

		// Files have been changed
		Kohana::$_files_changed = TRUE;
	}

	if (isset($benchmark))
	{
		// Stop the benchmark
		Profiler::stop($benchmark);
	}

	return $found;
}

public static globals( )
› Kohana_Core

Source Code

public static function globals()
{
	if (isset($_REQUEST['GLOBALS']) OR isset($_FILES['GLOBALS']))
	{
		// Prevent malicious GLOBALS overload attack
		echo "Global variable overload attack detected! Request aborted.\n";

		// Exit with an error status
		exit(1);
	}

	// Get the variable names of all globals
	$global_variables = array_keys($GLOBALS);

	// Remove the standard global variables from the list
	$global_variables = array_diff($global_variables, array(
		'_COOKIE',
		'_ENV',
		'_GET',
		'_FILES',
		'_POST',
		'_REQUEST',
		'_SERVER',
		'_SESSION',
		'GLOBALS',
	));

	foreach ($global_variables as $name)
	{
		// Unset the global variable, effectively disabling register_globals
		unset($GLOBALS[$name]);
	}
}

public static include_paths( )
› Kohana_Core

Source Code

public static function include_paths()
{
	return Kohana::$_paths;
}

public static init( )
› Kohana_Core

Source Code

public static function init(array $settings = NULL)
{
	if (Kohana::$_init)
	{
		// Do not allow execution twice
		return;
	}

	// Kohana is now initialized
	Kohana::$_init = TRUE;

	if (isset($settings['profile']))
	{
		// Enable profiling
		Kohana::$profiling = (bool) $settings['profile'];
	}

	// Start an output buffer
	ob_start();

	if (defined('E_DEPRECATED'))
	{
		// E_DEPRECATED only exists in PHP >= 5.3.0
		Kohana::$php_errors[E_DEPRECATED] = 'Deprecated';
	}

	if (isset($settings['errors']))
	{
		// Enable error handling
		Kohana::$errors = (bool) $settings['errors'];
	}

	if (Kohana::$errors === TRUE)
	{
		// Enable Kohana exception handling, adds stack traces and error source.
		set_exception_handler(array('Kohana', 'exception_handler'));

		// Enable Kohana error handling, converts all PHP errors to exceptions.
		set_error_handler(array('Kohana', 'error_handler'));
	}

	// Enable the Kohana shutdown handler, which catches E_FATAL errors.
	register_shutdown_function(array('Kohana', 'shutdown_handler'));

	if (isset($settings['error_view']))
	{
		if ( ! Kohana::find_file('views', $settings['error_view']))
		{
			throw new Kohana_Exception('Error view file does not exist: views/:file', array(
				':file' => $settings['error_view'],
			));
		}

		// Change the default error rendering
		Kohana::$error_view = (string) $settings['error_view'];
	}

	if (ini_get('register_globals'))
	{
		// Reverse the effects of register_globals
		Kohana::globals();
	}

	// Determine if we are running in a command line environment
	Kohana::$is_cli = (PHP_SAPI === 'cli');

	// Determine if we are running in a Windows environment
	Kohana::$is_windows = (DIRECTORY_SEPARATOR === '\\');

	// Determine if we are running in safe mode
	Kohana::$safe_mode = (bool) ini_get('safe_mode');

	if (isset($settings['cache_dir']))
	{
		if ( ! is_dir($settings['cache_dir']))
		{
			try
			{
				// Create the cache directory
				mkdir($settings['cache_dir'], 0755, TRUE);

				// Set permissions (must be manually set to fix umask issues)
				chmod($settings['cache_dir'], 0755);
			}
			catch (Exception $e)
			{
				throw new Kohana_Exception('Could not create cache directory :dir',
					array(':dir' => Kohana::debug_path($settings['cache_dir'])));
			}
		}

		// Set the cache directory path
		Kohana::$cache_dir = realpath($settings['cache_dir']);
	}
	else
	{
		// Use the default cache directory
		Kohana::$cache_dir = APPPATH.'cache';
	}

	if ( ! is_writable(Kohana::$cache_dir))
	{
		throw new Kohana_Exception('Directory :dir must be writable',
			array(':dir' => Kohana::debug_path(Kohana::$cache_dir)));
	}

	if (isset($settings['cache_life']))
	{
		// Set the default cache lifetime
		Kohana::$cache_life = (int) $settings['cache_life'];
	}

	if (isset($settings['caching']))
	{
		// Enable or disable internal caching
		Kohana::$caching = (bool) $settings['caching'];
	}

	if (Kohana::$caching === TRUE)
	{
		// Load the file path cache
		Kohana::$_files = Kohana::cache('Kohana::find_file()');
	}

	if (isset($settings['charset']))
	{
		// Set the system character set
		Kohana::$charset = strtolower($settings['charset']);
	}

	if (function_exists('mb_internal_encoding'))
	{
		// Set the MB extension encoding to the same character set
		mb_internal_encoding(Kohana::$charset);
	}

	if (isset($settings['base_url']))
	{
		// Set the base URL
		Kohana::$base_url = rtrim($settings['base_url'], '/').'/';
	}

	if (isset($settings['index_file']))
	{
		// Set the index file
		Kohana::$index_file = trim($settings['index_file'], '/');
	}

	// Determine if the extremely evil magic quotes are enabled
	Kohana::$magic_quotes = (bool) get_magic_quotes_gpc();

	// Sanitize all request variables
	$_GET    = Kohana::sanitize($_GET);
	$_POST   = Kohana::sanitize($_POST);
	$_COOKIE = Kohana::sanitize($_COOKIE);

	// Load the logger
	Kohana::$log = Kohana_Log::instance();

	// Load the config
	Kohana::$config = Kohana_Config::instance();
}

public static list_files( )
› Kohana_Core

Source Code

public static function list_files($directory = NULL, array $paths = NULL)
{
	if ($directory !== NULL)
	{
		// Add the directory separator
		$directory .= DIRECTORY_SEPARATOR;
	}

	if ($paths === NULL)
	{
		// Use the default paths
		$paths = Kohana::$_paths;
	}

	// Create an array for the files
	$found = array();

	foreach ($paths as $path)
	{
		if (is_dir($path.$directory))
		{
			// Create a new directory iterator
			$dir = new DirectoryIterator($path.$directory);

			foreach ($dir as $file)
			{
				// Get the file name
				$filename = $file->getFilename();

				if ($filename[0] === '.' OR $filename[strlen($filename)-1] === '~')
				{
					// Skip all hidden files and UNIX backup files
					continue;
				}

				// Relative filename is the array key
				$key = $directory.$filename;

				if ($file->isDir())
				{
					if ($sub_dir = Kohana::list_files($key, $paths))
					{
						if (isset($found[$key]))
						{
							// Append the sub-directory list
							$found[$key] += $sub_dir;
						}
						else
						{
							// Create a new sub-directory list
							$found[$key] = $sub_dir;
						}
					}
				}
				else
				{
					if ( ! isset($found[$key]))
					{
						// Add new files to the list
						$found[$key] = realpath($file->getPathName());
					}
				}
			}
		}
	}

	// Sort the results alphabetically
	ksort($found);

	return $found;
}

public static load( )
› Kohana_Core

Source Code

public static function load($file)
{
	return include $file;
}

public static message( )
› Kohana_Core

Source Code

public static function message($file, $path = NULL, $default = NULL)
{
	static $messages;

	if ( ! isset($messages[$file]))
	{
		// Create a new message list
		$messages[$file] = array();

		if ($files = Kohana::find_file('messages', $file))
		{
			foreach ($files as $f)
			{
				// Combine all the messages recursively
				$messages[$file] = Arr::merge($messages[$file], Kohana::load($f));
			}
		}
	}

	if ($path === NULL)
	{
		// Return all of the messages
		return $messages[$file];
	}
	else
	{
		// Get a message using the path
		return Arr::path($messages[$file], $path, $default);
	}
}

public static modules( )
› Kohana_Core

Source Code

public static function modules(array $modules = NULL)
{
	if ($modules === NULL)
	{
		// Not changing modules, just return the current set
		return Kohana::$_modules;
	}

	// Start a new list of include paths, APPPATH first
	$paths = array(APPPATH);

	foreach ($modules as $name => $path)
	{
		if (is_dir($path))
		{
			// Add the module to include paths
			$paths[] = $modules[$name] = realpath($path).DIRECTORY_SEPARATOR;
		}
		else
		{
			// This module is invalid, remove it
			unset($modules[$name]);
		}
	}

	// Finish the include paths by adding SYSPATH
	$paths[] = SYSPATH;

	// Set the new include paths
	Kohana::$_paths = $paths;

	// Set the current module list
	Kohana::$_modules = $modules;

	foreach (Kohana::$_modules as $path)
	{
		$init = $path.'init'.EXT;

		if (is_file($init))
		{
			// Include the module initialization file once
			require_once $init;
		}
	}

	return Kohana::$_modules;
}

public static sanitize( )
› Kohana_Core

Source Code

public static function sanitize($value)
{
	if (is_array($value) OR is_object($value))
	{
		foreach ($value as $key => $val)
		{
			// Recursively clean each value
			$value[$key] = Kohana::sanitize($val);
		}
	}
	elseif (is_string($value))
	{
		if (Kohana::$magic_quotes === TRUE)
		{
			// Remove slashes added by magic quotes
			$value = stripslashes($value);
		}

		if (strpos($value, "\r") !== FALSE)
		{
			// Standardize newlines
			$value = str_replace(array("\r\n", "\r"), "\n", $value);
		}
	}

	return $value;
}

public static shutdown_handler( )
› Kohana_Core

Source Code

public static function shutdown_handler()
{
	if ( ! Kohana::$_init)
	{
		// Do not execute when not active
		return;
	}

	try
	{
		if (Kohana::$caching === TRUE AND Kohana::$_files_changed === TRUE)
		{
			// Write the file path cache
			Kohana::cache('Kohana::find_file()', Kohana::$_files);
		}
	}
	catch (Exception $e)
	{
		// Pass the exception to the handler
		Kohana::exception_handler($e);
	}

	if (Kohana::$errors AND $error = error_get_last() AND in_array($error['type'], Kohana::$shutdown_errors))
	{
		// Clean the output buffer
		ob_get_level() and ob_clean();

		// Fake an exception for nice debugging
		Kohana::exception_handler(new ErrorException($error['message'], $error['type'], 0, $error['file'], $error['line']));

		// Shutdown now to avoid a "death loop"
		exit(1);
	}
}

public static trace( )
› Kohana_Core

Source Code

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']))
		{
			// Invalid trace step
			continue;
		}

		if (isset($step['file']) AND isset($step['line']))
		{
			// Include the source of this step
			$source = Kohana::debug_source($step['file'], $step['line']);
		}

		if (isset($step['file']))
		{
			$file = $step['file'];

			if (isset($step['line']))
			{
				$line = $step['line'];
			}
		}

		// function()
		$function = $step['function'];

		if (in_array($step['function'], $statements))
		{
			if (empty($step['args']))
			{
				// No arguments
				$args = array();
			}
			else
			{
				// Sanitize the file path
				$args = array(Kohana::debug_path($step['args'][0]));
			}
		}
		elseif (isset($step['args']))
		{
			if ( ! function_exists($step['function']) OR strpos($step['function'], '{closure}') !== FALSE)
			{
				// Introspection on closures or language constructs in a stack trace is impossible
				$params = NULL;
			}
			else
			{
				if (isset($step['class']))
				{
					if (method_exists($step['class'], $step['function']))
					{
						$reflection = new ReflectionMethod($step['class'], $step['function']);
					}
					else
					{
						$reflection = new ReflectionMethod($step['class'], '__call');
					}
				}
				else
				{
					$reflection = new ReflectionFunction($step['function']);
				}

				// Get the function parameters
				$params = $reflection->getParameters();
			}

			$args = array();

			foreach ($step['args'] as $i => $arg)
			{
				if (isset($params[$i]))
				{
					// Assign the argument by the parameter name
					$args[$params[$i]->name] = $arg;
				}
				else
				{
					// Assign the argument by number
					$args[$i] = $arg;
				}
			}
		}

		if (isset($step['class']))
		{
			// Class->method() or Class::method()
			$function = $step['class'].$step['type'].$step['function'];
		}

		$output[] = array(
			'function' => $function,
			'args'     => isset($args)   ? $args : NULL,
			'file'     => isset($file)   ? $file : NULL,
			'line'     => isset($line)   ? $line : NULL,
			'source'   => isset($source) ? $source : NULL,
		);

		unset($function, $args, $file, $line, $source);
	}

	return $output;
}

Kohana_Core

Class Contents

Constants

Properties

Methods

Constants

Properties

Methods

protected static _dump( ) › Kohana_Core

Source Code

public static auto_load( ) › Kohana_Core

Source Code

public static cache( ) › Kohana_Core

Source Code

public static config( ) › Kohana_Core

Source Code

public static debug( ) › Kohana_Core

Source Code

public static debug_path( ) › Kohana_Core

Source Code

public static debug_source( ) › Kohana_Core

Source Code

public static deinit( ) › Kohana_Core

Source Code

public static dump( ) › Kohana_Core

Source Code

public static error_handler( ) › Kohana_Core

Source Code

public static exception_handler( ) › Kohana_Core

Source Code

public static exception_text( ) › Kohana_Core

Source Code

public static find_file( ) › Kohana_Core

Source Code

public static globals( ) › Kohana_Core

Source Code

public static include_paths( ) › Kohana_Core

Source Code

public static init( ) › Kohana_Core

Source Code

public static list_files( ) › Kohana_Core

Source Code

public static load( ) › Kohana_Core

Source Code

public static message( ) › Kohana_Core

Source Code

public static modules( ) › Kohana_Core

Source Code

public static sanitize( ) › Kohana_Core

Source Code

public static shutdown_handler( ) › Kohana_Core

Source Code

public static trace( ) › Kohana_Core

Source Code

protected static _dump( )
› Kohana_Core

public static auto_load( )
› Kohana_Core

public static cache( )
› Kohana_Core

public static config( )
› Kohana_Core

public static debug( )
› Kohana_Core

public static debug_path( )
› Kohana_Core

public static debug_source( )
› Kohana_Core

public static deinit( )
› Kohana_Core

public static dump( )
› Kohana_Core

public static error_handler( )
› Kohana_Core

public static exception_handler( )
› Kohana_Core

public static exception_text( )
› Kohana_Core

public static find_file( )
› Kohana_Core

public static globals( )
› Kohana_Core

public static include_paths( )
› Kohana_Core

public static init( )
› Kohana_Core

public static list_files( )
› Kohana_Core

public static load( )
› Kohana_Core

public static message( )
› Kohana_Core

public static modules( )
› Kohana_Core

public static sanitize( )
› Kohana_Core

public static shutdown_handler( )
› Kohana_Core

public static trace( )
› Kohana_Core