library/Smarty/libs/sysplugins/smarty_internal_debug.php

   1 <?php
   2 /**
   3  * Smarty Internal Plugin Debug
   4  * Class to collect data for the Smarty Debugging Consol
   5  *
   6  * @package    Smarty
   7  * @subpackage Debug
   8  * @author     Uwe Tews
   9  */
  10
  11 /**
  12  * Smarty Internal Plugin Debug Class
  13  *
  14  * @package    Smarty
  15  * @subpackage Debug
  16  */
  17 class Smarty_Internal_Debug extends Smarty_Internal_Data
  18 {
  19     /**
  20      * template data
  21      *
  22      * @var array
  23      */
  24     public static $template_data = array();
  25
  26     /**
  27      * List of uid's which shall be ignored
  28      *
  29      * @var array
  30      */
  31     public static $ignore_uid = array();
  32
  33     /**
  34      * Ignore template
  35      *
  36      * @param object $template
  37      */
  38     public static function ignore($template)
  39     {
  40         // calculate Uid if not already done
  41         if ($template->source->uid == '') {
  42             $template->source->filepath;
  43         }
  44         self::$ignore_uid[$template->source->uid] = true;
  45     }
  46
  47     /**
  48      * Start logging of compile time
  49      *
  50      * @param object $template
  51      */
  52     public static function start_compile($template)
  53     {
  54         static $_is_stringy = array('string' => true, 'eval' => true);
  55         if (!empty($template->compiler->trace_uid)) {
  56             $key = $template->compiler->trace_uid;
  57             if (!isset(self::$template_data[$key])) {
  58                 if (isset($_is_stringy[$template->source->type])) {
  59                     self::$template_data[$key]['name'] = '\'' . substr($template->source->name, 0, 25) . '...\'';
  60                 } else {
  61                     self::$template_data[$key]['name'] = $template->source->filepath;
  62                 }
  63                 self::$template_data[$key]['compile_time'] = 0;
  64                 self::$template_data[$key]['render_time'] = 0;
  65                 self::$template_data[$key]['cache_time'] = 0;
  66             }
  67         } else {
  68             if (isset(self::$ignore_uid[$template->source->uid])) {
  69                 return;
  70             }
  71             $key = self::get_key($template);
  72         }
  73         self::$template_data[$key]['start_time'] = microtime(true);
  74     }
  75
  76     /**
  77      * End logging of compile time
  78      *
  79      * @param object $template
  80      */
  81     public static function end_compile($template)
  82     {
  83         if (!empty($template->compiler->trace_uid)) {
  84             $key = $template->compiler->trace_uid;
  85         } else {
  86             if (isset(self::$ignore_uid[$template->source->uid])) {
  87                 return;
  88             }
  89
  90             $key = self::get_key($template);
  91         }
  92         self::$template_data[$key]['compile_time'] += microtime(true) - self::$template_data[$key]['start_time'];
  93     }
  94
  95     /**
  96      * Start logging of render time
  97      *
  98      * @param object $template
  99      */
 100     public static function start_render($template)
 101     {
 102         $key = self::get_key($template);
 103         self::$template_data[$key]['start_time'] = microtime(true);
 104     }
 105
 106     /**
 107      * End logging of compile time
 108      *
 109      * @param object $template
 110      */
 111     public static function end_render($template)
 112     {
 113         $key = self::get_key($template);
 114         self::$template_data[$key]['render_time'] += microtime(true) - self::$template_data[$key]['start_time'];
 115     }
 116
 117     /**
 118      * Start logging of cache time
 119      *
 120      * @param object $template cached template
 121      */
 122     public static function start_cache($template)
 123     {
 124         $key = self::get_key($template);
 125         self::$template_data[$key]['start_time'] = microtime(true);
 126     }
 127
 128     /**
 129      * End logging of cache time
 130      *
 131      * @param object $template cached template
 132      */
 133     public static function end_cache($template)
 134     {
 135         $key = self::get_key($template);
 136         self::$template_data[$key]['cache_time'] += microtime(true) - self::$template_data[$key]['start_time'];
 137     }
 138
 139     /**
 140      * Opens a window for the Smarty Debugging Consol and display the data
 141      *
 142      * @param Smarty_Internal_Template|Smarty $obj object to debug
 143      */
 144     public static function display_debug($obj)
 145     {
 146         // prepare information of assigned variables
 147         $ptr = self::get_debug_vars($obj);
 148         if ($obj instanceof Smarty) {
 149             $smarty = clone $obj;
 150         } else {
 151             $smarty = clone $obj->smarty;
 152         }
 153         $_assigned_vars = $ptr->tpl_vars;
 154         ksort($_assigned_vars);
 155         $_config_vars = $ptr->config_vars;
 156         ksort($_config_vars);
 157         $smarty->registered_filters = array();
 158         $smarty->autoload_filters = array();
 159         $smarty->default_modifiers = array();
 160         $smarty->force_compile = false;
 161         $smarty->left_delimiter = '{';
 162         $smarty->right_delimiter = '}';
 163         $smarty->debugging = false;
 164         $smarty->debugging_ctrl = 'NONE';
 165         $smarty->force_compile = false;
 166         $_template = new Smarty_Internal_Template($smarty->debug_tpl, $smarty);
 167         $_template->caching = false;
 168         $_template->disableSecurity();
 169         $_template->cache_id = null;
 170         $_template->compile_id = null;
 171         if ($obj instanceof Smarty_Internal_Template) {
 172             $_template->assign('template_name', $obj->source->type . ':' . $obj->source->name);
 173         }
 174         if ($obj instanceof Smarty) {
 175             $_template->assign('template_data', self::$template_data);
 176         } else {
 177             $_template->assign('template_data', null);
 178         }
 179         $_template->assign('assigned_vars', $_assigned_vars);
 180         $_template->assign('config_vars', $_config_vars);
 181         $_template->assign('execution_time', microtime(true) - $smarty->start_time);
 182         echo $_template->fetch();
 183     }
 184
 185     /**
 186      * Recursively gets variables from all template/data scopes
 187      *
 188      * @param  Smarty_Internal_Template|Smarty_Data $obj object to debug
 189      *
 190      * @return StdClass
 191      */
 192     public static function get_debug_vars($obj)
 193     {
 194         $config_vars = $obj->config_vars;
 195         $tpl_vars = array();
 196         foreach ($obj->tpl_vars as $key => $var) {
 197             $tpl_vars[$key] = clone $var;
 198             if ($obj instanceof Smarty_Internal_Template) {
 199                 $tpl_vars[$key]->scope = $obj->source->type . ':' . $obj->source->name;
 200             } elseif ($obj instanceof Smarty_Data) {
 201                 $tpl_vars[$key]->scope = 'Data object';
 202             } else {
 203                 $tpl_vars[$key]->scope = 'Smarty root';
 204             }
 205         }
 206
 207         if (isset($obj->parent)) {
 208             $parent = self::get_debug_vars($obj->parent);
 209             $tpl_vars = array_merge($parent->tpl_vars, $tpl_vars);
 210             $config_vars = array_merge($parent->config_vars, $config_vars);
 211         } else {
 212             foreach (Smarty::$global_tpl_vars as $name => $var) {
 213                 if (!array_key_exists($name, $tpl_vars)) {
 214                     $clone = clone $var;
 215                     $clone->scope = 'Global';
 216                     $tpl_vars[$name] = $clone;
 217                 }
 218             }
 219         }
 220
 221         return (object) array('tpl_vars' => $tpl_vars, 'config_vars' => $config_vars);
 222     }
 223
 224     /**
 225      * Return key into $template_data for template
 226      *
 227      * @param  object $template template object
 228      *
 229      * @return string key into $template_data
 230      */
 231     private static function get_key($template)
 232     {
 233         static $_is_stringy = array('string' => true, 'eval' => true);
 234         // calculate Uid if not already done
 235         if ($template->source->uid == '') {
 236             $template->source->filepath;
 237         }
 238         $key = $template->source->uid;
 239         if (isset(self::$template_data[$key])) {
 240             return $key;
 241         } else {
 242             if (isset($_is_stringy[$template->source->type])) {
 243                 self::$template_data[$key]['name'] = '\'' . substr($template->source->name, 0, 25) . '...\'';
 244             } else {
 245                 self::$template_data[$key]['name'] = $template->source->filepath;
 246             }
 247             self::$template_data[$key]['compile_time'] = 0;
 248             self::$template_data[$key]['render_time'] = 0;
 249             self::$template_data[$key]['cache_time'] = 0;
 250
 251             return $key;
 252         }
 253     }
 254 }