Changeset 651

Timestamp:

10/04/2007 07:44:36 PM (14 months ago)

Author:

Shadowhand

Message:

A few small changes:

• Replaced the "pre_output" Event with "output"
  
• The "output" event can now load views during execution
  
• Completely re-organized Bootstrap to use Event, instead function calls
  
• Added hook loading support, and config/hooks.php
  
• Added Event::get($name) and Event::clean($name, $callback)
  

More spit shine too.

Location:

trunk

Files:

• application/config/config.php (modified) (1 diff)
• application/config/hooks.php (added)
• system/core/Bootstrap.php (modified) (4 diffs)
• system/core/Event.php (modified) (3 diffs)
• system/core/Kohana.php (modified) (8 diffs)
• system/libraries/Session.php (modified) (1 diff)

trunk/application/config/config.php

@@ -96 +96 @@
 /*
 | -----------------------------------------------------------------------------
-| Enable Hooks (EXPERT!)
-| -----------------------------------------------------------------------------
-|
-| User Guide: http://kohanaphp.com/user_guide/en/general/hooks.html
-|
-*/
-$config['enable_hooks'] = FALSE;
-
-/*
-| -----------------------------------------------------------------------------
 | Extension Prefix
 | -----------------------------------------------------------------------------

trunk/system/core/Bootstrap.php

@@ -14 +14 @@
  * @since            Version 2.0
  * @filesource
- */
-
-// ----------------------------------------------------------------------------
-
-/**
- * Kohana Bootstrapping
  *
  * $Id$
@@ -37 +31 @@
 
 // Load core classes
-require SYSPATH.'core/Config'.EXT;
-require SYSPATH.'core/Event'.EXT;
 require SYSPATH.'core/Kohana'.EXT;
-require SYSPATH.'core/Log'.EXT;
-// Load UTF-8 compatible string functions
-require SYSPATH.'core/utf8'.EXT;
 
-// Run Kohana's setup routine
-// This registers the Kohana handlers and prepares the output buffer
-Kohana::setup();
-
-// Run system.ready event
-Event::run('system.ready');
+// Run system.prepare event
+// This sets up Kohana's PHP hooks, output buffering, error handling, etc
+Event::run('system.setup');
 
 // Stop base class loading benchmark
@@ -56 +42 @@
 Benchmark::start(SYSTEM_BENCHMARK.'_system_initialization');
 
-// Run Router's setup routine
+// Run system.ready event
+Event::run('system.ready');
+
+// Run system.routing
 // All routing is performed at this stage
-Router::setup();
-
-// Run system.initialize
-Event::run('system.initialize');
+Event::run('system.routing');
 
 // Stop system initialization benchmark
@@ -68 +54 @@
 Benchmark::start(SYSTEM_BENCHMARK.'_controller_execution');
 
-try
-{
-        // Load the controller
-        Kohana::instance();
-
-        // Run system.ready_controller
-        Event::run('system.ready_controller');
-
-        /**
-         * @todo This needs to check for _remap and _default, as well as validating that method exists
-         */
-        $controller = Kohana::instance();
-
-        if (method_exists($controller, '_remap'))
-        {
-                // Change arguments to be $method, $arguments.
-                // This makes _remap capable of being a much more effecient dispatcher
-                Router::$arguments = array(Router::$method, Router::$arguments);
-                // Set the method to _remap
-                Router::$method = '_remap';
-        }
-        elseif (method_exists($controller, Router::$method))
-        {
-                (Router::$method !== 'kohana_include_view') or trigger_error
-                (
-                        'This method cannot be accessed directly.',
-                        E_USER_ERROR
-                );
-        }
-        elseif (method_exists($controller, '_default'))
-        {
-                // Change arguments to be $method, $arguments.
-                // This makes _default a much more effecient 404 handler
-                Router::$arguments = array(Router::$method, Router::$arguments);
-                // Set the method to _default
-                Router::$method = '_default';
-        }
-        else
-        {
-                $controller->show_404();
-        }
-        if (count(Router::$arguments) > 0)
-        {
-                call_user_func_array(array(Kohana::instance(), Router::$method), Router::$arguments);
-        }
-        else
-        {
-                call_user_func(array(Kohana::instance(), Router::$method));
-        }
-
-        // Run system.post_controller
-        Event::run('system.post_controller');
-
-        // Make sure that $controller is not available globally
-        unset($controller);
-}
-catch (controller_not_found $exception)
-{
-        die('Controller not found: '.$exception);
-}
+// Run system.execute
+// The controller is loaded and executed at this point
+Event::run('system.execute');
 
 // Stop the controller execution benchmark
 Benchmark::stop(SYSTEM_BENCHMARK.'_controller_execution');
+
+// Manually flush the output buffer to allow loading views in the system.output event
+Kohana::display();

trunk/system/core/Event.php

@@ -25 +25 @@
 final class Event {
 
-        public static $events = array();
+        private static $events = array();
 
         /**
@@ -40 +40 @@
                         return FALSE;
 
+                if (empty(self::$events[$name]))
+                        self::$events[$name] = array();
+
+                if (in_array($callback, self::$events))
+                        return FALSE;
+
                 self::$events[$name][] = $callback;
+        }
+
+
+        /**
+         * Fetch events
+         *
+         * @access public
+         * @param  string
+         * @return mixed
+         */
+        public static function get($name)
+        {
+                return empty(self::$events[$name]) ? array() : self::$events[$name];
+        }
+
+        /**
+         * Clear an event
+         *
+         * @access public
+         * @param  string
+         * @param  callback
+         * @return void
+         */
+        public static function clear($name, $callback = FALSE)
+        {
+                if ($callback == FALSE)
+                {
+                        self::$events[$name] = array();
+                }
+                else
+                {
+                        if (isset(self::$events[$name]))
+                        {
+                                foreach(self::$events[$name] as $i => $event_callback)
+                                {
+                                        if ($callback == $event_callback)
+                                        {
+                                                unset(self::$events[$name][$i]);
+                                        }
+                                }
+                        }
+                }
         }
 
@@ -51 +99 @@
          * @return  mixed
          */
-        public static function run($name, $args = array())
+        public static function run($name)
         {
                 if ($name == FALSE)
                         return FALSE;
 
-                if (isset(self::$events[$name]) AND count(self::$events[$name]))
+                $args = func_get_args();
+                $args = (empty($args) OR count($args) == 1) ? array() : array_slice($args, 1);
+
+                foreach(self::get($name) as $callback)
                 {
-                        foreach(array_reverse(self::$events[$name]) as $event)
-                        {
-                                if ($args == TRUE)
-                                {
-                                        call_user_func_array($event, (array) $args);
-                                }
-                                else
-                                {
-                                        call_user_func($event);
-                                }
-                        }
+                        call_user_func_array($callback, $args);
                 }
         }

trunk/system/core/Kohana.php

@@ -16 +16 @@
  */
 
-// ----------------------------------------------------------------------------
+require SYSPATH.'core/utf8'.EXT;
+require SYSPATH.'core/Event'.EXT;
+require SYSPATH.'core/Config'.EXT;
+require SYSPATH.'core/Log'.EXT;
+
+Event::add('system.setup', array('Kohana', 'setup'));
 
 /**
@@ -127 +132 @@
                 set_exception_handler(array('Kohana', 'exception_handler'));
 
-                // Enable log writing if the log threshold is enabled
-                (Config::item('log.threshold') > 0) and Event::add('system.shutdown', array('Log', 'write'));
-
                 // Set shutdown handler to run the 'system.shutdown' event
                 register_shutdown_function(array('Event', 'run'), 'system.shutdown');
@@ -143 +145 @@
                 }
 
+                if ($hooks = Config::item('hooks.enable'))
+                {
+                        // All hooks are enabled, we must build an array of filenames
+                        if ( ! is_array($hooks))
+                        {
+                                $hooks = array();
+                                foreach(Config::include_paths() as $path)
+                                {
+                                        $files = glob($path.'hooks/*'.EXT);
+
+                                        if ( ! empty($files))
+                                        {
+                                                $hooks = array_merge($hooks, $files);
+                                        }
+                                }
+                        }
+
+                        // Loop through all the hooks and load them
+                        foreach($hooks as $file)
+                        {
+                                Log::add('debug', 'Loading hook'.$file);
+                                include $file;
+                        }
+                }
+
+                // Enable log writing if the log threshold is enabled
+                if(Config::item('log.threshold') > 0)
+                {
+                        Event::add('system.shutdown', array('Log', 'write'));
+                }
+
+                // Enable routing
+                Event::add('system.routing', array('Router', 'setup'));
+
+                // Enabel loading a Kohana instance
+                Event::add('system.execute', array('Kohana', 'instance'));
+
                 // Setup is complete
                 $run = TRUE;
@@ -160 +199 @@
                 if (self::$instance == FALSE)
                 {
-                        require (Router::$directory.Router::$controller.EXT);
+                        // Run system.pre_controller
+                        Event::run('system.pre_controller');
+
+                        // Include the Controller file
+                        require Router::$directory.Router::$controller.EXT;
 
                         // Set controller class name
                         $controller = ucfirst(Router::$controller).'_Controller';
 
-                        // Load the controller
-                        $controller = new $controller();
+                        try
+                        {
+                                // Load the controller
+                                $controller = new $controller();
+                        }
+                        catch (Kohana_Exception $exception)
+                        {
+                                Kohana::show_404();
+                                return;
+                        }
+
+                        if (method_exists($controller, '_remap'))
+                        {
+                                // Change arguments to be $method, $arguments.
+                                // This makes _remap capable of being a much more effecient dispatcher
+                                Router::$arguments = array(Router::$method, Router::$arguments);
+                                // Set the method to _remap
+                                Router::$method = '_remap';
+                        }
+                        elseif (method_exists($controller, Router::$method))
+                        {
+                                (Router::$method !== 'kohana_include_view') or trigger_error
+                                (
+                                        'This method cannot be accessed directly.',
+                                        E_USER_ERROR
+                                );
+                        }
+                        elseif (method_exists($controller, '_default'))
+                        {
+                                // Change arguments to be $method, $arguments.
+                                // This makes _default a much more effecient 404 handler
+                                Router::$arguments = array(Router::$method, Router::$arguments);
+                                // Set the method to _default
+                                Router::$method = '_default';
+                        }
+                        else
+                        {
+                                $controller->show_404();
+                        }
+                        if (count(Router::$arguments) > 0)
+                        {
+                                call_user_func_array(array(Kohana::instance(), Router::$method), Router::$arguments);
+                        }
+                        else
+                        {
+                                call_user_func(array(Kohana::instance(), Router::$method));
+                        }
+
+                        // Run system.pre_controller
+                        Event::run('system.post_controller');
                 }
 
@@ -184 +275 @@
                 $memory = function_exists('memory_get_usage') ? (memory_get_usage() / 1024 / 1024) : 0;
 
-                // Bind the output to this output
-                self::$output =& $output;
-
-                // Run the pre_output event
-                // --------------------------------------------------------------------
-                // This can be used for functions that require completion before headers
-                // are sent. One example is cookies, which are sent with the headers,
-                // and will trigger errors if you try to set them after headers.
-                // --------------------------------------------------------------------
-                Event::run('system.pre_output');
-
                 // Replace the global template variables
-                self::$output = str_replace(
+                $output = str_replace(
                         array
                         (
@@ -209 +289 @@
                                 number_format($memory, 2)
                         ),
-                        self::$output
+                        $output
                 );
 
+                self::$output = $output;
+
                 // Return the final output
-                return self::$output;
+                return $output;
+        }
+
+        public static function display()
+        {
+                // This will flush the Kohana buffer, which sets self::$output
+                ob_end_clean();
+
+                // Run the output event
+                // --------------------------------------------------------------------
+                // This can be used for functions that require completion before headers
+                // are sent. One example is cookies, which are sent with the headers,
+                // and will trigger errors if you try to set them after headers.
+                // --------------------------------------------------------------------
+                Event::run('system.output');
+
+                print self::$output;
         }
 
@@ -289 +387 @@
                         $exception->getLine()
                 );
+        }
+
+        public static function show_404()
+        {
+                $message = Kohana::lang('core.page_not_found', '/'.Router::$current_uri.Config::item('core.url_suffix').Router::$query_string);
+
+                // Log the error
+                Log::add('file_not_found', $message);
+
+                if (ob_get_level() > self::$buffer_level)
+                {
+                        // Flush the entire buffer here, to ensure the error is displayed
+                        while(ob_get_level() > self::$buffer_level) ob_end_clean();
+                }
+
+                // Clear out the output buffer
+                ob_clean();
+
+                // Send the 404 header
+                header('HTTP/1.1 404 File Not Found');
+
+                // Load the error page
+                include self::find_file('views', 'kohana_404');
+
+                // Display the buffer and exit
+                ob_end_flush();
+                exit;
         }
 
@@ -504 +629 @@
         }
 
-        /**
-         * Hook Loader
-         *
-         * @access public
-         * @param  string
-         * @return void
-         */
-        public static function load_hook($name)
-        {
-                if (Config::item('core.enable_hooks') AND $hook = self::find_file('hooks', $name))
-                {
-                        require $hook;
-                }
-        }
-
-        public static function callback($callback, $params = FALSE)
-        {
-                if (is_string($callback))
-                {
-                        if ($params == FALSE)
-                        {
-                                return $callback();
-                        }
-                        elseif (is_array($params))
-                        {
-                                return call_user_func_array($callback, $params);
-                        }
-                        else
-                        {
-                                return $callback($params);
-                        }
-                }
-                else
-                {
-                        if (is_array($params) AND $params != FALSE)
-                        {
-                                return call_user_func_array($callback, $params);
-                        }
-                        else
-                        {
-                                return call_user_func($callback);
-                        }
-                }
-        }
-
-        public static function show_404()
-        {
-                $message = Kohana::lang('core.page_not_found', '/'.Router::$current_uri.Config::item('core.url_suffix').Router::$query_string);
-
-                // Log the error
-                Log::add('file_not_found', $message);
-
-                // Flush the entire buffer here, to ensure the error is displayed
-                while(ob_get_level()) ob_end_clean();
-
-                // Re-start the buffer
-                ob_start(array('Kohana', 'output'));
-
-                // Send the 404 header
-                header('HTTP/1.1 404 File Not Found');
-
-                // Load the error page
-                include self::find_file('views', 'kohana_404');
-
-                // Display the buffer and exit
-                ob_end_flush();
-                exit;
-        }
-
 } // End Kohana class
 

trunk/system/libraries/Session.php

@@ -93 +93 @@
 
                 // Close the session just before flushing the output buffer
-                Event::add('system.pre_output', 'session_write_close');
+                Event::add('system.output', 'session_write_close');
 
                 Log::add('debug', 'Session Class Initialized');