Changeset 3160

Timestamp:

07/20/2008 11:03:48 AM (5 months ago)

Author:

Shadowhand

Message:

WARNING! This change makes a massive break in backwards compatibility!

Changes to core:

• Config core class merged into Kohana: config, config_load, include_paths, config_clear
  
• Log core class merged into Kohana: log, log_save, log_directory
  
• Kohana::locale and l10n files removed
  
• log config file removed, log_threshold and log_directory moved to core configuration
  
• Kohana::cache and Kohana::cache_save now require a lifetime to be passed
  
• Kohana::show_error removed
  
• Optimizations applied to Kohana:: methods
  

Location:

trunk/system

Files:

• config/log.php (deleted)
• core/Bootstrap.php (modified) (1 diff)
• core/Config.php (deleted)
• core/Kohana.php (modified) (37 diffs)
• core/Log.php (deleted)
• helpers/cookie.php (modified) (2 diffs)
• helpers/download.php (modified) (1 diff)
• helpers/email.php (modified) (1 diff)
• helpers/file.php (modified) (1 diff)
• helpers/html.php (modified) (1 diff)
• helpers/inflector.php (modified) (3 diffs)
• helpers/request.php (modified) (1 diff)
• helpers/upload.php (modified) (4 diffs)
• helpers/url.php (modified) (3 diffs)
• helpers/valid.php (modified) (1 diff)
• l10n (deleted)
• libraries/Cache.php (modified) (4 diffs)
• libraries/Captcha.php (modified) (3 diffs)
• libraries/Database.php (modified) (3 diffs)
• libraries/Encrypt.php (modified) (2 diffs)
• libraries/Image.php (modified) (1 diff)
• libraries/Input.php (modified) (5 diffs)
• libraries/Pagination.php (modified) (3 diffs)
• libraries/Profiler.php (modified) (2 diffs)
• libraries/Router.php (modified) (5 diffs)
• libraries/Session.php (modified) (3 diffs)
• libraries/View.php (modified) (1 diff)
• libraries/drivers/Cache/Apc.php (modified) (1 diff)
• libraries/drivers/Cache/Eaccelerator.php (modified) (1 diff)
• libraries/drivers/Cache/File.php (modified) (2 diffs)
• libraries/drivers/Cache/Memcache.php (modified) (3 diffs)
• libraries/drivers/Cache/Sqlite.php (modified) (2 diffs)
• libraries/drivers/Cache/Xcache.php (modified) (4 diffs)
• libraries/drivers/Database.php (modified) (2 diffs)
• libraries/drivers/Database/Mssql.php (modified) (1 diff)
• libraries/drivers/Database/Mysql.php (modified) (1 diff)
• libraries/drivers/Database/Mysqli.php (modified) (1 diff)
• libraries/drivers/Database/Pdosqlite.php (modified) (3 diffs)
• libraries/drivers/Database/Pgsql.php (modified) (1 diff)
• libraries/drivers/Session/Cache.php (modified) (4 diffs)
• libraries/drivers/Session/Cookie.php (modified) (2 diffs)
• libraries/drivers/Session/Database.php (modified) (3 diffs)

trunk/system/core/Bootstrap.php

@@ -31 +31 @@
 // Load core files
 require SYSPATH.'core/utf8'.EXT;
-require SYSPATH.'core/Config'.EXT;
-require SYSPATH.'core/Log'.EXT;
 require SYSPATH.'core/Event'.EXT;
 require SYSPATH.'core/Kohana'.EXT;

trunk/system/core/Kohana.php

@@ -10 +10 @@
  * @license    http://kohanaphp.com/license.html
  */
-class Kohana {
+final class Kohana {
 
         // The singleton instance of the controller
@@ -16 +16 @@
 
         // Output buffering level
-        private static $buffer_level = 0;
+        private static $buffer_level;
 
         // Will be set to TRUE when an exception is caught
@@ -25 +25 @@
 
         // The current user agent
-        public static $user_agent = '';
+        public static $user_agent;
 
         // The current locale
-        public static $locale = '';
-
-        // File path cache
-        private static $paths;
-        private static $paths_changed = FALSE;
+        public static $locale;
+
+        // Configuration
+        private static $configuration;
+
+        // Include paths
+        private static $include_paths;
+
+        // Logged messages
+        private static $log;
+
+        // Log levels
+        private static $log_levels = array
+        (
+                'error' => 1,
+                'alert' => 2,
+                'info'  => 3,
+                'debug' => 4,
+        );
+
+        // Internal caches and write status
+        private static $internal_cache = array();
+        private static $write_cache;
 
         /**
@@ -48 +66 @@
          * @return  void
          */
-        final public static function setup()
+        public static function setup()
         {
                 static $run;
@@ -76 +94 @@
                 if (function_exists('date_default_timezone_set'))
                 {
-                        $timezone = Config::item('locale.timezone');
+                        $timezone = Kohana::config('locale.timezone');
 
                         // Set default timezone, due to increased validation of date settings
@@ -87 +105 @@
 
                 // Start output buffering
-                ob_start(array('Kohana', 'output_buffer'));
+                ob_start(array(__CLASS__, 'output_buffer'));
 
                 // Save buffering level
                 self::$buffer_level = ob_get_level();
 
-                // Load path cache
-                self::$paths = Kohana::load_cache('file_paths');
+                if ($lifetime = self::config('core.internal_cache'))
+                {
+                        // Load cached configuration and include paths
+                        self::$internal_cache['configuration'] = self::cache('configuration', $lifetime);
+                        self::$internal_cache['include_paths'] = self::cache('include_paths', $lifetime);
+
+                        // Enable cache saving
+                        Event::add('system.shutdown', array(__CLASS__, 'internal_cache_save'));
+                }
 
                 // Set autoloader
@@ -112 +137 @@
 
                 // Load locales
-                $locales = Config::item('locale.language');
+                $locales = self::config('locale.language');
 
                 // Make first locale UTF-8
@@ -120 +145 @@
                 self::$locale = setlocale(LC_ALL, $locales);
 
-                if (Config::item('log.threshold') > 0)
-                {
-                        // Get the configured log directory
-                        $log_dir = Config::item('log.directory');
-
-                        if ( ! is_dir($log_dir))
-                        {
-                                // Application log directory
-                                $log_dir = APPPATH.$log_dir;
-                        }
-
+                if (self::$configuration['core']['log_threshold'] > 0)
+                {
                         // Set the log directory
-                        Log::directory($log_dir);
-
-                        // Enable log writing if the log threshold is above 0
-                        register_shutdown_function(array('Log', 'write'));
+                        self::log_directory(self::$configuration['core']['log_directory']);
+
+                        // Enable log writing at shutdown
+                        register_shutdown_function(array(__CLASS__, 'log_save'));
                 }
 
@@ -151 +167 @@
                 Event::add('system.shutdown', array('Kohana', 'shutdown'));
 
-                if ($config = Config::item('hooks.enable'))
+                if ($config = Kohana::config('hooks.enable'))
                 {
                         $hooks = array();
@@ -173 +189 @@
                                         {
                                                 // This should never happen
-                                                Log::add('error', 'Hook not found: '.$name);
+                                                Kohana::log('error', 'Hook not found: '.$name);
                                         }
                                 }
@@ -192 +208 @@
                                 {
                                         // This should never happen
-                                        Log::add('error', 'Hook not found: '.$hook);
+                                        Kohana::log('error', 'Hook not found: '.$hook);
                                 }
                         }
@@ -213 +229 @@
          * @return  object  instance of controller
          */
-        final public static function & instance()
+        public static function & instance()
         {
                 if (self::$instance === NULL)
@@ -325 +341 @@
 
         /**
+         * Get all include paths. APPPATH is the first path, followed by module
+         * paths in the order they are configured, follow by the SYSPATH.
+         *
+         * @param   boolean  re-process the include paths
+         * @return  array
+         */
+        public static function include_paths($process = FALSE)
+        {
+                if ($process === TRUE)
+                {
+                        // Add APPPATH as the first path
+                        self::$include_paths = array(APPPATH);
+
+                        foreach (self::$configuration['core']['modules'] as $path)
+                        {
+                                if ($path = str_replace('\\', '/', realpath($path)))
+                                {
+                                        // Add a valid path
+                                        self::$include_paths[] = $path.'/';
+                                }
+                        }
+
+                        // Add SYSPATH as the last path
+                        self::$include_paths[] = SYSPATH;
+                }
+
+                return self::$include_paths;
+        }
+
+        /**
+         * Get a config item or group.
+         *
+         * @param   string   item name
+         * @param   boolean  force a forward slash (/) at the end of the item
+         * @param   boolean  is the item required?
+         * @return  mixed
+         */
+        public static function config($key, $slash = FALSE)
+        {
+                if (self::$configuration === NULL)
+                {
+                        // Load core configuration
+                        self::$configuration['core'] = self::config_load('core');
+
+                        // Re-parse the include paths
+                        self::include_paths(TRUE);
+                }
+
+                // Get the group name from the key
+                $group = explode('.', $key, 2);
+                $group = $group[0];
+
+                if ( ! isset(self::$configuration[$group]))
+                {
+                        // Load the configuration group
+                        self::$configuration[$group] = self::config_load($group);
+                }
+
+                // Get the value of the key string
+                $value = self::key_string(self::$configuration, $key);
+
+                if ($slash === TRUE AND is_string($value) AND $value !== '')
+                {
+                        // Force the value to end with "/"
+                        $value = rtrim($value, '/').'/';
+                }
+
+                return $value;
+        }
+
+        /**
+         * Load a config file.
+         *
+         * @param   string   config filename, without extension
+         * @return  array
+         */
+        public static function config_load($name)
+        {
+                if ($name === 'core')
+                {
+                        // Load the application configuration file
+                        require APPPATH.'config/config'.EXT;
+
+                        if ( ! isset($config['site_domain']))
+                        {
+                                // Invalid config file
+                                die('Your Kohana application configuration file is not valid.');
+                        }
+
+                        return $config;
+                }
+
+                if (isset(self::$internal_cache['configuration'][$name]))
+                        return self::$internal_cache['configuration'][$name];
+
+                // Load matching configs
+                $configuration = array();
+
+                if ($files = self::find_file('config', $name, TRUE))
+                {
+                        foreach ($files as $file)
+                        {
+                                require $file;
+
+                                if (isset($config) AND is_array($config))
+                                {
+                                        // Merge in configuration
+                                        $configuration = array_merge($configuration, $config);
+                                }
+                        }
+                }
+
+                if ( ! isset(self::$write_cache['configuration']))
+                {
+                        // Cache has changed
+                        self::$write_cache['configuration'] = TRUE;
+                }
+
+                return self::$internal_cache['configuration'][$name] = $configuration;
+        }
+
+        /**
+         * Clears a config group from the cached configuration.
+         *
+         * @param   string  config group
+         * @return  void
+         */
+        public static function config_clear($group)
+        {
+                // Remove the group from config
+                unset(self::$configuration[$group], self::$internal_cache['configuration'][$group]);
+
+                if ( ! isset(self::$write_cache['configuration']))
+                {
+                        // Cache has changed
+                        self::$write_cache['configuration'] = TRUE;
+                }
+        }
+
+        /**
+         * Add a new message to the log.
+         *
+         * @param   string  type of message
+         * @param   string  message text
+         * @return  void
+         */
+        public static function log($type, $message)
+        {
+                if (self::$log_levels[$type] <= self::$configuration['core']['log_threshold'])
+                {
+                        self::$log[] = array(date('Y-m-d H:i:s P'), $type, $message);
+                }
+        }
+
+        /**
+         * Save all currently logged messages.
+         *
+         * @return  void
+         */
+        public static function log_save()
+        {
+                if (empty(self::$log))
+                        return;
+
+                // Filename of the log
+                $filename = self::log_directory().date('Y-m-d').'.log'.EXT;
+
+                if ( ! file_exists($filename))
+                {
+                        // Write the SYSPATH checking header
+                        file_put_contents($filename,
+                                '<?php defined(\'SYSPATH\') or die(\'No direct script access.\'); ?>'.PHP_EOL.PHP_EOL);
+
+                        // Prevent external writes
+                        chmod($filename, 0644);
+                }
+
+                // Messages to write
+                $messages = array();
+
+                do
+                {
+                        // Load the next mess
+                        list ($date, $type, $text) = array_shift(self::$log);
+
+                        // Add a new message line
+                        $messages[] = $date.' --- '.$type.': '.$text;
+                }
+                while ( ! empty(self::$log));
+
+                // Write messages to log file
+                file_put_contents($filename, implode(PHP_EOL, $messages).PHP_EOL, FILE_APPEND);
+        }
+
+        /**
+         * Get or set the logging directory.
+         *
+         * @param   string  new log directory
+         * @return  string
+         */
+        public static function log_directory($dir = NULL)
+        {
+                static $directory;
+
+                if ( ! empty($dir))
+                {
+                        // Get the directory path
+                        $dir = realpath($dir);
+
+                        if (file_exists($dir) AND is_dir($dir) AND is_writable($dir))
+                        {
+                                // Change the log directory
+                                $directory = str_replace('\\', '/', $dir).'/';
+                        }
+                        else
+                        {
+                                // Log directory is invalid
+                                throw new Kohana_Exception('core.log_dir_unwritable', $dir);
+                        }
+                }
+
+                return $directory;
+        }
+
+        /**
+         * Load data from a simple cache file. This should only be used internally,
+         * and is NOT a replacement for the Cache library.
+         *
+         * @param   string   unique name of cache
+         * @param   integer  lifetime of cache
+         * @return  mixed
+         */
+        public static function cache($name, $lifetime)
+        {
+                if ($lifetime > 0)
+                {
+                        $path = APPPATH.'cache/kohana_'.$name;
+
+                        if (file_exists($path))
+                        {
+                                // Check the file modification time
+                                if ((time() - filemtime($path)) < $lifetime)
+                                {
+                                        // Cache is valid
+                                        return unserialize(file_get_contents($path));
+                                }
+                                else
+                                {
+                                        // Cache is invalid, delete it
+                                        unlink($path);
+                                }
+                        }
+                }
+
+                // No cache found
+                return NULL;
+        }
+
+        /**
+         * Save data to a simple cache file. This should only be used internally, and
+         * is NOT a replacement for the Cache library.
+         *
+         * @param   string  cache name
+         * @param   mixed   data to cache
+         * @return  boolean
+         */
+        public static function cache_save($name, $data, $lifetime)
+        {
+                if ($lifetime > 0)
+                {
+                        $path = APPPATH.'cache/kohana_'.$name;
+
+                        if ($data === NULL)
+                        {
+                                // Delete cache
+                                return (file_exists($path) and unlink($path));
+                        }
+                        else
+                        {
+                                // Write data to cache file
+                                return (bool) file_put_contents($path, serialize($data));
+                        }
+                }
+                else
+                {
+                        // No caching enabled
+                        return FALSE;
+                }
+        }
+
+        /**
          * Kohana output handler.
          *
@@ -330 +637 @@
          * @return  string
          */
-        final public static function output_buffer($output)
-        {
-                // Run the send_headers event, specifically for cookies being set
-                Event::has_run('system.send_headers') or Event::run('system.send_headers');
+        public static function output_buffer($output)
+        {
+                if ( ! Event::has_run('system.send_headers'))
+                {
+                        // Run the send_headers event, specifically for cookies being set
+                        Event::run('system.send_headers');
+                }
 
                 // Set final output
@@ -364 +674 @@
                         // This will flush the Kohana buffer, which sets self::$output
                         ob_end_clean();
+
+                        // Reset the buffer level
+                        self::$buffer_level = ob_get_level();
                 }
         }
@@ -398 +711 @@
                 $benchmark = Benchmark::get(SYSTEM_BENCHMARK.'_total_execution');
 
-                if (Config::item('core.render_stats') === TRUE)
+                if (Kohana::config('core.render_stats') === TRUE)
                 {
                         // Replace the global template variables
@@ -422 +735 @@
                 }
 
-                if ($level = Config::item('core.output_compression') AND ini_get('output_handler') !== 'ob_gzhandler' AND (int) ini_get('zlib.output_compression') === 0)
+                if ($level = Kohana::config('core.output_compression') AND ini_get('output_handler') !== 'ob_gzhandler' AND (int) ini_get('zlib.output_compression') === 0)
                 {
                         if ($level < 1 OR $level > 9)
@@ -473 +786 @@
 
         /**
+         * Displays a 404 page.
+         *
+         * @throws  Kohana_404_Exception
+         * @param   string  URI of page
+         * @param   string  custom template
+         * @return  void
+         */
+        public static function show_404($page = FALSE, $template = FALSE)
+        {
+                throw new Kohana_404_Exception($page, $template);
+        }
+
+        /**
          * Dual-purpose PHP error and exception handler. Uses the kohana_error_page
          * view to display the message.
@@ -513 +839 @@
                 if (is_numeric($code))
                 {
-                        $codes = Kohana::lang('errors');
+                        $codes = self::lang('errors');
 
                         if ( ! empty($codes[$code]))
@@ -538 +864 @@
                 $file = preg_replace('|^'.preg_quote(DOCROOT).'|', '', $file);
 
-                if (Config::item('log.threshold') >= $level)
+                if ($level >= self::$configuration['core']['log_threshold'])
                 {
                         // Log the error
-                        Log::add('error', Kohana::lang('core.uncaught_exception', $type, $message, $file, $line));
+                        self::log('error', self::lang('core.uncaught_exception', $type, $message, $file, $line));
                 }
 
                 if ($PHP_ERROR)
                 {
-                        $description = Kohana::lang('errors.'.E_RECOVERABLE_ERROR);
+                        $description = self::lang('errors.'.E_RECOVERABLE_ERROR);
                         $description = is_array($description) ? $description[2] : '';
                 }
                 else
                 {
-                        if (method_exists($exception, 'sendHeaders'))
+                        if (method_exists($exception, 'sendHeaders') AND ! headers_sent())
               &nbs