Subversion Repositories SmartDukaan

<?php
/**
 * DebugKit DebugToolbar Component
 *
 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link          http://cakephp.org CakePHP(tm) Project
 * @since         DebugKit 0.1
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */

App::uses('CakeLog', 'Log');
App::uses('CakeLogInterface', 'Log');
App::uses('DebugTimer', 'DebugKit.Lib');
App::uses('DebugMemory', 'DebugKit.Lib');
App::uses('HelperCollection', 'View');
App::uses('CakeEventManager', 'Event');
App::uses('CakeEventListener', 'Event');

/**
 * Class ToolbarComponent
 *
 * @since         DebugKit 0.1
 */
class ToolbarComponent extends Component implements CakeEventListener {

/**
 * Settings for the Component
 *
 * - forceEnable - Force the toolbar to display even if debug == 0. Default = false
 * - autoRun - Automatically display the toolbar. If set to false, toolbar display can be triggered by adding
 *    `?debug=true` to your URL.
 *
 * @var array
 */
        public $settings = array(
                'forceEnable' => false,
                'autoRun' => true
        );

/**
 * Controller instance reference
 *
 * @var object
 */
        public $controller;

/**
 * Components used by DebugToolbar
 *
 * @var array
 */
        public $components = array('RequestHandler', 'Session');

/**
 * The default panels the toolbar uses.
 * which panels are used can be configured when attaching the component
 *
 * @var array
 */
        protected $_defaultPanels = array(
                'DebugKit.History',
                'DebugKit.Session',
                'DebugKit.Request',
                'DebugKit.SqlLog',
                'DebugKit.Timer',
                'DebugKit.Log',
                'DebugKit.Variables',
                'DebugKit.Environment',
                'DebugKit.Include'
        );

/**
 * Loaded panel objects.
 *
 * @var array
 */
        public $panels = array();

/**
 * javascript files component will be using
 *
 * @var array
 */
        public $javascript = array(
                'libs' => 'DebugKit./js/js_debug_toolbar'
        );

/**
 * CSS files component will be using
 *
 * @var array
 */
        public $css = array('DebugKit./css/debug_toolbar.css');

/**
 * CacheKey used for the cache file.
 *
 * @var string
 */
        public $cacheKey = 'toolbar_cache';

/**
 * Duration of the debug kit history cache
 *
 * @var string
 */
        public $cacheDuration = '+4 hours';

/**
 * Status whether component is enable or disable
 *
 * @var boolean
 */
        public $enabled = true;

/**
 * Constructor
 *
 * If debug is off the component will be disabled and not do any further time tracking
 * or load the toolbar helper.
 *
 * @param ComponentCollection $collection
 * @param array $settings
 * @return \ToolbarComponent
 */
        public function __construct(ComponentCollection $collection, $settings = array()) {
                $settings = array_merge((array)Configure::read('DebugKit'), $settings);
                $panels = $this->_defaultPanels;
                if (isset($settings['panels'])) {
                        $panels = $this->_makePanelList($settings['panels']);
                        unset($settings['panels']);
                }
                $this->controller = $collection->getController();

                parent::__construct($collection, array_merge($this->settings, (array)$settings));

                if (
                        !Configure::read('debug') &&
                        empty($this->settings['forceEnable'])
                ) {
                        $this->enabled = false;
                        return false;
                }
                if (
                        $this->settings['autoRun'] === false &&
                        !isset($this->controller->request->query['debug'])
                ) {
                        $this->enabled = false;
                        return false;
                }

                $this->controller->getEventManager()->attach($this);

                DebugMemory::record(__d('debug_kit', 'Component initialization'));

                $this->cacheKey .= $this->Session->read('Config.userAgent');
                if (
                        in_array('DebugKit.History', $panels) ||
                        (isset($settings['history']) && $settings['history'] !== false)
                ) {
                        $this->_createCacheConfig();
                }

                $this->_loadPanels($panels, $settings);
                return false;
        }

/**
 * Register all the timing handlers for core events.
 *
 * @return array
 */
        public function implementedEvents() {
                $before = function ($name) {
                        return function () use ($name) {
                                DebugTimer::start($name, __d('debug_kit', $name));
                        };
                };
                $after = function ($name) {
                        return function () use ($name) {
                                DebugTimer::stop($name);
                        };
                };

                return array(
                        'Controller.initialize' => array(
                                array('priority' => 0, 'callable' => $before('Event: Controller.initialize')),
                                array('priority' => 999, 'callable' => $after('Event: Controller.initialize'))
                        ),
                        'Controller.startup' => array(
                                array('priority' => 0, 'callable' => $before('Event: Controller.startup')),
                                array('priority' => 999, 'callable' => $after('Event: Controller.startup'))
                        ),
                        'Controller.beforeRender' => array(
                                array('priority' => 0, 'callable' => $before('Event: Controller.beforeRender')),
                                array('priority' => 999, 'callable' => $after('Event: Controller.beforeRender'))
                        ),
                        'Controller.shutdown' => array(
                                array('priority' => 0, 'callable' => $before('Event: Controller.shutdown')),
                                array('priority' => 999, 'callable' => $after('Event: Controller.shutdown'))
                        ),
                        'View.beforeRender' => array(
                                array('priority' => 0, 'callable' => $before('Event: View.beforeRender')),
                                array('priority' => 999, 'callable' => $after('Event: View.beforeRender'))
                        ),
                        'View.afterRender' => array(
                                array('priority' => 0, 'callable' => $before('Event: View.afterRender')),
                                array('priority' => 999, 'callable' => $after('Event: View.afterRender'))
                        ),
                        'View.beforeLayout' => array(
                                array('priority' => 0, 'callable' => $before('Event: View.beforeLayout')),
                                array('priority' => 999, 'callable' => $after('Event: View.beforeLayout'))
                        ),
                        'View.afterLayout' => array(
                                array('priority' => 0, 'callable' => $before('Event: View.afterLayout')),
                                array('priority' => 999, 'callable' => $after('Event: View.afterLayout'))
                        ),
                );
        }

/**
 * Initialize callback.
 * If automatically disabled, tell component collection about the state.
 *
 * @param Controller $controller
 * @return boolean
 */
        public function initialize(Controller $controller) {
                if (!$this->enabled) {
                        $this->_Collection->disable('Toolbar');
                }
        }

/**
 * Go through user panels and remove default panels as indicated.
 *
 * @param array $userPanels The list of panels ther user has added removed.
 * @return array Array of panels to use.
 */
        protected function _makePanelList($userPanels) {
                $panels = $this->_defaultPanels;
                foreach ($userPanels as $key => $value) {
                        if (is_numeric($key)) {
                                $panels[] = $value;
                        }
                        if (is_string($key) && $value === false) {
                                $index = array_search($key, $panels);
                                if ($index !== false) {
                                        unset($panels[$index]);
                                }
                                // Compatibility for when panels were not
                                // required to have a plugin prefix.
                                $alternate = 'DebugKit.' . ucfirst($key);
                                $index = array_search($alternate, $panels);
                                if ($index !== false) {
                                        unset($panels[$index]);
                                }
                        }
                }
                return $panels;
        }

/**
 * Component Startup
 *
 * @param Controller $controller
 * @return boolean
 */
        public function startup(Controller $controller) {
                $panels = array_keys($this->panels);
                foreach ($panels as $panelName) {
                        $this->panels[$panelName]->startup($controller);
                }
                DebugTimer::start(
                        'controllerAction',
                        __d('debug_kit', 'Controller action')
                );
                DebugMemory::record(
                        __d('debug_kit', 'Controller action start')
                );
        }

/**
 * beforeRedirect callback
 *
 * @param Controller $controller
 * @param $url
 * @param null $status
 * @param boolean $exit
 * @return void
 */
        public function beforeRedirect(Controller $controller, $url, $status = null, $exit = true) {
                if (!class_exists('DebugTimer')) {
                        return null;
                }
                DebugTimer::stop('controllerAction');
                DebugTimer::start(
                        'processToolbar',
                        __d('debug_kit', 'Processing toolbar state')
                );
                $vars = $this->_gatherVars($controller);
                $this->_saveState($controller, $vars);
                DebugTimer::stop('processToolbar');
        }

/**
 * beforeRender callback
 *
 * Calls beforeRender on all the panels and set the aggregate to the controller.
 *
 * @param Controller $controller
 * @return void
 */
        public function beforeRender(Controller $controller) {
                if (!class_exists('DebugTimer')) {
                        return null;
                }
                DebugTimer::stop('controllerAction');

                DebugTimer::start(
                        'processToolbar',
                        __d('debug_kit', 'Processing toolbar data')
                );
                $vars = $this->_gatherVars($controller);
                $this->_saveState($controller, $vars);

                $this->javascript = array_unique(array_merge($this->javascript, $vars['javascript']));
                $this->css = array_unique(array_merge($this->css, $vars['css']));
                unset($vars['javascript'], $vars['css']);

                $controller->set(array(
                        'debugToolbarPanels' => $vars,
                        'debugToolbarJavascript' => $this->javascript,
                        'debugToolbarCss' => $this->css
                ));

                $isHtml = (
                        !isset($controller->request->params['ext']) ||
                        $controller->request->params['ext'] === 'html'
                );

                if (!$controller->request->is('ajax') && $isHtml) {
                        $format = 'Html';
                } else {
                        $format = 'FirePhp';
                }

                $controller->helpers[] = 'DebugKit.DebugTimer';
                $controller->helpers['DebugKit.Toolbar'] = array(
                        'output' => sprintf('DebugKit.%sToolbar', $format),
                        'cacheKey' => $this->cacheKey,
                        'cacheConfig' => 'debug_kit',
                        'forceEnable' => $this->settings['forceEnable'],
                );

                DebugTimer::stop('processToolbar');
                DebugMemory::record(__d('debug_kit', 'Controller render start'));
        }

/**
 * Load a toolbar state from cache
 *
 * @param integer $key
 * @return array
 */
        public function loadState($key) {
                $history = Cache::read($this->cacheKey, 'debug_kit');
                if (isset($history[$key])) {
                        return $history[$key];
                }
                return array();
        }

/**
 * Create the cache config for the history
 *
 * @return void
 */
        protected function _createCacheConfig() {
                if (Configure::read('Cache.disable') === true || Cache::config('debug_kit')) {
                        return;
                }
                $cache = array(
                    'duration' => $this->cacheDuration,
                    'engine' => 'File',
                    'path' => CACHE
                );
                if (isset($this->settings['cache'])) {
                        $cache = array_merge($cache, $this->settings['cache']);
                }
                Cache::config('debug_kit', $cache);
        }

/**
 * collects the panel contents
 *
 * @param Controller $controller
 * @return array Array of all panel beforeRender()
 */
        protected function _gatherVars(Controller $controller) {
                $vars = array('javascript' => array(), 'css' => array());
                $panels = array_keys($this->panels);

                foreach ($panels as $panelName) {
                        $panel = $this->panels[$panelName];
                        $panelName = Inflector::underscore($panelName);
                        $vars[$panelName]['content'] = $panel->beforeRender($controller);
                        $elementName = Inflector::underscore($panelName) . '_panel';
                        if (isset($panel->elementName)) {
                                $elementName = $panel->elementName;
                        }
                        $vars[$panelName]['elementName'] = $elementName;
                        $vars[$panelName]['plugin'] = $panel->plugin;
                        $vars[$panelName]['title'] = $panel->title;
                        $vars[$panelName]['disableTimer'] = true;

                        if (!empty($panel->javascript)) {
                                $vars['javascript'] = array_merge($vars['javascript'], (array)$panel->javascript);
                        }
                        if (!empty($panel->css)) {
                                $vars['css'] = array_merge($vars['css'], (array)$panel->css);
                        }
                }
                return $vars;
        }

/**
 * Load Panels used in the debug toolbar
 *
 * @param $panels
 * @param $settings
 * @return void
 */
        protected function _loadPanels($panels, $settings) {
                foreach ($panels as $panel) {
                        $className = ucfirst($panel) . 'Panel';
                        list($plugin, $className) = pluginSplit($className, true);

                        App::uses($className, $plugin . 'Panel');
                        if (!class_exists($className)) {
                                trigger_error(__d('debug_kit', 'Could not load DebugToolbar panel %s', $panel), E_USER_WARNING);
                                continue;
                        }
                        $panelObj = new $className($settings);
                        if ($panelObj instanceof DebugPanel) {
                                list(, $panel) = pluginSplit($panel);
                                $this->panels[Inflector::underscore($panel)] = $panelObj;
                        }
                }
        }

/**
 * Save the current state of the toolbar varibles to the cache file.
 *
 * @param \Controller|object $controller Controller instance
 * @param array $vars Vars to save.
 * @return void
 */
        protected function _saveState(Controller $controller, $vars) {
                $config = Cache::config('debug_kit');
                if (empty($config) || !isset($this->panels['history'])) {
                        return;
                }
                $history = Cache::read($this->cacheKey, 'debug_kit');
                if (empty($history)) {
                        $history = array();
                }
                if (count($history) == $this->panels['history']->history) {
                        array_pop($history);
                }

                if (isset($vars['variables']['content'])) {
                        // Remove unserializable native objects.
                        array_walk_recursive($vars['variables']['content'], function (&$item) {
                                if (
                                        $item instanceof Closure ||
                                        $item instanceof PDO ||
                                        $item instanceof SimpleXmlElement
                                ) {
                                        $item = 'Unserializable object - ' . get_class($item);
                                } elseif ($item instanceof Exception) {
                                        $item = sprintf(
                                                'Unserializable object - %s. Error: %s in %s, line %s',
                                                get_class($item),
                                                $item,
                                                $item->getMessage(),
                                                $item->getFile(),
                                                $item->getLine()
                                        );
                                }
                                return $item;
                        });
                }
                unset($vars['history']);
                array_unshift($history, $vars);
                Cache::write($this->cacheKey, $history, 'debug_kit');
        }

}