dwoo-project / dwoo

lib/Dwoo/Core.php

Indentation +1530 added lines, -1530 removed lines

@@ -31,23 +31,23 @@ 
  */
 class Dwoo_Core
 {
-    /**
-     * current version number
-     *
-     * @var string
-     */
-    const VERSION = '1.2.2';
-
-    /**
-     * unique number of this dwoo release
-     *
-     * this can be used by templates classes to check whether the compiled template
-     * has been compiled before this release or not, so that old templates are
-     * recompiled automatically when Dwoo is updated
-     */
-    const RELEASE_TAG = 17;
-
-    /**#@+
+	/**
+	 * current version number
+	 *
+	 * @var string
+	 */
+	const VERSION = '1.2.2';
+
+	/**
+	 * unique number of this dwoo release
+	 *
+	 * this can be used by templates classes to check whether the compiled template
+	 * has been compiled before this release or not, so that old templates are
+	 * recompiled automatically when Dwoo is updated
+	 */
+	const RELEASE_TAG = 17;
+
+	/**#@+
      * constants that represents all plugin types
      *
      * these are bitwise-operation-safe values to allow multiple types
@@ -55,436 +55,436 @@ 
      *
      * @var int
      */
-    const CLASS_PLUGIN = 1;
-    const FUNC_PLUGIN = 2;
-    const NATIVE_PLUGIN = 4;
-    const BLOCK_PLUGIN = 8;
-    const COMPILABLE_PLUGIN = 16;
-    const CUSTOM_PLUGIN = 32;
-    const SMARTY_MODIFIER = 64;
-    const SMARTY_BLOCK = 128;
-    const SMARTY_FUNCTION = 256;
-    const PROXY_PLUGIN = 512;
-    const TEMPLATE_PLUGIN = 1024;
-    /**#@-*/
-
-    /**
-     * character set of the template, used by string manipulation plugins
-     *
-     * it must be lowercase, but setCharset() will take care of that
-     *
-     * @see setCharset
-     * @see getCharset
-     * @var string
-     */
-    protected $charset = 'utf-8';
-
-    /**
-     * global variables that are accessible through $dwoo.* in the templates
-     *
-     * default values include:
-     *
-     * $dwoo.version - current version number
-     * $dwoo.ad - a Powered by Dwoo link pointing to dwoo.org
-     * $dwoo.now - the current time
-     * $dwoo.template - the current template filename
-     * $dwoo.charset - the character set used by the template
-     *
-     * on top of that, foreach and other plugins can store special values in there,
-     * see their documentation for more details.
-     *
-     * @private
-     * @var array
-     */
-    public $globals;
-
-    /**
-     * directory where the compiled templates are stored
-     *
-     * defaults to DWOO_COMPILEDIR (= dwoo_dir/compiled by default)
-     *
-     * @var string
-     */
-    protected $compileDir;
-
-    /**
-     * directory where the cached templates are stored
-     *
-     * defaults to DWOO_CACHEDIR (= dwoo_dir/cache by default)
-     *
-     * @var string
-     */
-    protected $cacheDir;
-
-    /**
-     * defines how long (in seconds) the cached files must remain valid
-     *
-     * can be overriden on a per-template basis
-     *
-     * -1 = never delete
-     * 0 = disabled
-     * >0 = duration in seconds
-     *
-     * @var int
-     */
-    protected $cacheTime = 0;
-
-    /**
-     * security policy object
-     *
-     * @var Dwoo_Security_Policy
-     */
-    protected $securityPolicy = null;
-
-    /**
-     * stores the custom plugins callbacks
-     *
-     * @see addPlugin
-     * @see removePlugin
-     * @var array
-     */
-    protected $plugins = array();
-
-    /**
-     * stores the filter callbacks
-     *
-     * @see addFilter
-     * @see removeFilter
-     * @var array
-     */
-    protected $filters = array();
-
-    /**
-     * stores the resource types and associated
-     * classes / compiler classes
-     *
-     * @var array
-     */
-    protected $resources = array
-    (
-        'file'      =>  array
-        (
-            'class'     =>  'Dwoo_Template_File',
-            'compiler'  =>  null
-        ),
-        'string'    =>  array
-        (
-            'class'     =>  'Dwoo_Template_String',
-            'compiler'  =>  null
-        )
-    );
-
-    /**
-     * the dwoo loader object used to load plugins by this dwoo instance
-     *
-     * @var Dwoo_ILoader
-     */
-    protected $loader = null;
-
-    /**
-     * currently rendered template, set to null when not-rendering
-     *
-     * @var Dwoo_ITemplate
-     */
-    protected $template = null;
-
-    /**
-     * stores the instances of the class plugins during template runtime
-     *
-     * @var array
-     */
-    protected $runtimePlugins;
-
-    /**
-     * stores the returned values during template runtime
-     *
-     * @var array
-     */
-    protected $returnData;
-
-    /**
-     * stores the data during template runtime
-     *
-     * @var array
-     * @private
-     */
-    public $data;
-
-    /**
-     * stores the current scope during template runtime
-     *
-     * this should ideally not be accessed directly from outside template code
-     *
-     * @var mixed
-     * @private
-     */
-    public $scope;
-
-    /**
-     * stores the scope tree during template runtime
-     *
-     * @var array
-     */
-    protected $scopeTree;
+	const CLASS_PLUGIN = 1;
+	const FUNC_PLUGIN = 2;
+	const NATIVE_PLUGIN = 4;
+	const BLOCK_PLUGIN = 8;
+	const COMPILABLE_PLUGIN = 16;
+	const CUSTOM_PLUGIN = 32;
+	const SMARTY_MODIFIER = 64;
+	const SMARTY_BLOCK = 128;
+	const SMARTY_FUNCTION = 256;
+	const PROXY_PLUGIN = 512;
+	const TEMPLATE_PLUGIN = 1024;
+	/**#@-*/
+
+	/**
+	 * character set of the template, used by string manipulation plugins
+	 *
+	 * it must be lowercase, but setCharset() will take care of that
+	 *
+	 * @see setCharset
+	 * @see getCharset
+	 * @var string
+	 */
+	protected $charset = 'utf-8';
+
+	/**
+	 * global variables that are accessible through $dwoo.* in the templates
+	 *
+	 * default values include:
+	 *
+	 * $dwoo.version - current version number
+	 * $dwoo.ad - a Powered by Dwoo link pointing to dwoo.org
+	 * $dwoo.now - the current time
+	 * $dwoo.template - the current template filename
+	 * $dwoo.charset - the character set used by the template
+	 *
+	 * on top of that, foreach and other plugins can store special values in there,
+	 * see their documentation for more details.
+	 *
+	 * @private
+	 * @var array
+	 */
+	public $globals;
+
+	/**
+	 * directory where the compiled templates are stored
+	 *
+	 * defaults to DWOO_COMPILEDIR (= dwoo_dir/compiled by default)
+	 *
+	 * @var string
+	 */
+	protected $compileDir;
+
+	/**
+	 * directory where the cached templates are stored
+	 *
+	 * defaults to DWOO_CACHEDIR (= dwoo_dir/cache by default)
+	 *
+	 * @var string
+	 */
+	protected $cacheDir;
+
+	/**
+	 * defines how long (in seconds) the cached files must remain valid
+	 *
+	 * can be overriden on a per-template basis
+	 *
+	 * -1 = never delete
+	 * 0 = disabled
+	 * >0 = duration in seconds
+	 *
+	 * @var int
+	 */
+	protected $cacheTime = 0;
+
+	/**
+	 * security policy object
+	 *
+	 * @var Dwoo_Security_Policy
+	 */
+	protected $securityPolicy = null;
+
+	/**
+	 * stores the custom plugins callbacks
+	 *
+	 * @see addPlugin
+	 * @see removePlugin
+	 * @var array
+	 */
+	protected $plugins = array();
+
+	/**
+	 * stores the filter callbacks
+	 *
+	 * @see addFilter
+	 * @see removeFilter
+	 * @var array
+	 */
+	protected $filters = array();
+
+	/**
+	 * stores the resource types and associated
+	 * classes / compiler classes
+	 *
+	 * @var array
+	 */
+	protected $resources = array
+	(
+		'file'      =>  array
+		(
+			'class'     =>  'Dwoo_Template_File',
+			'compiler'  =>  null
+		),
+		'string'    =>  array
+		(
+			'class'     =>  'Dwoo_Template_String',
+			'compiler'  =>  null
+		)
+	);
+
+	/**
+	 * the dwoo loader object used to load plugins by this dwoo instance
+	 *
+	 * @var Dwoo_ILoader
+	 */
+	protected $loader = null;
+
+	/**
+	 * currently rendered template, set to null when not-rendering
+	 *
+	 * @var Dwoo_ITemplate
+	 */
+	protected $template = null;
+
+	/**
+	 * stores the instances of the class plugins during template runtime
+	 *
+	 * @var array
+	 */
+	protected $runtimePlugins;
+
+	/**
+	 * stores the returned values during template runtime
+	 *
+	 * @var array
+	 */
+	protected $returnData;
+
+	/**
+	 * stores the data during template runtime
+	 *
+	 * @var array
+	 * @private
+	 */
+	public $data;
+
+	/**
+	 * stores the current scope during template runtime
+	 *
+	 * this should ideally not be accessed directly from outside template code
+	 *
+	 * @var mixed
+	 * @private
+	 */
+	public $scope;
+
+	/**
+	 * stores the scope tree during template runtime
+	 *
+	 * @var array
+	 */
+	protected $scopeTree;
+
+	/**
+	 * stores the block plugins stack during template runtime
+	 *
+	 * @var array
+	 */
+	protected $stack;
+
+	/**
+	 * stores the current block plugin at the top of the stack during template runtime
+	 *
+	 * @var Dwoo_Block_Plugin
+	 */
+	protected $curBlock;
+
+	/**
+	 * stores the output buffer during template runtime
+	 *
+	 * @var string
+	 */
+	protected $buffer;
+
+	/**
+	 * stores plugin proxy
+	 *
+	 * @var Dwoo_IPluginProxy
+	 */
+	protected $pluginProxy;
+
+	/**
+	 * constructor, sets the cache and compile dir to the default values if not provided
+	 *
+	 * @param string $compileDir path to the compiled directory, defaults to lib/compiled
+	 * @param string $cacheDir path to the cache directory, defaults to lib/cache
+	 */
+	public function __construct($compileDir = null, $cacheDir = null)
+	{
+		if ($compileDir !== null) {
+			$this->setCompileDir($compileDir);
+		}
+		if ($cacheDir !== null) {
+			$this->setCacheDir($cacheDir);
+		}
+		$this->initGlobals();
+	}
+
+	/**
+	 * resets some runtime variables to allow a cloned object to be used to render sub-templates
+	 */
+	public function __clone()
+	{
+		$this->template = null;
+		unset($this->data);
+		unset($this->returnData);
+	}
+
+	/**
+	 * outputs the template instead of returning it, this is basically a shortcut for get(*, *, *, true)
+	 *
+	 * @see get
+	 * @param mixed $tpl template, can either be a Dwoo_ITemplate object (i.e. Dwoo_Template_File), a valid path to a template, or
+	 *                   a template as a string it is recommended to provide a Dwoo_ITemplate as it will probably make things faster,
+	 *                   especially if you render a template multiple times
+	 * @param mixed $data the data to use, can either be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array. if you're
+	 *                    rendering the template from cache, it can be left null
+	 * @param Dwoo_ICompiler $compiler the compiler that must be used to compile the template, if left empty a default
+	 *                                Dwoo_Compiler will be used.
+	 * @return string nothing or the template output if $output is true
+	 */
+	public function output($tpl, $data = array(), Dwoo_ICompiler $compiler = null)
+	{
+		return $this->get($tpl, $data, $compiler, true);
+	}
+
+	/**
+	 * returns the given template rendered using the provided data and optional compiler
+	 *
+	 * @param mixed $tpl template, can either be a Dwoo_ITemplate object (i.e. Dwoo_Template_File), a valid path to a template, or
+	 *                   a template as a string it is recommended to provide a Dwoo_ITemplate as it will probably make things faster,
+	 *                   especially if you render a template multiple times
+	 * @param mixed $data the data to use, can either be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array. if you're
+	 *                    rendering the template from cache, it can be left null
+	 * @param Dwoo_ICompiler $compiler the compiler that must be used to compile the template, if left empty a default
+	 *                                Dwoo_Compiler will be used.
+	 * @param bool $output flag that defines whether the function returns the output of the template (false, default) or echoes it directly (true)
+	 * @return string nothing or the template output if $output is false
+	 */
+	public function get($_tpl, $data = array(), $_compiler = null, $_output = false)
+	{
+		// a render call came from within a template, so we need a new dwoo instance in order to avoid breaking this one
+		if ($this->template instanceof Dwoo_ITemplate) {
+			$clone = clone $this;
+			return $clone->get($_tpl, $data, $_compiler, $_output);
+		}
+
+		// auto-create template if required
+		if ($_tpl instanceof Dwoo_ITemplate) {
+			// valid, skip
+		} elseif (is_string($_tpl) && file_exists($_tpl)) {
+			$_tpl = new Dwoo_Template_File($_tpl);
+		} else {
+			throw new Dwoo_Exception('Dwoo->get/Dwoo->output\'s first argument must be a Dwoo_ITemplate (i.e. Dwoo_Template_File) or a valid path to a template file', E_USER_NOTICE);
+		}
+
+		// save the current template, enters render mode at the same time
+		// if another rendering is requested it will be proxied to a new Dwoo_Core(instance
+		$this->template = $_tpl;
+
+		// load data
+		if ($data instanceof Dwoo_IDataProvider) {
+			$this->data = $data->getData();
+		} elseif (is_array($data)) {
+			$this->data = $data;
+		} elseif ($data instanceof ArrayAccess) {
+			$this->data = $data;
+		} else {
+			throw new Dwoo_Exception('Dwoo->get/Dwoo->output\'s data argument must be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array', E_USER_NOTICE);
+		}
+
+		$this->globals['template'] = $_tpl->getName();
+		$this->initRuntimeVars($_tpl);
+
+		// try to get cached template
+		$file = $_tpl->getCachedTemplate($this);
+		$doCache = $file === true;
+		$cacheLoaded = is_string($file);
+
+		if ($cacheLoaded === true) {
+			// cache is present, run it
+			if ($_output === true) {
+				include $file;
+				$this->template = null;
+			} else {
+				ob_start();
+				include $file;
+				$this->template = null;
+				return ob_get_clean();
+			}
+		} else {
+			// no cache present
+			if ($doCache === true) {
+				$dynamicId = uniqid();
+			}
 
-    /**
-     * stores the block plugins stack during template runtime
-     *
-     * @var array
-     */
-    protected $stack;
+			// render template
+			$compiledTemplate = $_tpl->getCompiledTemplate($this, $_compiler);
+			$out = include $compiledTemplate;
 
-    /**
-     * stores the current block plugin at the top of the stack during template runtime
-     *
-     * @var Dwoo_Block_Plugin
-     */
-    protected $curBlock;
+			// template returned false so it needs to be recompiled
+			if ($out === false) {
+				$_tpl->forceCompilation();
+				$compiledTemplate = $_tpl->getCompiledTemplate($this, $_compiler);
+				$out = include $compiledTemplate;
+			}
 
-    /**
-     * stores the output buffer during template runtime
-     *
-     * @var string
-     */
-    protected $buffer;
+			if ($doCache === true) {
+				$out = preg_replace('/(<%|%>|<\?php|<\?|\?>)/', '<?php /*'.$dynamicId.'*/ echo \'$1\'; ?>', $out);
+				if (!class_exists('Dwoo_plugin_dynamic', false)) {
+					$this->getLoader()->loadPlugin('dynamic');
+				}
+				$out = Dwoo_Plugin_dynamic::unescape($out, $dynamicId, $compiledTemplate);
+			}
 
-    /**
-     * stores plugin proxy
-     *
-     * @var Dwoo_IPluginProxy
-     */
-    protected $pluginProxy;
+			// process filters
+			foreach ($this->filters as $filter) {
+				if (is_array($filter) && $filter[0] instanceof Dwoo_Filter) {
+					$out = call_user_func($filter, $out);
+				} else {
+					$out = call_user_func($filter, $this, $out);
+				}
+			}
 
-    /**
-     * constructor, sets the cache and compile dir to the default values if not provided
-     *
-     * @param string $compileDir path to the compiled directory, defaults to lib/compiled
-     * @param string $cacheDir path to the cache directory, defaults to lib/cache
-     */
-    public function __construct($compileDir = null, $cacheDir = null)
-    {
-        if ($compileDir !== null) {
-            $this->setCompileDir($compileDir);
-        }
-        if ($cacheDir !== null) {
-            $this->setCacheDir($cacheDir);
-        }
-        $this->initGlobals();
-    }
-
-    /**
-     * resets some runtime variables to allow a cloned object to be used to render sub-templates
-     */
-    public function __clone()
-    {
-        $this->template = null;
-        unset($this->data);
-        unset($this->returnData);
-    }
-
-    /**
-     * outputs the template instead of returning it, this is basically a shortcut for get(*, *, *, true)
-     *
-     * @see get
-     * @param mixed $tpl template, can either be a Dwoo_ITemplate object (i.e. Dwoo_Template_File), a valid path to a template, or
-     *                   a template as a string it is recommended to provide a Dwoo_ITemplate as it will probably make things faster,
-     *                   especially if you render a template multiple times
-     * @param mixed $data the data to use, can either be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array. if you're
-     *                    rendering the template from cache, it can be left null
-     * @param Dwoo_ICompiler $compiler the compiler that must be used to compile the template, if left empty a default
-     *                                Dwoo_Compiler will be used.
-     * @return string nothing or the template output if $output is true
-     */
-    public function output($tpl, $data = array(), Dwoo_ICompiler $compiler = null)
-    {
-        return $this->get($tpl, $data, $compiler, true);
-    }
+			if ($doCache === true) {
+				// building cache
+				$file = $_tpl->cache($this, $out);
 
-    /**
-     * returns the given template rendered using the provided data and optional compiler
-     *
-     * @param mixed $tpl template, can either be a Dwoo_ITemplate object (i.e. Dwoo_Template_File), a valid path to a template, or
-     *                   a template as a string it is recommended to provide a Dwoo_ITemplate as it will probably make things faster,
-     *                   especially if you render a template multiple times
-     * @param mixed $data the data to use, can either be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array. if you're
-     *                    rendering the template from cache, it can be left null
-     * @param Dwoo_ICompiler $compiler the compiler that must be used to compile the template, if left empty a default
-     *                                Dwoo_Compiler will be used.
-     * @param bool $output flag that defines whether the function returns the output of the template (false, default) or echoes it directly (true)
-     * @return string nothing or the template output if $output is false
-     */
-    public function get($_tpl, $data = array(), $_compiler = null, $_output = false)
-    {
-        // a render call came from within a template, so we need a new dwoo instance in order to avoid breaking this one
-        if ($this->template instanceof Dwoo_ITemplate) {
-            $clone = clone $this;
-            return $clone->get($_tpl, $data, $_compiler, $_output);
-        }
-
-        // auto-create template if required
-        if ($_tpl instanceof Dwoo_ITemplate) {
-            // valid, skip
-        } elseif (is_string($_tpl) && file_exists($_tpl)) {
-            $_tpl = new Dwoo_Template_File($_tpl);
-        } else {
-            throw new Dwoo_Exception('Dwoo->get/Dwoo->output\'s first argument must be a Dwoo_ITemplate (i.e. Dwoo_Template_File) or a valid path to a template file', E_USER_NOTICE);
-        }
-
-        // save the current template, enters render mode at the same time
-        // if another rendering is requested it will be proxied to a new Dwoo_Core(instance
-        $this->template = $_tpl;
-
-        // load data
-        if ($data instanceof Dwoo_IDataProvider) {
-            $this->data = $data->getData();
-        } elseif (is_array($data)) {
-            $this->data = $data;
-        } elseif ($data instanceof ArrayAccess) {
-            $this->data = $data;
-        } else {
-            throw new Dwoo_Exception('Dwoo->get/Dwoo->output\'s data argument must be a Dwoo_IDataProvider object (i.e. Dwoo_Data) or an associative array', E_USER_NOTICE);
-        }
-
-        $this->globals['template'] = $_tpl->getName();
-        $this->initRuntimeVars($_tpl);
-
-        // try to get cached template
-        $file = $_tpl->getCachedTemplate($this);
-        $doCache = $file === true;
-        $cacheLoaded = is_string($file);
-
-        if ($cacheLoaded === true) {
-            // cache is present, run it
-            if ($_output === true) {
-                include $file;
-                $this->template = null;
-            } else {
-                ob_start();
-                include $file;
-                $this->template = null;
-                return ob_get_clean();
-            }
-        } else {
-            // no cache present
-            if ($doCache === true) {
-                $dynamicId = uniqid();
-            }
-
-            // render template
-            $compiledTemplate = $_tpl->getCompiledTemplate($this, $_compiler);
-            $out = include $compiledTemplate;
-
-            // template returned false so it needs to be recompiled
-            if ($out === false) {
-                $_tpl->forceCompilation();
-                $compiledTemplate = $_tpl->getCompiledTemplate($this, $_compiler);
-                $out = include $compiledTemplate;
-            }
-
-            if ($doCache === true) {
-                $out = preg_replace('/(<%|%>|<\?php|<\?|\?>)/', '<?php /*'.$dynamicId.'*/ echo \'$1\'; ?>', $out);
-                if (!class_exists('Dwoo_plugin_dynamic', false)) {
-                    $this->getLoader()->loadPlugin('dynamic');
-                }
-                $out = Dwoo_Plugin_dynamic::unescape($out, $dynamicId, $compiledTemplate);
-            }
-
-            // process filters
-            foreach ($this->filters as $filter) {
-                if (is_array($filter) && $filter[0] instanceof Dwoo_Filter) {
-                    $out = call_user_func($filter, $out);
-                } else {
-                    $out = call_user_func($filter, $this, $out);
-                }
-            }
-
-            if ($doCache === true) {
-                // building cache
-                $file = $_tpl->cache($this, $out);
-
-                // run it from the cache to be sure dynamics are rendered
-                if ($_output === true) {
-                    include $file;
-                    // exit render mode
-                    $this->template = null;
-                } else {
-                    ob_start();
-                    include $file;
-                    // exit render mode
-                    $this->template = null;
-                    return ob_get_clean();
-                }
-            } else {
-                // no need to build cache
-                // exit render mode
-                $this->template = null;
-                // output
-                if ($_output === true) {
-                    echo $out;
-                }
-                return $out;
-            }
-        }
-    }
-
-    /**
-     * re-initializes the globals array before each template run
-     *
-     * this method is only callede once when the Dwoo object is created
-     */
-    protected function initGlobals()
-    {
-        $this->globals = array
-        (
-            'version'   =>  self::VERSION,
-            'ad'        =>  '<a href="http://dwoo.org/">Powered by Dwoo</a>',
-            'now'       =>  $_SERVER['REQUEST_TIME'],
-            'charset'   =>  $this->charset,
-        );
-    }
-
-    /**
-     * re-initializes the runtime variables before each template run
-     *
-     * override this method to inject data in the globals array if needed, this
-     * method is called before each template execution
-     *
-     * @param Dwoo_ITemplate $tpl the template that is going to be rendered
-     */
-    protected function initRuntimeVars(Dwoo_ITemplate $tpl)
-    {
-        $this->runtimePlugins = array();
-        $this->scope =& $this->data;
-        $this->scopeTree = array();
-        $this->stack = array();
-        $this->curBlock = null;
-        $this->buffer = '';
-        $this->returnData = array();
-    }
-
-    /*
+				// run it from the cache to be sure dynamics are rendered
+				if ($_output === true) {
+					include $file;
+					// exit render mode
+					$this->template = null;
+				} else {
+					ob_start();
+					include $file;
+					// exit render mode
+					$this->template = null;
+					return ob_get_clean();
+				}
+			} else {
+				// no need to build cache
+				// exit render mode
+				$this->template = null;
+				// output
+				if ($_output === true) {
+					echo $out;
+				}
+				return $out;
+			}
+		}
+	}
+
+	/**
+	 * re-initializes the globals array before each template run
+	 *
+	 * this method is only callede once when the Dwoo object is created
+	 */
+	protected function initGlobals()
+	{
+		$this->globals = array
+		(
+			'version'   =>  self::VERSION,
+			'ad'        =>  '<a href="http://dwoo.org/">Powered by Dwoo</a>',
+			'now'       =>  $_SERVER['REQUEST_TIME'],
+			'charset'   =>  $this->charset,
+		);
+	}
+
+	/**
+	 * re-initializes the runtime variables before each template run
+	 *
+	 * override this method to inject data in the globals array if needed, this
+	 * method is called before each template execution
+	 *
+	 * @param Dwoo_ITemplate $tpl the template that is going to be rendered
+	 */
+	protected function initRuntimeVars(Dwoo_ITemplate $tpl)
+	{
+		$this->runtimePlugins = array();
+		$this->scope =& $this->data;
+		$this->scopeTree = array();
+		$this->stack = array();
+		$this->curBlock = null;
+		$this->buffer = '';
+		$this->returnData = array();
+	}
+
+	/*
      * --------- settings functions ---------
      */
 
-    /**
-     * adds a custom plugin that is not in one of the plugin directories
-     *
-     * @param string $name the plugin name to be used in the templates
-     * @param callback $callback the plugin callback, either a function name,
-     *                           a class name or an array containing an object
-     *                           or class name and a method name
-     * @param bool $compilable if set to true, the plugin is assumed to be compilable
-     */
-    public function addPlugin($name, $callback, $compilable = false)
-    {
-        $compilable = $compilable ? self::COMPILABLE_PLUGIN : 0;
-        if (is_array($callback)) {
-            if (is_subclass_of(is_object($callback[0]) ? get_class($callback[0]) : $callback[0], 'Dwoo_Block_Plugin')) {
-                $this->plugins[$name] = array('type'=>self::BLOCK_PLUGIN | $compilable, 'callback'=>$callback, 'class'=>(is_object($callback[0]) ? get_class($callback[0]) : $callback[0]));
-            } else {
-                $this->plugins[$name] = array('type'=>self::CLASS_PLUGIN | $compilable, 'callback'=>$callback, 'class'=>(is_object($callback[0]) ? get_class($callback[0]) : $callback[0]), 'function'=>$callback[1]);
-            }
-        } elseif(is_string($callback)) {
+	/**
+	 * adds a custom plugin that is not in one of the plugin directories
+	 *
+	 * @param string $name the plugin name to be used in the templates
+	 * @param callback $callback the plugin callback, either a function name,
+	 *                           a class name or an array containing an object
+	 *                           or class name and a method name
+	 * @param bool $compilable if set to true, the plugin is assumed to be compilable
+	 */
+	public function addPlugin($name, $callback, $compilable = false)
+	{
+		$compilable = $compilable ? self::COMPILABLE_PLUGIN : 0;
+		if (is_array($callback)) {
+			if (is_subclass_of(is_object($callback[0]) ? get_class($callback[0]) : $callback[0], 'Dwoo_Block_Plugin')) {
+				$this->plugins[$name] = array('type'=>self::BLOCK_PLUGIN | $compilable, 'callback'=>$callback, 'class'=>(is_object($callback[0]) ? get_class($callback[0]) : $callback[0]));
+			} else {
+				$this->plugins[$name] = array('type'=>self::CLASS_PLUGIN | $compilable, 'callback'=>$callback, 'class'=>(is_object($callback[0]) ? get_class($callback[0]) : $callback[0]), 'function'=>$callback[1]);
+			}
+		} elseif(is_string($callback)) {
 			if (class_exists($callback, false)) {
 				if (is_subclass_of($callback, 'Dwoo_Block_Plugin')) {
 					$this->plugins[$name] = array('type'=>self::BLOCK_PLUGIN | $compilable, 'callback'=>$callback, 'class'=>$callback);
@@ -499,1120 +499,1120 @@ 
 		} elseif(is_callable($callback)) {
 			$this->plugins[$name] = array('type'=>self::FUNC_PLUGIN | $compilable, 'callback'=>$callback);
 		} else {
-            throw new Dwoo_Exception('Callback could not be processed correctly, please check that the function/class you used exists');
-        }
-    }
-
-    /**
-     * removes a custom plugin
-     *
-     * @param string $name the plugin name
-     */
-    public function removePlugin($name)
-    {
-        if (isset($this->plugins[$name])) {
-            unset($this->plugins[$name]);
-        }
-    }
-
-    /**
-     * adds a filter to this Dwoo instance, it will be used to filter the output of all the templates rendered by this instance
-     *
-     * @param mixed $callback a callback or a filter name if it is autoloaded from a plugin directory
-     * @param bool $autoload if true, the first parameter must be a filter name from one of the plugin directories
-     */
-    public function addFilter($callback, $autoload = false)
-    {
-        if ($autoload) {
-            $class = 'Dwoo_Filter_'.$callback;
-
-            if (!class_exists($class, false) && !function_exists($class)) {
-                try {
-                    $this->getLoader()->loadPlugin($callback);
-                } catch (Dwoo_Exception $e) {
-                    if (strstr($callback, 'Dwoo_Filter_')) {
-                        throw new Dwoo_Exception('Wrong filter name : '.$callback.', the "Dwoo_Filter_" prefix should not be used, please only use "'.str_replace('Dwoo_Filter_', '', $callback).'"');
-                    } else {
-                        throw new Dwoo_Exception('Wrong filter name : '.$callback.', when using autoload the filter must be in one of your plugin dir as "name.php" containg a class or function named "Dwoo_Filter_name"');
-                    }
-                }
-            }
-
-            if (class_exists($class, false)) {
-                $callback = array(new $class($this), 'process');
-            } elseif (function_exists($class)) {
-                $callback = $class;
-            } else {
-                throw new Dwoo_Exception('Wrong filter name : '.$callback.', when using autoload the filter must be in one of your plugin dir as "name.php" containg a class or function named "Dwoo_Filter_name"');
-            }
-
-            $this->filters[] = $callback;
-        } else {
-            $this->filters[] = $callback;
-        }
-    }
-
-    /**
-     * removes a filter
-     *
-     * @param mixed $callback callback or filter name if it was autoloaded
-     */
-    public function removeFilter($callback)
-    {
-        if (($index = array_search('Dwoo_Filter_'.$callback, $this->filters, true)) !== false) {
-            unset($this->filters[$index]);
-        } elseif (($index = array_search($callback, $this->filters, true)) !== false) {
-            unset($this->filters[$index]);
-        } else  {
-            $class = 'Dwoo_Filter_' . $callback;
-            foreach ($this->filters as $index=>$filter) {
-                if (is_array($filter) && $filter[0] instanceof $class) {
-                    unset($this->filters[$index]);
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * adds a resource or overrides a default one
-     *
-     * @param string $name the resource name
-     * @param string $class the resource class (which must implement Dwoo_ITemplate)
-     * @param callback $compilerFactory the compiler factory callback, a function that must return a compiler instance used to compile this resource, if none is provided. by default it will produce a Dwoo_Compiler object
-     */
-    public function addResource($name, $class, $compilerFactory = null)
-    {
-        if (strlen($name) < 2) {
-            throw new Dwoo_Exception('Resource names must be at least two-character long to avoid conflicts with Windows paths');
-        }
-
-        if (!class_exists($class)) {
-            throw new Dwoo_Exception('Resource class does not exist');
-        }
-
-        $interfaces = class_implements($class);
-        if (in_array('Dwoo_ITemplate', $interfaces) === false) {
-            throw new Dwoo_Exception('Resource class must implement Dwoo_ITemplate');
-        }
-
-        $this->resources[$name] = array('class'=>$class, 'compiler'=>$compilerFactory);
-    }
-
-    /**
-     * removes a custom resource
-     *
-     * @param string $name the resource name
-     */
-    public function removeResource($name)
-    {
-        unset($this->resources[$name]);
-        if ($name==='file') {
-            $this->resources['file'] = array('class'=>'Dwoo_Template_File', 'compiler'=>null);
-        }
-    }
-
-    /*
-     * --------- getters and setters ---------
-     */
-
-    /**
-     * sets the loader object to use to load plugins
-     *
-     * @param Dwoo_ILoader $loader loader object
-     */
-    public function setLoader(Dwoo_ILoader $loader)
-    {
-        $this->loader = $loader;
-    }
-
-    /**
-     * returns the current loader object or a default one if none is currently found
-     *
-     * @param Dwoo_ILoader
-     */
-    public function getLoader()
-    {
-        if ($this->loader === null) {
-            $this->loader = new Dwoo_Loader($this->getCompileDir());
-        }
-
-        return $this->loader;
-    }
-
-    /**
-     * returns the custom plugins loaded
-     *
-     * used by the Dwoo_ITemplate classes to pass the custom plugins to their Dwoo_ICompiler instance
-     *
-     * @return array
-     */
-    public function getCustomPlugins()
-    {
-        return $this->plugins;
-    }
-
-    /**
-     * returns the cache directory with a trailing DIRECTORY_SEPARATOR
-     *
-     * @return string
-     */
-    public function getCacheDir()
-    {
-        if ($this->cacheDir === null) {
-            $this->setCacheDir(DWOO_DIRECTORY.'cache'.DIRECTORY_SEPARATOR);
-        }
+			throw new Dwoo_Exception('Callback could not be processed correctly, please check that the function/class you used exists');
+		}
+	}
+
+	/**
+	 * removes a custom plugin
+	 *
+	 * @param string $name the plugin name
+	 */
+	public function removePlugin($name)
+	{
+		if (isset($this->plugins[$name])) {
+			unset($this->plugins[$name]);
+		}
+	}
+
+	/**
+	 * adds a filter to this Dwoo instance, it will be used to filter the output of all the templates rendered by this instance
+	 *
+	 * @param mixed $callback a callback or a filter name if it is autoloaded from a plugin directory
+	 * @param bool $autoload if true, the first parameter must be a filter name from one of the plugin directories
+	 */
+	public function addFilter($callback, $autoload = false)
+	{
+		if ($autoload) {
+			$class = 'Dwoo_Filter_'.$callback;
+
+			if (!class_exists($class, false) && !function_exists($class)) {
+				try {
+					$this->getLoader()->loadPlugin($callback);
+				} catch (Dwoo_Exception $e) {
+					if (strstr($callback, 'Dwoo_Filter_')) {
+						throw new Dwoo_Exception('Wrong filter name : '.$callback.', the "Dwoo_Filter_" prefix should not be used, please only use "'.str_replace('Dwoo_Filter_', '', $callback).'"');
+					} else {
+						throw new Dwoo_Exception('Wrong filter name : '.$callback.', when using autoload the filter must be in one of your plugin dir as "name.php" containg a class or function named "Dwoo_Filter_name"');
+					}
+				}
+			}
 
-        return $this->cacheDir;
-    }
+			if (class_exists($class, false)) {
+				$callback = array(new $class($this), 'process');
+			} elseif (function_exists($class)) {
+				$callback = $class;
+			} else {
+				throw new Dwoo_Exception('Wrong filter name : '.$callback.', when using autoload the filter must be in one of your plugin dir as "name.php" containg a class or function named "Dwoo_Filter_name"');
+			}
 
-    /**
-     * sets the cache directory and automatically appends a DIRECTORY_SEPARATOR
-     *
-     * @param string $dir the cache directory
-     */
-    public function setCacheDir($dir)
-    {
-        $this->cacheDir = rtrim($dir, '/\\').DIRECTORY_SEPARATOR;
-        if (is_writable($this->cacheDir) === false) {
-            throw new Dwoo_Exception('The cache directory must be writable, chmod "'.$this->cacheDir.'" to make it writable');
-        }
-    }
-
-    /**
-     * returns the compile directory with a trailing DIRECTORY_SEPARATOR
-     *
-     * @return string
+			$this->filters[] = $callback;
+		} else {
+			$this->filters[] = $callback;
+		}
+	}
+
+	/**
+	 * removes a filter
+	 *
+	 * @param mixed $callback callback or filter name if it was autoloaded
+	 */
+	public function removeFilter($callback)
+	{
+		if (($index = array_search('Dwoo_Filter_'.$callback, $this->filters, true)) !== false) {
+			unset($this->filters[$index]);
+		} elseif (($index = array_search($callback, $this->filters, true)) !== false) {
+			unset($this->filters[$index]);
+		} else  {
+			$class = 'Dwoo_Filter_' . $callback;
+			foreach ($this->filters as $index=>$filter) {
+				if (is_array($filter) && $filter[0] instanceof $class) {
+					unset($this->filters[$index]);
+					break;
+				}
+			}
+		}
+	}
+
+	/**
+	 * adds a resource or overrides a default one
+	 *
+	 * @param string $name the resource name
+	 * @param string $class the resource class (which must implement Dwoo_ITemplate)
+	 * @param callback $compilerFactory the compiler factory callback, a function that must return a compiler instance used to compile this resource, if none is provided. by default it will produce a Dwoo_Compiler object
+	 */
+	public function addResource($name, $class, $compilerFactory = null)
+	{
+		if (strlen($name) < 2) {
+			throw new Dwoo_Exception('Resource names must be at least two-character long to avoid conflicts with Windows paths');
+		}
+
+		if (!class_exists($class)) {
+			throw new Dwoo_Exception('Resource class does not exist');
+		}
+
+		$interfaces = class_implements($class);
+		if (in_array('Dwoo_ITemplate', $interfaces) === false) {
+			throw new Dwoo_Exception('Resource class must implement Dwoo_ITemplate');
+		}
+
+		$this->resources[$name] = array('class'=>$class, 'compiler'=>$compilerFactory);
+	}
+
+	/**
+	 * removes a custom resource
+	 *
+	 * @param string $name the resource name
+	 */
+	public function removeResource($name)
+	{
+		unset($this->resources[$name]);
+		if ($name==='file') {
+			$this->resources['file'] = array('class'=>'Dwoo_Template_File', 'compiler'=>null);
+		}
+	}
+
+	/*
+     * --------- getters and setters ---------
      */
-    public function getCompileDir()
-    {
-        if ($this->compileDir === null) {
-            $this->setCompileDir(DWOO_DIRECTORY.'compiled'.DIRECTORY_SEPARATOR);
-        }
-
-        return $this->compileDir;
-    }
 
-    /**
-     * sets the compile directory and automatically appends a DIRECTORY_SEPARATOR
-     *
-     * @param string $dir the compile directory
-     */
-    public function setCompileDir($dir)
-    {
-        $this->compileDir = rtrim($dir, '/\\').DIRECTORY_SEPARATOR;
-        if (is_writable($this->compileDir) === false) {
-            throw new Dwoo_Exception('The compile directory must be writable, chmod "'.$this->compileDir.'" to make it writable');
-        }
-    }
-
-    /**
-     * returns the default cache time that is used with templates that do not have a cache time set
-     *
-     * @return int the duration in seconds
+	/**
+	 * sets the loader object to use to load plugins
+	 *
+	 * @param Dwoo_ILoader $loader loader object
+	 */
+	public function setLoader(Dwoo_ILoader $loader)
+	{
+		$this->loader = $loader;
+	}
+
+	/**
+	 * returns the current loader object or a default one if none is currently found
+	 *
+	 * @param Dwoo_ILoader
+	 */
+	public function getLoader()
+	{
+		if ($this->loader === null) {
+			$this->loader = new Dwoo_Loader($this->getCompileDir());
+		}
+
+		return $this->loader;
+	}
+
+	/**
+	 * returns the custom plugins loaded
+	 *
+	 * used by the Dwoo_ITemplate classes to pass the custom plugins to their Dwoo_ICompiler instance
+	 *
+	 * @return array
+	 */
+	public function getCustomPlugins()
+	{
+		return $this->plugins;
+	}
+
+	/**
+	 * returns the cache directory with a trailing DIRECTORY_SEPARATOR
+	 *
+	 * @return string
+	 */
+	public function getCacheDir()
+	{
+		if ($this->cacheDir === null) {
+			$this->setCacheDir(DWOO_DIRECTORY.'cache'.DIRECTORY_SEPARATOR);
+		}
+
+		return $this->cacheDir;
+	}
+
+	/**
+	 * sets the cache directory and automatically appends a DIRECTORY_SEPARATOR
+	 *
+	 * @param string $dir the cache directory
+	 */
+	public function setCacheDir($dir)
+	{
+		$this->cacheDir = rtrim($dir, '/\\').DIRECTORY_SEPARATOR;
+		if (is_writable($this->cacheDir) === false) {
+			throw new Dwoo_Exception('The cache directory must be writable, chmod "'.$this->cacheDir.'" to make it writable');
+		}
+	}
+
+	/**
+	 * returns the compile directory with a trailing DIRECTORY_SEPARATOR
+	 *
+	 * @return string
+	 */
+	public function getCompileDir()
+	{
+		if ($this->compileDir === null) {
+			$this->setCompileDir(DWOO_DIRECTORY.'compiled'.DIRECTORY_SEPARATOR);
+		}
+
+		return $this->compileDir;
+	}
+
+	/**
+	 * sets the compile directory and automatically appends a DIRECTORY_SEPARATOR
+	 *
+	 * @param string $dir the compile directory
+	 */
+	public function setCompileDir($dir)
+	{
+		$this->compileDir = rtrim($dir, '/\\').DIRECTORY_SEPARATOR;
+		if (is_writable($this->compileDir) === false) {
+			throw new Dwoo_Exception('The compile directory must be writable, chmod "'.$this->compileDir.'" to make it writable');
+		}
+	}
+
+	/**
+	 * returns the default cache time that is used with templates that do not have a cache time set
+	 *
+	 * @return int the duration in seconds
+	 */
+	public function getCacheTime()
+	{
+		return $this->cacheTime;
+	}
+
+	/**
+	 * sets the default cache time to use with templates that do not have a cache time set
+	 *
+	 * @param int $seconds the duration in seconds
+	 */
+	public function setCacheTime($seconds)
+	{
+		$this->cacheTime = (int) $seconds;
+	}
+
+	/**
+	 * returns the character set used by the string manipulation plugins
+	 *
+	 * the charset is automatically lowercased
+	 *
+	 * @return string
+	 */
+	public function getCharset()
+	{
+		return $this->charset;
+	}
+
+	/**
+	 * sets the character set used by the string manipulation plugins
+	 *
+	 * the charset will be automatically lowercased
+	 *
+	 * @param string $charset the character set
+	 */
+	public function setCharset($charset)
+	{
+		$this->charset = strtolower((string) $charset);
+	}
+
+	/**
+	 * returns the current template being rendered, when applicable, or null
+	 *
+	 * @return Dwoo_ITemplate|null
+	 */
+	public function getTemplate()
+	{
+		return $this->template;
+	}
+
+	/**
+	 * sets the current template being rendered
+	 *
+	 * @param Dwoo_ITemplate $tpl template object
+	 */
+	public function setTemplate(Dwoo_ITemplate $tpl)
+	{
+		$this->template = $tpl;
+	}
+
+	/**
+	 * sets the default compiler factory function for the given resource name
+	 *
+	 * a compiler factory must return a Dwoo_ICompiler object pre-configured to fit your needs
+	 *
+	 * @param string $resourceName the resource name (i.e. file, string)
+	 * @param callback $compilerFactory the compiler factory callback
+	 */
+	public function setDefaultCompilerFactory($resourceName, $compilerFactory)
+	{
+		$this->resources[$resourceName]['compiler'] = $compilerFactory;
+	}
+
+	/**
+	 * returns the default compiler factory function for the given resource name
+	 *
+	 * @param string $resourceName the resource name
+	 * @return callback the compiler factory callback
+	 */
+	public function getDefaultCompilerFactory($resourceName)
+	{
+		return $this->resources[$resourceName]['compiler'];
+	}
+
+	/**
+	 * sets the security policy object to enforce some php security settings
+	 *
+	 * use this if untrusted persons can modify templates
+	 *
+	 * @param Dwoo_Security_Policy $policy the security policy object
+	 */
+	public function setSecurityPolicy(Dwoo_Security_Policy $policy = null)
+	{
+		$this->securityPolicy = $policy;
+	}
+
+	/**
+	 * returns the current security policy object or null by default
+	 *
+	 * @return Dwoo_Security_Policy|null the security policy object if any
+	 */
+	public function getSecurityPolicy()
+	{
+		return $this->securityPolicy;
+	}
+
+	/**
+	 * sets the object that must be used as a plugin proxy when plugin can't be found
+	 * by dwoo's loader
+	 *
+	 * @param Dwoo_IPluginProxy $pluginProxy the proxy object
+	 */
+	public function setPluginProxy(Dwoo_IPluginProxy $pluginProxy) {
+		$this->pluginProxy = $pluginProxy;
+	}
+
+	/**
+	 * returns the current plugin proxy object or null by default
+	 *
+	 * @param Dwoo_IPluginProxy|null the proxy object if any
+	 */
+	public function getPluginProxy() {
+		return $this->pluginProxy;
+	}
+
+	/*
+     * --------- util functions ---------
      */
-    public function getCacheTime()
-    {
-        return $this->cacheTime;
-    }
 
-    /**
-     * sets the default cache time to use with templates that do not have a cache time set
-     *
-     * @param int $seconds the duration in seconds
+	/**
+	 * [util function] checks whether the given template is cached or not
+	 *
+	 * @param Dwoo_ITemplate $tpl the template object
+	 * @return bool
+	 */
+	public function isCached(Dwoo_ITemplate $tpl)
+	{
+		return is_string($tpl->getCachedTemplate($this));
+	}
+
+	/**
+	 * [util function] clears the cached templates if they are older than the given time
+	 *
+	 * @param int $olderThan minimum time (in seconds) required for a cached template to be cleared
+	 * @return int the amount of templates cleared
+	 */
+	public function clearCache($olderThan=-1)
+	{
+		$cacheDirs = new RecursiveDirectoryIterator($this->getCacheDir());
+		$cache = new RecursiveIteratorIterator($cacheDirs);
+		$expired = time() - $olderThan;
+		$count = 0;
+		foreach ($cache as $file) {
+			if ($cache->isDot() || $cache->isDir() || substr($file, -5) !== '.html') {
+				continue;
+			}
+			if ($cache->getCTime() < $expired) {
+				$count += unlink((string) $file) ? 1 : 0;
+			}
+		}
+		return $count;
+	}
+
+	/**
+	 * [util function] fetches a template object of the given resource
+	 *
+	 * @param string $resourceName the resource name (i.e. file, string)
+	 * @param string $resourceId the resource identifier (i.e. file path)
+	 * @param int $cacheTime the cache time setting for this resource
+	 * @param string $cacheId the unique cache identifier
+	 * @param string $compileId the unique compiler identifier
+	 * @return Dwoo_ITemplate
+	 */
+	public function templateFactory($resourceName, $resourceId, $cacheTime = null, $cacheId = null, $compileId = null, Dwoo_ITemplate $parentTemplate = null)
+	{
+		if (isset($this->resources[$resourceName])) {
+			// TODO could be changed to $this->resources[$resourceName]['class']::templateFactory(..) in 5.3 maybe
+			return call_user_func(array($this->resources[$resourceName]['class'], 'templateFactory'), $this, $resourceId, $cacheTime, $cacheId, $compileId, $parentTemplate);
+		} else {
+			throw new Dwoo_Exception('Unknown resource type : '.$resourceName);
+		}
+	}
+
+	/**
+	 * [util function] checks if the input is an array or arrayaccess object, optionally it can also check if it's empty
+	 *
+	 * @param mixed $value the variable to check
+	 * @param bool $checkIsEmpty if true, the function will also check if the array|arrayaccess is empty,
+	 *                              and return true only if it's not empty
+	 * @return int|bool true if it's an array|arrayaccess (or the item count if $checkIsEmpty is true) or false if it's not an array|arrayaccess (or 0 if $checkIsEmpty is true)
+	 */
+	public function isArray($value, $checkIsEmpty=false)
+	{
+		if (is_array($value) === true || $value instanceof ArrayAccess) {
+			if ($checkIsEmpty === false) {
+				return true;
+			} else {
+				return $this->count($value);
+			}
+		}
+	}
+
+	/**
+	 * [util function] checks if the input is an array or a traversable object, optionally it can also check if it's empty
+	 *
+	 * @param mixed $value the variable to check
+	 * @param bool $checkIsEmpty if true, the function will also check if the array|traversable is empty,
+	 *                              and return true only if it's not empty
+	 * @return int|bool true if it's an array|traversable (or the item count if $checkIsEmpty is true) or false if it's not an array|traversable (or 0 if $checkIsEmpty is true)
+	 */
+	public function isTraversable($value, $checkIsEmpty=false)
+	{
+		if (is_array($value) === true) {
+			if ($checkIsEmpty === false) {
+				return true;
+			} else {
+				return count($value) > 0;
+			}
+		} elseif ($value instanceof Traversable) {
+			if ($checkIsEmpty === false) {
+				return true;
+			} else {
+				return $this->count($value);
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * [util function] counts an array or arrayaccess/traversable object
+	 * @param mixed $value
+	 * @return int|bool the count for arrays and objects that implement countable, true for other objects that don't, and 0 for empty elements
+	 */
+	public function count($value)
+	{
+		if (is_array($value) === true || $value instanceof Countable) {
+			return count($value);
+		} elseif ($value instanceof ArrayAccess) {
+			if ($value->offsetExists(0)) {
+				return true;
+			}
+		} elseif ($value instanceof Iterator) {
+			$value->rewind();
+			if ($value->valid()) {
+				return true;
+			}
+		} elseif ($value instanceof Traversable) {
+			foreach ($value as $dummy) {
+				return true;
+			}
+		}
+		return 0;
+	}
+
+	/**
+	 * [util function] triggers a dwoo error
+	 *
+	 * @param string $message the error message
+	 * @param int $level the error level, one of the PHP's E_* constants
+	 */
+	public function triggerError($message, $level=E_USER_NOTICE)
+	{
+		if (!($tplIdentifier = $this->template->getResourceIdentifier())) {
+			$tplIdentifier = $this->template->getResourceName();
+		}
+		trigger_error('Dwoo error (in '.$tplIdentifier.') : '.$message, $level);
+	}
+
+	/*
+     * --------- runtime functions ---------
      */
-    public function setCacheTime($seconds)
-    {
-        $this->cacheTime = (int) $seconds;
-    }
 
-    /**
-     * returns the character set used by the string manipulation plugins
-     *
-     * the charset is automatically lowercased
-     *
-     * @return string
-     */
-    public function getCharset()
-    {
-        return $this->charset;
-    }
+	/**
+	 * [runtime function] adds a block to the block stack
+	 *
+	 * @param string $blockName the block name (without Dwoo_Plugin_ prefix)
+	 * @param array $args the arguments to be passed to the block's init() function
+	 * @return Dwoo_Block_Plugin the newly created block
+	 */
+	public function addStack($blockName, array $args=array())
+	{
+		if (isset($this->plugins[$blockName])) {
+			$class = $this->plugins[$blockName]['class'];
+		} else {
+			$class = 'Dwoo_Plugin_'.$blockName;
+		}
 
-    /**
-     * sets the character set used by the string manipulation plugins
-     *
-     * the charset will be automatically lowercased
-     *
-     * @param string $charset the character set
-     */
-    public function setCharset($charset)
-    {
-        $this->charset = strtolower((string) $charset);
-    }
+		if ($this->curBlock !== null) {
+			$this->curBlock->buffer(ob_get_contents());
+			ob_clean();
+		} else {
+			$this->buffer .= ob_get_contents();
+			ob_clean();
+		}
+
+		$block = new $class($this);
+
+		$cnt = count($args);
+		if ($cnt===0) {
+			$block->init();
+		} elseif ($cnt===1) {
+			$block->init($args[0]);
+		} elseif ($cnt===2) {
+			$block->init($args[0], $args[1]);
+		} elseif ($cnt===3) {
+			$block->init($args[0], $args[1], $args[2]);
+		} elseif ($cnt===4) {
+			$block->init($args[0], $args[1], $args[2], $args[3]);
+		} else {
+			call_user_func_array(array($block,'init'), $args);
+		}
+
+		$this->stack[] = $this->curBlock = $block;
+		return $block;
+	}
+
+	/**
+	 * [runtime function] removes the plugin at the top of the block stack
+	 *
+	 * calls the block buffer() function, followed by a call to end()
+	 * and finally a call to process()
+	 */
+	public function delStack()
+	{
+		$args = func_get_args();
+
+		$this->curBlock->buffer(ob_get_contents());
+		ob_clean();
+
+		$cnt = count($args);
+		if ($cnt===0) {
+			$this->curBlock->end();
+		} elseif ($cnt===1) {
+			$this->curBlock->end($args[0]);
+		} elseif ($cnt===2) {
+			$this->curBlock->end($args[0], $args[1]);
+		} elseif ($cnt===3) {
+			$this->curBlock->end($args[0], $args[1], $args[2]);
+		} elseif ($cnt===4) {
+			$this->curBlock->end($args[0], $args[1], $args[2], $args[3]);
+		} else {
+			call_user_func_array(array($this->curBlock, 'end'), $args);
+		}
 
-    /**
-     * returns the current template being rendered, when applicable, or null
-     *
-     * @return Dwoo_ITemplate|null
-     */
-    public function getTemplate()
-    {
-        return $this->template;
-    }
+		$tmp = array_pop($this->stack);
 
-    /**
-     * sets the current template being rendered
-     *
-     * @param Dwoo_ITemplate $tpl template object
-     */
-    public function setTemplate(Dwoo_ITemplate $tpl)
-    {
-        $this->template = $tpl;
-    }
+		if (count($this->stack) > 0) {
+			$this->curBlock = end($this->stack);
+			$this->curBlock->buffer($tmp->process());
+		} else {
+			if($this->buffer !== '') {
+				echo $this->buffer;
+				$this->buffer = '';
+			}
+			$this->curBlock = null;
+			echo $tmp->process();
+		}
+
+		unset($tmp);
+	}
+
+	/**
+	 * [runtime function] returns the parent block of the given block
+	 *
+	 * @param Dwoo_Block_Plugin $block
+	 * @return Dwoo_Block_Plugin or false if the given block isn't in the stack
+	 */
+	public function getParentBlock(Dwoo_Block_Plugin $block)
+	{
+		$index = array_search($block, $this->stack, true);
+		if ($index !== false && $index > 0) {
+			return $this->stack[$index-1];
+		}
+		return false;
+	}
+
+	/**
+	 * [runtime function] finds the closest block of the given type, starting at the top of the stack
+	 *
+	 * @param string $type the type of plugin you want to find
+	 * @return Dwoo_Block_Plugin or false if no plugin of such type is in the stack
+	 */
+	public function findBlock($type)
+	{
+		if (isset($this->plugins[$type])) {
+			$type = $this->plugins[$type]['class'];
+		} else {
+			$type = 'Dwoo_Plugin_'.str_replace('Dwoo_Plugin_', '', $type);
+		}
 
-    /**
-     * sets the default compiler factory function for the given resource name
-     *
-     * a compiler factory must return a Dwoo_ICompiler object pre-configured to fit your needs
-     *
-     * @param string $resourceName the resource name (i.e. file, string)
-     * @param callback $compilerFactory the compiler factory callback
-     */
-    public function setDefaultCompilerFactory($resourceName, $compilerFactory)
-    {
-        $this->resources[$resourceName]['compiler'] = $compilerFactory;
-    }
+		$keys = array_keys($this->stack);
+		while (($key = array_pop($keys)) !== false) {
+			if ($this->stack[$key] instanceof $type) {
+				return $this->stack[$key];
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * [runtime function] returns a Dwoo_Plugin of the given class
+	 *
+	 * this is so a single instance of every class plugin is created at each template run,
+	 * allowing class plugins to have "per-template-run" static variables
+	 *
+	 * @private
+	 * @param string $class the class name
+	 * @return mixed an object of the given class
+	 */
+	public function getObjectPlugin($class)
+	{
+		if (isset($this->runtimePlugins[$class])) {
+			return $this->runtimePlugins[$class];
+		}
+		return $this->runtimePlugins[$class] = new $class($this);
+	}
+
+	/**
+	 * [runtime function] calls the process() method of the given class-plugin name
+	 *
+	 * @param string $plugName the class plugin name (without Dwoo_Plugin_ prefix)
+	 * @param array $params an array of parameters to send to the process() method
+	 * @return string the process() return value
+	 */
+	public function classCall($plugName, array $params = array())
+	{
+		$class = 'Dwoo_Plugin_'.$plugName;
+
+		$plugin = $this->getObjectPlugin($class);
+
+		$cnt = count($params);
+		if ($cnt===0) {
+			return $plugin->process();
+		} elseif ($cnt===1) {
+			return $plugin->process($params[0]);
+		} elseif ($cnt===2) {
+			return $plugin->process($params[0], $params[1]);
+		} elseif ($cnt===3) {
+			return $plugin->process($params[0], $params[1], $params[2]);
+		} elseif ($cnt===4) {
+			return $plugin->process($params[0], $params[1], $params[2], $params[3]);
+		} else {
+			return call_user_func_array(array($plugin, 'process'), $params);
+		}
+	}
+
+	/**
+	 * [runtime function] calls a php function
+	 *
+	 * @param string $callback the function to call
+	 * @param array $params an array of parameters to send to the function
+	 * @return mixed the return value of the called function
+	 */
+	public function arrayMap($callback, array $params)
+	{
+		if ($params[0] === $this) {
+			$addThis = true;
+			array_shift($params);
+		}
+		if ((is_array($params[0]) || ($params[0] instanceof Iterator && $params[0] instanceof ArrayAccess))) {
+			if (empty($params[0])) {
+				return $params[0];
+			}
 
-    /**
-     * returns the default compiler factory function for the given resource name
-     *
-     * @param string $resourceName the resource name
-     * @return callback the compiler factory callback
-     */
-    public function getDefaultCompilerFactory($resourceName)
-    {
-        return $this->resources[$resourceName]['compiler'];
-    }
+			// array map
+			$out = array();
+			$cnt = count($params);
+
+			if (isset($addThis)) {
+				array_unshift($params, $this);
+				$items = $params[1];
+				$keys = array_keys($items);
+
+				if (is_string($callback) === false) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = call_user_func_array($callback, array(1=>$items[$i]) + $params);
+					}
+				} elseif ($cnt===1) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($this, $items[$i]);
+					}
+				} elseif ($cnt===2) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($this, $items[$i], $params[2]);
+					}
+				} elseif ($cnt===3) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($this, $items[$i], $params[2], $params[3]);
+					}
+				} else {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = call_user_func_array($callback, array(1=>$items[$i]) + $params);
+					}
+				}
+			} else {
+				$items = $params[0];
+				$keys = array_keys($items);
+
+				if (is_string($callback) === false) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = call_user_func_array($callback, array($items[$i]) + $params);
+					}
+				} elseif ($cnt===1) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($items[$i]);
+					}
+				} elseif ($cnt===2) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($items[$i], $params[1]);
+					}
+				} elseif ($cnt===3) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($items[$i], $params[1], $params[2]);
+					}
+				} elseif ($cnt===4) {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = $callback($items[$i], $params[1], $params[2], $params[3]);
+					}
+				} else {
+					while (($i = array_shift($keys)) !== null) {
+						$out[] = call_user_func_array($callback, array($items[$i]) + $params);
+					}
+				}
+			}
+			return $out;
+		} else {
+			return $params[0];
+		}
+	}
+
+	/**
+	 * [runtime function] reads a variable into the given data array
+	 *
+	 * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
+	 * @param mixed $data the data array or object to read from
+	 * @param bool $safeRead if true, the function will check whether the index exists to prevent any notices from being output
+	 * @return mixed
+	 */
+	public function readVarInto($varstr, $data, $safeRead = false)
+	{
+		if ($data === null) {
+			return null;
+		}
+
+		if (is_array($varstr) === false) {
+			preg_match_all('#(\[|->|\.)?((?:[^.[\]-]|-(?!>))+)\]?#i', $varstr, $m);
+		} else {
+			$m = $varstr;
+		}
+		unset($varstr);
 
-    /**
-     * sets the security policy object to enforce some php security settings
-     *
-     * use this if untrusted persons can modify templates
-     *
-     * @param Dwoo_Security_Policy $policy the security policy object
-     */
-    public function setSecurityPolicy(Dwoo_Security_Policy $policy = null)
-    {
-        $this->securityPolicy = $policy;
-    }
+		while (list($k, $sep) = each($m[1])) {
+			if ($sep === '.' || $sep === '[' || $sep === '') {
+				// strip enclosing quotes if present
+				$m[2][$k] = preg_replace('#^(["\']?)(.*?)\1$#', '$2', $m[2][$k]);
 
-    /**
-     * returns the current security policy object or null by default
-     *
-     * @return Dwoo_Security_Policy|null the security policy object if any
-     */
-    public function getSecurityPolicy()
-    {
-        return $this->securityPolicy;
-    }
-
-    /**
-     * sets the object that must be used as a plugin proxy when plugin can't be found
-     * by dwoo's loader
-     *
-     * @param Dwoo_IPluginProxy $pluginProxy the proxy object
-     */
-    public function setPluginProxy(Dwoo_IPluginProxy $pluginProxy) {
-        $this->pluginProxy = $pluginProxy;
-    }
+				if ((is_array($data) || $data instanceof ArrayAccess) && ($safeRead === false || isset($data[$m[2][$k]]))) {
+					$data = $data[$m[2][$k]];
+				} else {
+					return null;
+				}
+			} else {
+				if (is_object($data) && ($safeRead === false || isset($data->$m[2][$k]))) {
+					$data = $data->$m[2][$k];
+				} else {
+					return null;
+				}
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * [runtime function] reads a variable into the parent scope
+	 *
+	 * @param int $parentLevels the amount of parent levels to go from the current scope
+	 * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
+	 * @return mixed
+	 */
+	public function readParentVar($parentLevels, $varstr = null)
+	{
+		$tree = $this->scopeTree;
+		$cur = $this->data;
+
+		while ($parentLevels--!==0) {
+			array_pop($tree);
+		}
+
+		while (($i = array_shift($tree)) !== null) {
+			if (is_object($cur)) {
+				$cur = $cur->$i;
+			} else {
+				$cur = $cur[$i];
+			}
+		}
 
-    /**
-     * returns the current plugin proxy object or null by default
-     *
-     * @param Dwoo_IPluginProxy|null the proxy object if any
-     */
-    public function getPluginProxy() {
-        return $this->pluginProxy;
-    }
+		if ($varstr!==null) {
+			return $this->readVarInto($varstr, $cur);
+		} else {
+			return $cur;
+		}
+	}
+
+	/**
+	 * [runtime function] reads a variable into the current scope
+	 *
+	 * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
+	 * @return mixed
+	 */
+	public function readVar($varstr)
+	{
+		if (is_array($varstr)===true) {
+			$m = $varstr;
+			unset($varstr);
+		} else {
+			if (strstr($varstr, '.') === false && strstr($varstr, '[') === false && strstr($varstr, '->') === false) {
+				if ($varstr === 'dwoo') {
+					return $this->globals;
+				} elseif ($varstr === '__' || $varstr === '_root' ) {
+					return $this->data;
+					$varstr = substr($varstr, 6);
+				} elseif ($varstr === '_' || $varstr === '_parent') {
+					$varstr = '.'.$varstr;
+					$tree = $this->scopeTree;
+					$cur = $this->data;
+					array_pop($tree);
+
+					while (($i = array_shift($tree)) !== null) {
+						if (is_object($cur)) {
+							$cur = $cur->$i;
+						} else {
+							$cur = $cur[$i];
+						}
+					}
+
+					return $cur;
+				}
 
-    /*
-     * --------- util functions ---------
-     */
+				$cur = $this->scope;
 
-    /**
-     * [util function] checks whether the given template is cached or not
-     *
-     * @param Dwoo_ITemplate $tpl the template object
-     * @return bool
-     */
-    public function isCached(Dwoo_ITemplate $tpl)
-    {
-        return is_string($tpl->getCachedTemplate($this));
-    }
+				if (isset($cur[$varstr])) {
+					return $cur[$varstr];
+				} else {
+					return null;
+				}
+			}
 
-    /**
-     * [util function] clears the cached templates if they are older than the given time
-     *
-     * @param int $olderThan minimum time (in seconds) required for a cached template to be cleared
-     * @return int the amount of templates cleared
-     */
-    public function clearCache($olderThan=-1)
-    {
-        $cacheDirs = new RecursiveDirectoryIterator($this->getCacheDir());
-        $cache = new RecursiveIteratorIterator($cacheDirs);
-        $expired = time() - $olderThan;
-        $count = 0;
-        foreach ($cache as $file) {
-            if ($cache->isDot() || $cache->isDir() || substr($file, -5) !== '.html') {
-                continue;
-            }
-            if ($cache->getCTime() < $expired) {
-                $count += unlink((string) $file) ? 1 : 0;
-            }
-        }
-        return $count;
-    }
-
-    /**
-     * [util function] fetches a template object of the given resource
-     *
-     * @param string $resourceName the resource name (i.e. file, string)
-     * @param string $resourceId the resource identifier (i.e. file path)
-     * @param int $cacheTime the cache time setting for this resource
-     * @param string $cacheId the unique cache identifier
-     * @param string $compileId the unique compiler identifier
-     * @return Dwoo_ITemplate
-     */
-    public function templateFactory($resourceName, $resourceId, $cacheTime = null, $cacheId = null, $compileId = null, Dwoo_ITemplate $parentTemplate = null)
-    {
-        if (isset($this->resources[$resourceName])) {
-            // TODO could be changed to $this->resources[$resourceName]['class']::templateFactory(..) in 5.3 maybe
-            return call_user_func(array($this->resources[$resourceName]['class'], 'templateFactory'), $this, $resourceId, $cacheTime, $cacheId, $compileId, $parentTemplate);
-        } else {
-            throw new Dwoo_Exception('Unknown resource type : '.$resourceName);
-        }
-    }
-
-    /**
-     * [util function] checks if the input is an array or arrayaccess object, optionally it can also check if it's empty
-     *
-     * @param mixed $value the variable to check
-     * @param bool $checkIsEmpty if true, the function will also check if the array|arrayaccess is empty,
-     *                              and return true only if it's not empty
-     * @return int|bool true if it's an array|arrayaccess (or the item count if $checkIsEmpty is true) or false if it's not an array|arrayaccess (or 0 if $checkIsEmpty is true)
-     */
-    public function isArray($value, $checkIsEmpty=false)
-    {
-        if (is_array($value) === true || $value instanceof ArrayAccess) {
-            if ($checkIsEmpty === false) {
-                return true;
-            } else {
-                return $this->count($value);
-            }
-        }
-    }
-
-    /**
-     * [util function] checks if the input is an array or a traversable object, optionally it can also check if it's empty
-     *
-     * @param mixed $value the variable to check
-     * @param bool $checkIsEmpty if true, the function will also check if the array|traversable is empty,
-     *                              and return true only if it's not empty
-     * @return int|bool true if it's an array|traversable (or the item count if $checkIsEmpty is true) or false if it's not an array|traversable (or 0 if $checkIsEmpty is true)
-     */
-    public function isTraversable($value, $checkIsEmpty=false)
-    {
-        if (is_array($value) === true) {
-            if ($checkIsEmpty === false) {
-                return true;
-            } else {
-                return count($value) > 0;
-            }
-        } elseif ($value instanceof Traversable) {
-            if ($checkIsEmpty === false) {
-                return true;
-            } else {
-                return $this->count($value);
-            }
-        }
-        return false;
-    }
-
-    /**
-     * [util function] counts an array or arrayaccess/traversable object
-     * @param mixed $value
-     * @return int|bool the count for arrays and objects that implement countable, true for other objects that don't, and 0 for empty elements
-     */
-    public function count($value)
-    {
-        if (is_array($value) === true || $value instanceof Countable) {
-            return count($value);
-        } elseif ($value instanceof ArrayAccess) {
-            if ($value->offsetExists(0)) {
-                return true;
-            }
-        } elseif ($value instanceof Iterator) {
-            $value->rewind();
-            if ($value->valid()) {
-                return true;
-            }
-        } elseif ($value instanceof Traversable) {
-            foreach ($value as $dummy) {
-                return true;
-            }
-        }
-        return 0;
-    }
-
-    /**
-     * [util function] triggers a dwoo error
-     *
-     * @param string $message the error message
-     * @param int $level the error level, one of the PHP's E_* constants
-     */
-    public function triggerError($message, $level=E_USER_NOTICE)
-    {
-        if (!($tplIdentifier = $this->template->getResourceIdentifier())) {
-            $tplIdentifier = $this->template->getResourceName();
-        }
-        trigger_error('Dwoo error (in '.$tplIdentifier.') : '.$message, $level);
-    }
-
-    /*
-     * --------- runtime functions ---------
-     */
+			if (substr($varstr, 0, 1) === '.') {
+				$varstr = 'dwoo'.$varstr;
+			}
 
-    /**
-     * [runtime function] adds a block to the block stack
-     *
-     * @param string $blockName the block name (without Dwoo_Plugin_ prefix)
-     * @param array $args the arguments to be passed to the block's init() function
-     * @return Dwoo_Block_Plugin the newly created block
-     */
-    public function addStack($blockName, array $args=array())
-    {
-        if (isset($this->plugins[$blockName])) {
-            $class = $this->plugins[$blockName]['class'];
-        } else {
-            $class = 'Dwoo_Plugin_'.$blockName;
-        }
-
-        if ($this->curBlock !== null) {
-            $this->curBlock->buffer(ob_get_contents());
-            ob_clean();
-        } else {
-            $this->buffer .= ob_get_contents();
-            ob_clean();
-        }
-
-        $block = new $class($this);
-
-        $cnt = count($args);
-        if ($cnt===0) {
-            $block->init();
-        } elseif ($cnt===1) {
-            $block->init($args[0]);
-        } elseif ($cnt===2) {
-            $block->init($args[0], $args[1]);
-        } elseif ($cnt===3) {
-            $block->init($args[0], $args[1], $args[2]);
-        } elseif ($cnt===4) {
-            $block->init($args[0], $args[1], $args[2], $args[3]);
-        } else {
-            call_user_func_array(array($block,'init'), $args);
-        }
-
-        $this->stack[] = $this->curBlock = $block;
-        return $block;
-    }
-
-    /**
-     * [runtime function] removes the plugin at the top of the block stack
-     *
-     * calls the block buffer() function, followed by a call to end()
-     * and finally a call to process()
-     */
-    public function delStack()
-    {
-        $args = func_get_args();
-
-        $this->curBlock->buffer(ob_get_contents());
-        ob_clean();
-
-        $cnt = count($args);
-        if ($cnt===0) {
-            $this->curBlock->end();
-        } elseif ($cnt===1) {
-            $this->curBlock->end($args[0]);
-        } elseif ($cnt===2) {
-            $this->curBlock->end($args[0], $args[1]);
-        } elseif ($cnt===3) {
-            $this->curBlock->end($args[0], $args[1], $args[2]);
-        } elseif ($cnt===4) {
-            $this->curBlock->end($args[0], $args[1], $args[2], $args[3]);
-        } else {
-            call_user_func_array(array($this->curBlock, 'end'), $args);
-        }
-
-        $tmp = array_pop($this->stack);
-
-        if (count($this->stack) > 0) {
-            $this->curBlock = end($this->stack);
-            $this->curBlock->buffer($tmp->process());
-        } else {
-            if($this->buffer !== '') {
-                echo $this->buffer;
-                $this->buffer = '';
-            }
-            $this->curBlock = null;
-            echo $tmp->process();
-        }
-
-        unset($tmp);
-    }
-
-    /**
-     * [runtime function] returns the parent block of the given block
-     *
-     * @param Dwoo_Block_Plugin $block
-     * @return Dwoo_Block_Plugin or false if the given block isn't in the stack
-     */
-    public function getParentBlock(Dwoo_Block_Plugin $block)
-    {
-        $index = array_search($block, $this->stack, true);
-        if ($index !== false && $index > 0) {
-            return $this->stack[$index-1];
-        }
-        return false;
-    }
-
-    /**
-     * [runtime function] finds the closest block of the given type, starting at the top of the stack
-     *
-     * @param string $type the type of plugin you want to find
-     * @return Dwoo_Block_Plugin or false if no plugin of such type is in the stack
-     */
-    public function findBlock($type)
-    {
-        if (isset($this->plugins[$type])) {
-            $type = $this->plugins[$type]['class'];
-        } else {
-            $type = 'Dwoo_Plugin_'.str_replace('Dwoo_Plugin_', '', $type);
-        }
-
-        $keys = array_keys($this->stack);
-        while (($key = array_pop($keys)) !== false) {
-            if ($this->stack[$key] instanceof $type) {
-                return $this->stack[$key];
-            }
-        }
-        return false;
-    }
-
-    /**
-     * [runtime function] returns a Dwoo_Plugin of the given class
-     *
-     * this is so a single instance of every class plugin is created at each template run,
-     * allowing class plugins to have "per-template-run" static variables
-     *
-     * @private
-     * @param string $class the class name
-     * @return mixed an object of the given class
-     */
-    public function getObjectPlugin($class)
-    {
-        if (isset($this->runtimePlugins[$class])) {
-            return $this->runtimePlugins[$class];
-        }
-        return $this->runtimePlugins[$class] = new $class($this);
-    }
-
-    /**
-     * [runtime function] calls the process() method of the given class-plugin name
-     *
-     * @param string $plugName the class plugin name (without Dwoo_Plugin_ prefix)
-     * @param array $params an array of parameters to send to the process() method
-     * @return string the process() return value
-     */
-    public function classCall($plugName, array $params = array())
-    {
-        $class = 'Dwoo_Plugin_'.$plugName;
-
-        $plugin = $this->getObjectPlugin($class);
-
-        $cnt = count($params);
-        if ($cnt===0) {
-            return $plugin->process();
-        } elseif ($cnt===1) {
-            return $plugin->process($params[0]);
-        } elseif ($cnt===2) {
-            return $plugin->process($params[0], $params[1]);
-        } elseif ($cnt===3) {
-            return $plugin->process($params[0], $params[1], $params[2]);
-        } elseif ($cnt===4) {
-            return $plugin->process($params[0], $params[1], $params[2], $params[3]);
-        } else {
-            return call_user_func_array(array($plugin, 'process'), $params);
-        }
-    }
-
-    /**
-     * [runtime function] calls a php function
-     *
-     * @param string $callback the function to call
-     * @param array $params an array of parameters to send to the function
-     * @return mixed the return value of the called function
-     */
-    public function arrayMap($callback, array $params)
-    {
-        if ($params[0] === $this) {
-            $addThis = true;
-            array_shift($params);
-        }
-        if ((is_array($params[0]) || ($params[0] instanceof Iterator && $params[0] instanceof ArrayAccess))) {
-            if (empty($params[0])) {
-                return $params[0];
-            }
-
-            // array map
-            $out = array();
-            $cnt = count($params);
-
-            if (isset($addThis)) {
-                array_unshift($params, $this);
-                $items = $params[1];
-                $keys = array_keys($items);
-
-                if (is_string($callback) === false) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = call_user_func_array($callback, array(1=>$items[$i]) + $params);
-                    }
-                } elseif ($cnt===1) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($this, $items[$i]);
-                    }
-                } elseif ($cnt===2) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($this, $items[$i], $params[2]);
-                    }
-                } elseif ($cnt===3) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($this, $items[$i], $params[2], $params[3]);
-                    }
-                } else {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = call_user_func_array($callback, array(1=>$items[$i]) + $params);
-                    }
-                }
-            } else {
-                $items = $params[0];
-                $keys = array_keys($items);
-
-                if (is_string($callback) === false) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = call_user_func_array($callback, array($items[$i]) + $params);
-                    }
-                } elseif ($cnt===1) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($items[$i]);
-                    }
-                } elseif ($cnt===2) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($items[$i], $params[1]);
-                    }
-                } elseif ($cnt===3) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($items[$i], $params[1], $params[2]);
-                    }
-                } elseif ($cnt===4) {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = $callback($items[$i], $params[1], $params[2], $params[3]);
-                    }
-                } else {
-                    while (($i = array_shift($keys)) !== null) {
-                        $out[] = call_user_func_array($callback, array($items[$i]) + $params);
-                    }
-                }
-            }
-            return $out;
-        } else {
-            return $params[0];
-        }
-    }
-
-    /**
-     * [runtime function] reads a variable into the given data array
-     *
-     * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
-     * @param mixed $data the data array or object to read from
-     * @param bool $safeRead if true, the function will check whether the index exists to prevent any notices from being output
-     * @return mixed
-     */
-    public function readVarInto($varstr, $data, $safeRead = false)
-    {
-        if ($data === null) {
-            return null;
-        }
-
-        if (is_array($varstr) === false) {
-            preg_match_all('#(\[|->|\.)?((?:[^.[\]-]|-(?!>))+)\]?#i', $varstr, $m);
-        } else {
-            $m = $varstr;
-        }
-        unset($varstr);
-
-        while (list($k, $sep) = each($m[1])) {
-            if ($sep === '.' || $sep === '[' || $sep === '') {
-                // strip enclosing quotes if present
-                $m[2][$k] = preg_replace('#^(["\']?)(.*?)\1$#', '$2', $m[2][$k]);
-
-                if ((is_array($data) || $data instanceof ArrayAccess) && ($safeRead === false || isset($data[$m[2][$k]]))) {
-                    $data = $data[$m[2][$k]];
-                } else {
-                    return null;
-                }
-            } else {
-                if (is_object($data) && ($safeRead === false || isset($data->$m[2][$k]))) {
-                    $data = $data->$m[2][$k];
-                } else {
-                    return null;
-                }
-            }
-        }
-
-        return $data;
-    }
-
-    /**
-     * [runtime function] reads a variable into the parent scope
-     *
-     * @param int $parentLevels the amount of parent levels to go from the current scope
-     * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
-     * @return mixed
-     */
-    public function readParentVar($parentLevels, $varstr = null)
-    {
-        $tree = $this->scopeTree;
-        $cur = $this->data;
-
-        while ($parentLevels--!==0) {
-            array_pop($tree);
-        }
-
-        while (($i = array_shift($tree)) !== null) {
-            if (is_object($cur)) {
-                $cur = $cur->$i;
-            } else {
-                $cur = $cur[$i];
-            }
-        }
-
-        if ($varstr!==null) {
-            return $this->readVarInto($varstr, $cur);
-        } else {
-            return $cur;
-        }
-    }
-
-    /**
-     * [runtime function] reads a variable into the current scope
-     *
-     * @param string $varstr the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
-     * @return mixed
-     */
-    public function readVar($varstr)
-    {
-        if (is_array($varstr)===true) {
-            $m = $varstr;
-            unset($varstr);
-        } else {
-            if (strstr($varstr, '.') === false && strstr($varstr, '[') === false && strstr($varstr, '->') === false) {
-                if ($varstr === 'dwoo') {
-                    return $this->globals;
-                } elseif ($varstr === '__' || $varstr === '_root' ) {
-                    return $this->data;
-                    $varstr = substr($varstr, 6);
-                } elseif ($varstr === '_' || $varstr === '_parent') {
-                    $varstr = '.'.$varstr;
-                    $tree = $this->scopeTree;
-                    $cur = $this->data;
-                    array_pop($tree);
-
-                    while (($i = array_shift($tree)) !== null) {
-                        if (is_object($cur)) {
-                            $cur = $cur->$i;
-                        } else {
-                            $cur = $cur[$i];
-                        }
-                    }
-
-                    return $cur;
-                }
-
-                $cur = $this->scope;
-
-                if (isset($cur[$varstr])) {
-                    return $cur[$varstr];
-                } else {
-                    return null;
-                }
-            }
-
-            if (substr($varstr, 0, 1) === '.') {
-                $varstr = 'dwoo'.$varstr;
-            }
-
-            preg_match_all('#(\[|->|\.)?((?:[^.[\]-]|-(?!>))+)\]?#i', $varstr, $m);
-        }
-
-        $i = $m[2][0];
-        if ($i === 'dwoo') {
-            $cur = $this->globals;
-            array_shift($m[2]);
-            array_shift($m[1]);
-            switch ($m[2][0]) {
-
-            case 'get':
-                $cur = $_GET;
-                break;
-            case 'post':
-                $cur = $_POST;
-                break;
-            case 'session':
-                $cur = $_SESSION;
-                break;
-            case 'cookies':
-            case 'cookie':
-                $cur = $_COOKIE;
-                break;
-            case 'server':
-                $cur = $_SERVER;
-                break;
-            case 'env':
-                $cur = $_ENV;
-                break;
-            case 'request':
-                $cur = $_REQUEST;
-                break;
-            case 'const':
-                array_shift($m[2]);
-                if (defined($m[2][0])) {
-                    return constant($m[2][0]);
-                } else {
-                    return null;
-                }
-
-            }
-            if ($cur !== $this->globals) {
-                array_shift($m[2]);
-                array_shift($m[1]);
-            }
-        } elseif ($i === '__' || $i === '_root') {
-            $cur = $this->data;
-            array_shift($m[2]);
-            array_shift($m[1]);
-        } elseif ($i === '_' || $i === '_parent') {
-            $tree = $this->scopeTree;
-            $cur = $this->data;
-
-            while (true) {
-                array_pop($tree);
-                array_shift($m[2]);
-                array_shift($m[1]);
-                if (current($m[2]) === '_' || current($m[2]) === '_parent') {
-                    continue;
-                }
-
-                while (($i = array_shift($tree)) !== null) {
-                    if (is_object($cur)) {
-                        $cur = $cur->$i;
-                    } else {
-                        $cur = $cur[$i];
-                    }
-                }
-                break;
-            }
-        } else {
-            $cur = $this->scope;
-        }
-
-        while (list($k, $sep) = each($m[1])) {
-            if ($sep === '.' || $sep === '[' || $sep === '') {
-                if ((is_array($cur) || $cur instanceof ArrayAccess) && isset($cur[$m[2][$k]])) {
-                    $cur = $cur[$m[2][$k]];
-                } else {
-                    return null;
-                }
-            } elseif ($sep === '->') {
-                if (is_object($cur)) {
-                    $cur = $cur->$m[2][$k];
-                } else {
-                    return null;
-                }
-            } else {
-                return null;
-            }
-        }
-
-        return $cur;
-    }
-
-    /**
-     * [runtime function] assign the value to the given variable
-     *
-     * @param mixed $value the value to assign
-     * @param string $scope the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
-     * @return bool true if assigned correctly or false if a problem occured while parsing the var string
-     */
-    public function assignInScope($value, $scope)
-    {
-        $tree =& $this->scopeTree;
-        $data =& $this->data;
-
-        if (!is_string($scope)) {
-            return $this->triggerError('Assignments must be done into strings, ('.gettype($scope).') '.var_export($scope, true).' given', E_USER_ERROR);
-        }
-        if (strstr($scope, '.') === false && strstr($scope, '->') === false) {
-            $this->scope[$scope] = $value;
-        } else {
-            // TODO handle _root/_parent scopes ?
-            preg_match_all('#(\[|->|\.)?([^.[\]-]+)\]?#i', $scope, $m);
-
-            $cur =& $this->scope;
-            $last = array(array_pop($m[1]), array_pop($m[2]));
-
-            while (list($k, $sep) = each($m[1])) {
-                if ($sep === '.' || $sep === '[' || $sep === '') {
-                    if (is_array($cur) === false) {
-                        $cur = array();
-                    }
-                    $cur =& $cur[$m[2][$k]];
-                } elseif ($sep === '->') {
-                    if (is_object($cur) === false) {
-                        $cur = new stdClass;
-                    }
-                    $cur =& $cur->$m[2][$k];
-                } else {
-                    return false;
-                }
-            }
-
-            if ($last[0] === '.' || $last[0] === '[' || $last[0] === '') {
-                if (is_array($cur) === false) {
-                    $cur = array();
-                }
-                $cur[$last[1]] = $value;
-            } elseif ($last[0] === '->') {
-                if (is_object($cur) === false) {
-                    $cur = new stdClass;
-                }
-                $cur->$last[1] = $value;
-            } else {
-                return false;
-            }
-        }
-    }
-
-    /**
-     * [runtime function] sets the scope to the given scope string or array
-     *
-     * @param mixed $scope a string i.e. "level1.level2" or an array i.e. array("level1", "level2")
-     * @param bool $absolute if true, the scope is set from the top level scope and not from the current scope
-     * @return array the current scope tree
-     */
-    public function setScope($scope, $absolute = false)
-    {
-        $old = $this->scopeTree;
-
-        if (is_string($scope)===true) {
-            $scope = explode('.', $scope);
-        }
-
-        if ($absolute===true) {
-            $this->scope =& $this->data;
-            $this->scopeTree = array();
-        }
-
-        while (($bit = array_shift($scope)) !== null) {
-            if ($bit === '_' || $bit === '_parent') {
-                array_pop($this->scopeTree);
-                $this->scope =& $this->data;
-                $cnt = count($this->scopeTree);
-                for ($i=0;$i<$cnt;$i++)
-                    $this->scope =& $this->scope[$this->scopeTree[$i]];
-            } elseif ($bit === '__' || $bit === '_root') {
-                $this->scope =& $this->data;
-                $this->scopeTree = array();
-            } elseif (isset($this->scope[$bit])) {
-                if($this->scope instanceof ArrayAccess) {
-                    $tmp = $this->scope[$bit];
-                    $this->scope =& $tmp;
-                } else {
-                    $this->scope =& $this->scope[$bit];
-                }
-                $this->scopeTree[] = $bit;
-            } else {
-                unset($this->scope);
-                $this->scope = null;
-            }
-        }
-
-        return $old;
-    }
-
-    /**
-     * [runtime function] returns the entire data array
-     *
-     * @return array
-     */
-    public function getData()
-    {
-        return $this->data;
-    }
+			preg_match_all('#(\[|->|\.)?((?:[^.[\]-]|-(?!>))+)\]?#i', $varstr, $m);
+		}
+
+		$i = $m[2][0];
+		if ($i === 'dwoo') {
+			$cur = $this->globals;
+			array_shift($m[2]);
+			array_shift($m[1]);
+			switch ($m[2][0]) {
+
+			case 'get':
+				$cur = $_GET;
+				break;
+			case 'post':
+				$cur = $_POST;
+				break;
+			case 'session':
+				$cur = $_SESSION;
+				break;
+			case 'cookies':
+			case 'cookie':
+				$cur = $_COOKIE;
+				break;
+			case 'server':
+				$cur = $_SERVER;
+				break;
+			case 'env':
+				$cur = $_ENV;
+				break;
+			case 'request':
+				$cur = $_REQUEST;
+				break;
+			case 'const':
+				array_shift($m[2]);
+				if (defined($m[2][0])) {
+					return constant($m[2][0]);
+				} else {
+					return null;
+				}
 
-    /**
-     * [runtime function] sets a return value for the currently running template
-     *
-     * @param string $name var name
-     * @param mixed $value var value
-     */
-    public function setReturnValue($name, $value)
-    {
-        $this->returnData[$name] = $value;
-    }
+			}
+			if ($cur !== $this->globals) {
+				array_shift($m[2]);
+				array_shift($m[1]);
+			}
+		} elseif ($i === '__' || $i === '_root') {
+			$cur = $this->data;
+			array_shift($m[2]);
+			array_shift($m[1]);
+		} elseif ($i === '_' || $i === '_parent') {
+			$tree = $this->scopeTree;
+			$cur = $this->data;
+
+			while (true) {
+				array_pop($tree);
+				array_shift($m[2]);
+				array_shift($m[1]);
+				if (current($m[2]) === '_' || current($m[2]) === '_parent') {
+					continue;
+				}
 
-    /**
-     * [runtime function] retrieves the return values set by the template
-     *
-     * @return array
-     */
-    public function getReturnValues()
-    {
-        return $this->returnData;
-    }
+				while (($i = array_shift($tree)) !== null) {
+					if (is_object($cur)) {
+						$cur = $cur->$i;
+					} else {
+						$cur = $cur[$i];
+					}
+				}
+				break;
+			}
+		} else {
+			$cur = $this->scope;
+		}
 
-    /**
-     * [runtime function] returns a reference to the current scope
-     *
-     * @return &mixed
-     */
-    public function &getScope()
-    {
-        return $this->scope;
-    }
+		while (list($k, $sep) = each($m[1])) {
+			if ($sep === '.' || $sep === '[' || $sep === '') {
+				if ((is_array($cur) || $cur instanceof ArrayAccess) && isset($cur[$m[2][$k]])) {
+					$cur = $cur[$m[2][$k]];
+				} else {
+					return null;
+				}
+			} elseif ($sep === '->') {
+				if (is_object($cur)) {
+					$cur = $cur->$m[2][$k];
+				} else {
+					return null;
+				}
+			} else {
+				return null;
+			}
+		}
+
+		return $cur;
+	}
+
+	/**
+	 * [runtime function] assign the value to the given variable
+	 *
+	 * @param mixed $value the value to assign
+	 * @param string $scope the variable string, using dwoo variable syntax (i.e. "var.subvar[subsubvar]->property")
+	 * @return bool true if assigned correctly or false if a problem occured while parsing the var string
+	 */
+	public function assignInScope($value, $scope)
+	{
+		$tree =& $this->scopeTree;
+		$data =& $this->data;
+
+		if (!is_string($scope)) {
+			return $this->triggerError('Assignments must be done into strings, ('.gettype($scope).') '.var_export($scope, true).' given', E_USER_ERROR);
+		}
+		if (strstr($scope, '.') === false && strstr($scope, '->') === false) {
+			$this->scope[$scope] = $value;
+		} else {
+			// TODO handle _root/_parent scopes ?
+			preg_match_all('#(\[|->|\.)?([^.[\]-]+)\]?#i', $scope, $m);
+
+			$cur =& $this->scope;
+			$last = array(array_pop($m[1]), array_pop($m[2]));
+
+			while (list($k, $sep) = each($m[1])) {
+				if ($sep === '.' || $sep === '[' || $sep === '') {
+					if (is_array($cur) === false) {
+						$cur = array();
+					}
+					$cur =& $cur[$m[2][$k]];
+				} elseif ($sep === '->') {
+					if (is_object($cur) === false) {
+						$cur = new stdClass;
+					}
+					$cur =& $cur->$m[2][$k];
+				} else {
+					return false;
+				}
+			}
 
-    /**
-     * Redirects all calls to unexisting to plugin proxy.
-     *
-     * @param string Method name
-     * @param array  List of arguments
-     * @return mixed
-     */
-    public function __call($method, $args) {
-        $proxy = $this->getPluginProxy();
-        if (!$proxy) {
-            throw new Dwoo_Exception('Call to undefined method '.__CLASS__.'::'.$method.'()');
-        }
-        return call_user_func_array($proxy->getCallback($method), $args);
-    }
+			if ($last[0] === '.' || $last[0] === '[' || $last[0] === '') {
+				if (is_array($cur) === false) {
+					$cur = array();
+				}
+				$cur[$last[1]] = $value;
+			} elseif ($last[0] === '->') {
+				if (is_object($cur) === false) {
+					$cur = new stdClass;
+				}
+				$cur->$last[1] = $value;
+			} else {
+				return false;
+			}
+		}
+	}
+
+	/**
+	 * [runtime function] sets the scope to the given scope string or array
+	 *
+	 * @param mixed $scope a string i.e. "level1.level2" or an array i.e. array("level1", "level2")
+	 * @param bool $absolute if true, the scope is set from the top level scope and not from the current scope
+	 * @return array the current scope tree
+	 */
+	public function setScope($scope, $absolute = false)
+	{
+		$old = $this->scopeTree;
+
+		if (is_string($scope)===true) {
+			$scope = explode('.', $scope);
+		}
+
+		if ($absolute===true) {
+			$this->scope =& $this->data;
+			$this->scopeTree = array();
+		}
+
+		while (($bit = array_shift($scope)) !== null) {
+			if ($bit === '_' || $bit === '_parent') {
+				array_pop($this->scopeTree);
+				$this->scope =& $this->data;
+				$cnt = count($this->scopeTree);
+				for ($i=0;$i<$cnt;$i++)
+					$this->scope =& $this->scope[$this->scopeTree[$i]];
+			} elseif ($bit === '__' || $bit === '_root') {
+				$this->scope =& $this->data;
+				$this->scopeTree = array();
+			} elseif (isset($this->scope[$bit])) {
+				if($this->scope instanceof ArrayAccess) {
+					$tmp = $this->scope[$bit];
+					$this->scope =& $tmp;
+				} else {
+					$this->scope =& $this->scope[$bit];
+				}
+				$this->scopeTree[] = $bit;
+			} else {
+				unset($this->scope);
+				$this->scope = null;
+			}
+		}
+
+		return $old;
+	}
+
+	/**
+	 * [runtime function] returns the entire data array
+	 *
+	 * @return array
+	 */
+	public function getData()
+	{
+		return $this->data;
+	}
+
+	/**
+	 * [runtime function] sets a return value for the currently running template
+	 *
+	 * @param string $name var name
+	 * @param mixed $value var value
+	 */
+	public function setReturnValue($name, $value)
+	{
+		$this->returnData[$name] = $value;
+	}
+
+	/**
+	 * [runtime function] retrieves the return values set by the template
+	 *
+	 * @return array
+	 */
+	public function getReturnValues()
+	{
+		return $this->returnData;
+	}
+
+	/**
+	 * [runtime function] returns a reference to the current scope
+	 *
+	 * @return &mixed
+	 */
+	public function &getScope()
+	{
+		return $this->scope;
+	}
+
+	/**
+	 * Redirects all calls to unexisting to plugin proxy.
+	 *
+	 * @param string Method name
+	 * @param array  List of arguments
+	 * @return mixed
+	 */
+	public function __call($method, $args) {
+		$proxy = $this->getPluginProxy();
+		if (!$proxy) {
+			throw new Dwoo_Exception('Call to undefined method '.__CLASS__.'::'.$method.'()');
+		}
+		return call_user_func_array($proxy->getCallback($method), $args);
+	}
 }

Braces +3 added lines, -2 removed lines

@@ -1538,8 +1538,9 @@
                 array_pop($this->scopeTree);
                 $this->scope =& $this->data;
                 $cnt = count($this->scopeTree);
-                for ($i=0;$i<$cnt;$i++)
-                    $this->scope =& $this->scope[$this->scopeTree[$i]];
+                for ($i=0;$i<$cnt;$i++) {
+                                    $this->scope =& $this->scope[$this->scopeTree[$i]];
+                }
             } elseif ($bit === '__' || $bit === '_root') {
                 $this->scope =& $this->data;
                 $this->scopeTree = array();

lib/Dwoo/Smarty/Adapter.php

Braces +18 added lines, -14 removed lines

@@ -297,9 +297,10 @@ 
 
 	public function unregister_prefilter($callback)
 	{
-		foreach ($this->_filters['pre'] as $index => $processor)
-			if ($processor->callback === $callback) {
+		foreach ($this->_filters['pre'] as $index => $processor) {
+					if ($processor->callback === $callback) {
 				$this->compiler->removePostProcessor($processor);
+		}
 				unset($this->_filters['pre'][$index]);
 			}
 	}
@@ -314,9 +315,10 @@ 
 
 	public function unregister_postfilter($callback)
 	{
-		foreach ($this->_filters['post'] as $index => $processor)
-			if ($processor->callback === $callback) {
+		foreach ($this->_filters['post'] as $index => $processor) {
+					if ($processor->callback === $callback) {
 				$this->compiler->removePostProcessor($processor);
+		}
 				unset($this->_filters['post'][$index]);
 			}
 	}
@@ -331,9 +333,10 @@ 
 
 	public function unregister_outputfilter($callback)
 	{
-		foreach ($this->_filters['output'] as $index => $filter)
-			if ($filter->callback === $callback) {
+		foreach ($this->_filters['output'] as $index => $filter) {
+					if ($filter->callback === $callback) {
 				$this->removeOutputFilter($filter);
+		}
 				unset($this->_filters['output'][$index]);
 			}
 	}
@@ -419,10 +422,11 @@ 
 		}
 
 		$data = $this->dataProvider->getData();
-   		if ($name === null)
-   			return $data;
-   		elseif (isset($data[$name]))
-   			return $data[$name];
+   		if ($name === null) {
+   		   			return $data;
+   		} elseif (isset($data[$name])) {
+   		   			return $data[$name];
+   		}
    		return null;
    	}
 
@@ -450,8 +454,9 @@ 
 
 	protected function makeTemplate($file, $cacheId, $compileId)
 	{
-   		if ($compileId === null)
-   			$compileId = $this->compile_id;
+   		if ($compileId === null) {
+   		   			$compileId = $this->compile_id;
+   		}
 
 		$hash = bin2hex(md5($file.$cacheId.$compileId, true));
 		if (!isset(self::$tplCache[$hash])) {
@@ -511,8 +516,7 @@ 
 {
 	interface Smarty {}
 	class Dwoo_Smarty_Adapter extends Dwoo_Smarty__Adapter implements Smarty {}
-}
-else
+} else
 {
 	class Dwoo_Smarty_Adapter extends Dwoo_Smarty__Adapter {}
 }

lib/Dwoo/Security/Policy.php

Braces +30 added lines, -24 removed lines

@@ -100,11 +100,12 @@ 
 	 */
 	public function allowPhpFunction($func)
 	{
-		if (is_array($func))
-			foreach ($func as $fname)
+		if (is_array($func)) {
+					foreach ($func as $fname)
 				$this->allowedPhpFunctions[strtolower($fname)] = true;
-		else
-			$this->allowedPhpFunctions[strtolower($func)] = true;
+		} else {
+					$this->allowedPhpFunctions[strtolower($func)] = true;
+		}
 	}
 
 	/**
@@ -114,11 +115,12 @@ 
 	 */
 	public function disallowPhpFunction($func)
 	{
-		if (is_array($func))
-			foreach ($func as $fname)
+		if (is_array($func)) {
+					foreach ($func as $fname)
 				unset($this->allowedPhpFunctions[strtolower($fname)]);
-		else
-			unset($this->allowedPhpFunctions[strtolower($func)]);
+		} else {
+					unset($this->allowedPhpFunctions[strtolower($func)]);
+		}
 	}
 
 	/**
@@ -142,11 +144,12 @@ 
 	 */
 	public function allowMethod($class, $method = null)
 	{
-		if (is_array($class))
-			foreach ($class as $elem)
+		if (is_array($class)) {
+					foreach ($class as $elem)
 				$this->allowedMethods[strtolower($elem[0])][strtolower($elem[1])] = true;
-		else
-			$this->allowedMethods[strtolower($class)][strtolower($method)] = true;
+		} else {
+					$this->allowedMethods[strtolower($class)][strtolower($method)] = true;
+		}
 	}
 
 	/**
@@ -157,11 +160,12 @@ 
 	 */
 	public function disallowMethod($class, $method = null)
 	{
-		if (is_array($class))
-			foreach ($class as $elem)
+		if (is_array($class)) {
+					foreach ($class as $elem)
 				unset($this->allowedMethods[strtolower($elem[0])][strtolower($elem[1])]);
-		else
-			unset($this->allowedMethods[strtolower($class)][strtolower($method)]);
+		} else {
+					unset($this->allowedMethods[strtolower($class)][strtolower($method)]);
+		}
 	}
 
 	/**
@@ -185,11 +189,12 @@ 
 	 */
 	public function allowDirectory($path)
 	{
-		if (is_array($path))
-			foreach ($path as $dir)
+		if (is_array($path)) {
+					foreach ($path as $dir)
 				$this->allowedDirectories[realpath($dir)] = true;
-		else
-			$this->allowedDirectories[realpath($path)] = true;
+		} else {
+					$this->allowedDirectories[realpath($path)] = true;
+		}
 	}
 
 	/**
@@ -199,11 +204,12 @@ 
 	 */
 	public function disallowDirectory($path)
 	{
-		if (is_array($path))
-			foreach ($path as $dir)
+		if (is_array($path)) {
+					foreach ($path as $dir)
 				unset($this->allowedDirectories[realpath($dir)]);
-		else
-			unset($this->allowedDirectories[realpath($path)]);
+		} else {
+					unset($this->allowedDirectories[realpath($path)]);
+		}
 	}
 
 	/**

lib/Dwoo/Compiler.php

Braces +156 added lines, -57 removed lines

@@ -713,9 +713,13 @@ 
 				$compiled = $this->addBlock('topLevelBlock', array(), 0);
 				$this->stack[0]['buffer'] = '';
 
-				if ($this->debug) echo 'COMPILER INIT<br />';
+				if ($this->debug) {
+					echo 'COMPILER INIT<br />';
+				}
 
-				if ($this->debug) echo 'PROCESSING PREPROCESSORS ('.count($this->processors['pre']).')<br>';
+				if ($this->debug) {
+					echo 'PROCESSING PREPROCESSORS ('.count($this->processors['pre']).')<br>';
+				}
 
 				// runs preprocessors
 				foreach ($this->processors['pre'] as $preProc) {
@@ -731,7 +735,9 @@ 
 				unset($preProc);
 
 				// show template source if debug
-				if ($this->debug) echo '<pre>'.print_r(htmlentities($tpl), true).'</pre><hr />';
+				if ($this->debug) {
+					echo '<pre>'.print_r(htmlentities($tpl), true).'</pre><hr />';
+				}
 
 				// strips php tags if required by the security policy
 				if ($this->securityPolicy !== null) {
@@ -820,7 +826,9 @@ 
 
 		$compiled .= $this->removeBlock('topLevelBlock');
 
-		if ($this->debug) echo 'PROCESSING POSTPROCESSORS<br>';
+		if ($this->debug) {
+			echo 'PROCESSING POSTPROCESSORS<br>';
+		}
 
 		foreach ($this->processors['post'] as $postProc) {
 			if (is_array($postProc) && isset($postProc['autoload'])) {
@@ -834,7 +842,9 @@ 
 		}
 		unset($postProc);
 
-		if ($this->debug) echo 'COMPILATION COMPLETE : MEM USAGE : '.memory_get_usage().'<br>';
+		if ($this->debug) {
+			echo 'COMPILATION COMPLETE : MEM USAGE : '.memory_get_usage().'<br>';
+		}
 
 		$output = "<?php\n/* template head */\n";
 
@@ -902,7 +912,9 @@ 
 				echo ($i+1).'. '.$line."\r\n";
 			}
 		}
-		if ($this->debug) echo '<hr></pre></pre>';
+		if ($this->debug) {
+			echo '<hr></pre></pre>';
+		}
 
 		$this->template = $this->dwoo = null;
 		$tpl = null;
@@ -987,8 +999,9 @@ 
 				reset($this->scopeTree);
 				$this->scope =& $this->data;
 				$cnt = count($this->scopeTree);
-				for ($i=0;$i<$cnt;$i++)
-					$this->scope =& $this->scope[$this->scopeTree[$i]];
+				for ($i=0;$i<$cnt;$i++) {
+									$this->scope =& $this->scope[$this->scopeTree[$i]];
+				}
 			} elseif ($bit === '_root' || $bit === '__') {
 				$this->scope =& $this->data;
 				$this->scopeTree = array();
@@ -1253,7 +1266,9 @@ 
 			if ($curBlock === 'root' && substr($in, $from, strlen($this->rd)) === $this->rd) {
 				// end template tag
 				$pointer += strlen($this->rd);
-				if ($this->debug) echo 'TEMPLATE PARSING ENDED<br />';
+				if ($this->debug) {
+					echo 'TEMPLATE PARSING ENDED<br />';
+				}
 				return false;
 			}
 			$from++;
@@ -1272,7 +1287,9 @@ 
 
 		$substr = substr($in, $from, $to-$from);
 
-		if ($this->debug) echo '<br />PARSE CALL : PARSING "<b>'.htmlentities(substr($in, $from, min($to-$from, 50))).(($to-$from) > 50 ? '...':'').'</b>" @ '.$from.':'.$to.' in '.$curBlock.' : pointer='.$pointer.'<br/>';
+		if ($this->debug) {
+			echo '<br />PARSE CALL : PARSING "<b>'.htmlentities(substr($in, $from, min($to-$from, 50))).(($to-$from) > 50 ? '...':'').'</b>" @ '.$from.':'.$to.' in '.$curBlock.' : pointer='.$pointer.'<br/>';
+		}
 		$parsed = "";
 
 		if ($curBlock === 'root' && $first === '*') {
@@ -1357,7 +1374,9 @@ 
 			$parsed = 'func';
 		} elseif ($first === ';') {
 			// instruction end
-			if ($this->debug) echo 'END OF INSTRUCTION<br />';
+			if ($this->debug) {
+				echo 'END OF INSTRUCTION<br />';
+			}
 			if ($pointer !== null) {
 				$pointer++;
 			}
@@ -1377,20 +1396,28 @@ 
 				if ($this->curBlock['type'] == 'else' || $this->curBlock['type'] == 'elseif') {
 					$pointer -= strlen($match[0]);
 				}
-				if ($this->debug) echo 'TOP BLOCK CLOSED<br />';
+				if ($this->debug) {
+					echo 'TOP BLOCK CLOSED<br />';
+				}
 				return $this->removeTopBlock();
 			} else {
-				if ($this->debug) echo 'BLOCK OF TYPE '.$match[1].' CLOSED<br />';
+				if ($this->debug) {
+					echo 'BLOCK OF TYPE '.$match[1].' CLOSED<br />';
+				}
 				return $this->removeBlock($match[1]);
 			}
 		} elseif ($curBlock === 'root' && substr($substr, 0, strlen($this->rd)) === $this->rd) {
 			// end template tag
-			if ($this->debug) echo 'TAG PARSING ENDED<br />';
+			if ($this->debug) {
+				echo 'TAG PARSING ENDED<br />';
+			}
 			$pointer += strlen($this->rd);
 			return false;
 		} elseif (is_array($parsingParams) && preg_match('#^(([\'"]?)[a-z0-9_]+\2\s*='.($curBlock === 'array' ? '>?':'').')(?:\s+|[^=]).*#i', $substr, $match)) {
 			// named parameter
-			if ($this->debug) echo 'NAMED PARAM FOUND<br />';
+			if ($this->debug) {
+				echo 'NAMED PARAM FOUND<br />';
+			}
 			$len = strlen($match[1]);
 			while (substr($in, $from+$len, 1)===' ') {
 				$len++;
@@ -1430,7 +1457,9 @@ 
 		// var parsed, check if any var-extension applies
 		if ($parsed==='var') {
 			if (preg_match('#^\s*([/%+*-])\s*([a-z0-9]|\$)#i', $substr, $match)) {
-				if($this->debug) echo 'PARSING POST-VAR EXPRESSION '.$substr.'<br />';
+				if($this->debug) {
+					echo 'PARSING POST-VAR EXPRESSION '.$substr.'<br />';
+				}
 				// parse expressions
 				$pointer += strlen($match[0]) - 1;
 				if (is_array($parsingParams)) {
@@ -1460,7 +1489,9 @@ 
 					}
 				}
 			} else if ($curBlock === 'root' && preg_match('#^(\s*(?:[+/*%-.]=|=|\+\+|--)\s*)(.*)#s', $substr, $match)) {
-				if($this->debug) echo 'PARSING POST-VAR ASSIGNMENT '.$substr.'<br />';
+				if($this->debug) {
+					echo 'PARSING POST-VAR ASSIGNMENT '.$substr.'<br />';
+				}
 				// parse assignment
 				$value = $match[2];
 				$operator = trim($match[1]);
@@ -1502,7 +1533,9 @@ 
 				$out = Dwoo_Compiler::PHP_OPEN. $echo . $out . $operator . implode(' ', $value) . Dwoo_Compiler::PHP_CLOSE;
 			} else if ($curBlock === 'array' && is_array($parsingParams) && preg_match('#^(\s*=>?\s*)#', $substr, $match)) {
 				// parse namedparam with var as name (only for array)
-				if ($this->debug) echo 'VARIABLE NAMED PARAM (FOR ARRAY) FOUND<br />';
+				if ($this->debug) {
+					echo 'VARIABLE NAMED PARAM (FOR ARRAY) FOUND<br />';
+				}
 				$len = strlen($match[1]);
 				$var = $out[count($out)-1];
 				$pointer += $len;
@@ -1576,7 +1609,9 @@ 
 			$cmdstr = $match[1];
 		}
 
-		if ($this->debug) echo 'FUNC FOUND ('.$func.')<br />';
+		if ($this->debug) {
+			echo 'FUNC FOUND ('.$func.')<br />';
+		}
 
 		$paramsep = '';
 
@@ -1638,17 +1673,25 @@ 
 							}
 
 							if ($func !== 'if' && $func !== 'elseif' && $paramstr[$ptr] === ')') {
-								if ($this->debug) echo 'PARAM PARSING ENDED, ")" FOUND, POINTER AT '.$ptr.'<br/>';
+								if ($this->debug) {
+									echo 'PARAM PARSING ENDED, ")" FOUND, POINTER AT '.$ptr.'<br/>';
+								}
 								break 2;
 							} elseif ($paramstr[$ptr] === ';') {
 								$ptr++;
-								if ($this->debug) echo 'PARAM PARSING ENDED, ";" FOUND, POINTER AT '.$ptr.'<br/>';
+								if ($this->debug) {
+									echo 'PARAM PARSING ENDED, ";" FOUND, POINTER AT '.$ptr.'<br/>';
+								}
 								break 2;
 							} elseif ($func !== 'if' && $func !== 'elseif' && $paramstr[$ptr] === '/') {
-								if ($this->debug) echo 'PARAM PARSING ENDED, "/" FOUND, POINTER AT '.$ptr.'<br/>';
+								if ($this->debug) {
+									echo 'PARAM PARSING ENDED, "/" FOUND, POINTER AT '.$ptr.'<br/>';
+								}
 								break 2;
 							} elseif (substr($paramstr, $ptr, strlen($this->rd)) === $this->rd) {
-								if ($this->debug) echo 'PARAM PARSING ENDED, RIGHT DELIMITER FOUND, POINTER AT '.$ptr.'<br/>';
+								if ($this->debug) {
+									echo 'PARAM PARSING ENDED, RIGHT DELIMITER FOUND, POINTER AT '.$ptr.'<br/>';
+								}
 								break 2;
 							}
 
@@ -1659,7 +1702,9 @@ 
 							}
 						}
 
-						if ($this->debug) echo 'FUNC START PARAM PARSING WITH POINTER AT '.$ptr.'<br/>';
+						if ($this->debug) {
+							echo 'FUNC START PARAM PARSING WITH POINTER AT '.$ptr.'<br/>';
+						}
 
 						if ($func === 'if' || $func === 'elseif' || $func === 'tif') {
 							$params = $this->parse($paramstr, $ptr, strlen($paramstr), $params, 'condition', $ptr);
@@ -1669,7 +1714,9 @@ 
 							$params = $this->parse($paramstr, $ptr, strlen($paramstr), $params, 'function', $ptr);
 						}
 
-						if ($this->debug) echo 'PARAM PARSED, POINTER AT '.$ptr.' ('.substr($paramstr, $ptr-1, 3).')<br/>';
+						if ($this->debug) {
+							echo 'PARAM PARSED, POINTER AT '.$ptr.' ('.substr($paramstr, $ptr-1, 3).')<br/>';
+						}
 					}
 				}
 				$paramstr = substr($paramstr, 0, $ptr);
@@ -1693,7 +1740,9 @@ 
 
 		if ($pointer !== null) {
 			$pointer += (isset($paramstr) ? strlen($paramstr) : 0) + (')' === $paramsep ? 2 : ($paramspos === false ? 0 : 1)) + strlen($func) + (isset($whitespace) ? $whitespace : 0);
-			if ($this->debug) echo 'FUNC ADDS '.((isset($paramstr) ? strlen($paramstr) : 0) + (')' === $paramsep ? 2 : ($paramspos === false ? 0 : 1)) + strlen($func)).' TO POINTER<br/>';
+			if ($this->debug) {
+				echo 'FUNC ADDS '.((isset($paramstr) ? strlen($paramstr) : 0) + (')' === $paramsep ? 2 : ($paramspos === false ? 0 : 1)) + strlen($func)).' TO POINTER<br/>';
+			}
 		}
 
 		if ($curBlock === 'method' || $func === 'do' || strstr($func, '::') !== false) {
@@ -1931,7 +1980,9 @@ 
 		$substr = substr($in, $from, $to-$from);
 		$first = $substr[0];
 
-		if ($this->debug) echo 'STRING FOUND (in '.htmlentities(substr($in, $from, min($to-$from, 50))).(($to-$from) > 50 ? '...':'').')<br />';
+		if ($this->debug) {
+			echo 'STRING FOUND (in '.htmlentities(substr($in, $from, min($to-$from, 50))).(($to-$from) > 50 ? '...':'').')<br />';
+		}
 		$strend = false;
 		$o = $from+1;
 		while ($strend === false) {
@@ -1944,7 +1995,9 @@ 
 				$strend = false;
 			}
 		}
-		if ($this->debug) echo 'STRING DELIMITED: '.substr($in, $from, $strend+1-$from).'<br/>';
+		if ($this->debug) {
+			echo 'STRING DELIMITED: '.substr($in, $from, $strend+1-$from).'<br/>';
+		}
 
 		$srcOutput = substr($in, $from, $strend+1-$from);
 
@@ -2150,11 +2203,15 @@ 
 				}
 				unset($uid, $current, $curTxt, $tree, $chars);
 
-				if ($this->debug) echo 'RECURSIVE VAR REPLACEMENT : '.$key.'<br>';
+				if ($this->debug) {
+					echo 'RECURSIVE VAR REPLACEMENT : '.$key.'<br>';
+				}
 
 				$key = $this->flattenVarTree($parsed);
 
-				if ($this->debug) echo 'RECURSIVE VAR REPLACEMENT DONE : '.$key.'<br>';
+				if ($this->debug) {
+					echo 'RECURSIVE VAR REPLACEMENT DONE : '.$key.'<br>';
+				}
 
 				$output = preg_replace('#(^""\.|""\.|\.""$|(\()""\.|\.""(\)))#', '$2$3', '$this->readVar("'.$key.'")');
 			} else {
@@ -2334,8 +2391,9 @@ 
 				$global = 'COOKIE';
 			}
 			$key = '$_'.$global;
-			foreach (explode('.', ltrim($m[2], '.')) as $part)
-				$key .= '['.var_export($part, true).']';
+			foreach (explode('.', ltrim($m[2], '.')) as $part) {
+							$key .= '['.var_export($part, true).']';
+			}
 			if ($curBlock === 'root') {
 				$output = $key;
 			} else {
@@ -2445,7 +2503,9 @@ 
 				} else {
 					$cnt = substr_count($key, '$');
 
-					if ($this->debug) echo 'PARSING SUBVARS IN : '.$key.'<br>';
+					if ($this->debug) {
+						echo 'PARSING SUBVARS IN : '.$key.'<br>';
+					}
 					if ($cnt > 0) {
 						while (--$cnt >= 0) {
 							if (isset($last)) {
@@ -2467,7 +2527,9 @@ 
 								$last,
 								$len
 							);
-							if ($this->debug) echo 'RECURSIVE VAR REPLACEMENT DONE : '.$key.'<br>';
+							if ($this->debug) {
+								echo 'RECURSIVE VAR REPLACEMENT DONE : '.$key.'<br>';
+							}
 						}
 						unset($last);
 
@@ -2548,15 +2610,21 @@ 
 		$substr = trim($substr);
 
 		if (strtolower($substr) === 'false' || strtolower($substr) === 'no' || strtolower($substr) === 'off') {
-			if ($this->debug) echo 'BOOLEAN(FALSE) PARSED<br />';
+			if ($this->debug) {
+				echo 'BOOLEAN(FALSE) PARSED<br />';
+			}
 			$substr = 'false';
 			$type = self::T_BOOL;
 		} elseif (strtolower($substr) === 'true' || strtolower($substr) === 'yes' || strtolower($substr) === 'on') {
-			if ($this->debug) echo 'BOOLEAN(TRUE) PARSED<br />';
+			if ($this->debug) {
+				echo 'BOOLEAN(TRUE) PARSED<br />';
+			}
 			$substr = 'true';
 			$type = self::T_BOOL;
 		} elseif ($substr === 'null' || $substr === 'NULL') {
-			if ($this->debug) echo 'NULL PARSED<br />';
+			if ($this->debug) {
+				echo 'NULL PARSED<br />';
+			}
 			$substr = 'null';
 			$type = self::T_NULL;
 		} elseif (is_numeric($substr)) {
@@ -2565,19 +2633,27 @@ 
 				$substr = (int) $substr;
 			}
 			$type = self::T_NUMERIC;
-			if ($this->debug) echo 'NUMBER ('.$substr.') PARSED<br />';
+			if ($this->debug) {
+				echo 'NUMBER ('.$substr.') PARSED<br />';
+			}
 		} elseif (preg_match('{^-?(\d+|\d*(\.\d+))\s*([/*%+-]\s*-?(\d+|\d*(\.\d+)))+$}', $substr)) {
-			if ($this->debug) echo 'SIMPLE MATH PARSED<br />';
+			if ($this->debug) {
+				echo 'SIMPLE MATH PARSED<br />';
+			}
 			$type = self::T_MATH;
 			$substr = '('.$substr.')';
 		} elseif ($curBlock === 'condition' && array_search($substr, $breakChars, true) !== false) {
-			if ($this->debug) echo 'BREAKCHAR ('.$substr.') PARSED<br />';
+			if ($this->debug) {
+				echo 'BREAKCHAR ('.$substr.') PARSED<br />';
+			}
 			$type = self::T_BREAKCHAR;
 			//$substr = '"'.$substr.'"';
 		} else {
 			$substr = $this->replaceStringVars('\''.str_replace('\'', '\\\'', $substr).'\'', '\'', $curBlock);
 			$type = self::T_UNQUOTED_STRING;
-			if ($this->debug) echo 'BLABBER ('.$substr.') CASTED AS STRING<br />';
+			if ($this->debug) {
+				echo 'BLABBER ('.$substr.') CASTED AS STRING<br />';
+			}
 		}
 
 		if (is_array($parsingParams)) {
@@ -2603,7 +2679,9 @@ 
 	protected function replaceStringVars($string, $first, $curBlock='')
 	{
 		$pos = 0;
-		if ($this->debug) echo 'STRING VAR REPLACEMENT : '.$string.'<br>';
+		if ($this->debug) {
+			echo 'STRING VAR REPLACEMENT : '.$string.'<br>';
+		}
 		// replace vars
 		while (($pos = strpos($string, '$', $pos)) !== false) {
 			$prev = substr($string, $pos-1, 1);
@@ -2622,7 +2700,9 @@ 
 				$string = substr_replace($string, $first.'.'.$var[1].'.'.$first, $pos, $len);
 			}
 			$pos += strlen($var[1]) + 2;
-			if ($this->debug) echo 'STRING VAR REPLACEMENT DONE : '.$string.'<br>';
+			if ($this->debug) {
+				echo 'STRING VAR REPLACEMENT DONE : '.$string.'<br>';
+			}
 		}
 
 		// handle modifiers
@@ -2646,7 +2726,9 @@ 
 	 */
 	protected function replaceModifiers(array $m, $curBlock = null, &$pointer = null)
 	{
-		if ($this->debug) echo 'PARSING MODIFIERS : '.$m[3].'<br />';
+		if ($this->debug) {
+			echo 'PARSING MODIFIERS : '.$m[3].'<br />';
+		}
 
 		if ($pointer !== null) {
 			$pointer += strlen($m[3]);
@@ -2668,7 +2750,9 @@ 
 				continue;
 			}
 			if ($cmdstrsrc[0] === ' ' || $cmdstrsrc[0] === ';' || substr($cmdstrsrc, 0, strlen($this->rd)) === $this->rd) {
-				if ($this->debug) echo 'MODIFIER PARSING ENDED, RIGHT DELIMITER or ";" FOUND<br/>';
+				if ($this->debug) {
+					echo 'MODIFIER PARSING ENDED, RIGHT DELIMITER or ";" FOUND<br/>';
+				}
 				$continue = false;
 				if ($pointer !== null) {
 					$pointer -= strlen($cmdstrsrc);
@@ -2687,7 +2771,9 @@ 
 			if ($paramspos === false) {
 				$cmdstrsrc = substr($cmdstrsrc, strlen($func));
 				$params = array();
-				if ($this->debug) echo 'MODIFIER ('.$func.') CALLED WITH NO PARAMS<br/>';
+				if ($this->debug) {
+					echo 'MODIFIER ('.$func.') CALLED WITH NO PARAMS<br/>';
+				}
 			} else {
 				$paramstr = substr($cmdstr, $paramspos+1);
 				if (substr($paramstr, -1, 1) === $paramsep) {
@@ -2697,18 +2783,28 @@ 
 				$ptr = 0;
 				$params = array();
 				while ($ptr < strlen($paramstr)) {
-					if ($this->debug) echo 'MODIFIER ('.$func.') START PARAM PARSING WITH POINTER AT '.$ptr.'<br/>';
-					if ($this->debug) echo $paramstr.'--'.$ptr.'--'.strlen($paramstr).'--modifier<br/>';
+					if ($this->debug) {
+						echo 'MODIFIER ('.$func.') START PARAM PARSING WITH POINTER AT '.$ptr.'<br/>';
+					}
+					if ($this->debug) {
+						echo $paramstr.'--'.$ptr.'--'.strlen($paramstr).'--modifier<br/>';
+					}
 					$params = $this->parse($paramstr, $ptr, strlen($paramstr), $params, 'modifier', $ptr);
-					if ($this->debug) echo 'PARAM PARSED, POINTER AT '.$ptr.'<br/>';
+					if ($this->debug) {
+						echo 'PARAM PARSED, POINTER AT '.$ptr.'<br/>';
+					}
 
 					if ($ptr >= strlen($paramstr)) {
-						if ($this->debug) echo 'PARAM PARSING ENDED, PARAM STRING CONSUMED<br/>';
+						if ($this->debug) {
+							echo 'PARAM PARSING ENDED, PARAM STRING CONSUMED<br/>';
+						}
 						break;
 					}
 
 					if ($paramstr[$ptr] === ' ' || $paramstr[$ptr] === '|' || $paramstr[$ptr] === ';' || substr($paramstr, $ptr, strlen($this->rd)) === $this->rd) {
-						if ($this->debug) echo 'PARAM PARSING ENDED, " ", "|", RIGHT DELIMITER or ";" FOUND, POINTER AT '.$ptr.'<br/>';
+						if ($this->debug) {
+							echo 'PARAM PARSING ENDED, " ", "|", RIGHT DELIMITER or ";" FOUND, POINTER AT '.$ptr.'<br/>';
+						}
 						if ($paramstr[$ptr] !== '|') {
 							$continue = false;
 							if ($pointer !== null) {
@@ -2769,8 +2865,9 @@ 
 				}
 			} elseif ($pluginType & Dwoo_Core::PROXY_PLUGIN) {
 				$params = $this->mapParams($params, $this->getDwoo()->getPluginProxy()->getCallback($func), $state);
-				foreach ($params as &$p)
-					$p = $p[0];
+				foreach ($params as &$p) {
+									$p = $p[0];
+				}
 				$output = call_user_func(array($this->dwoo->getPluginProxy(), 'getCode'), $func, $params);
 			} elseif ($pluginType & Dwoo_Core::SMARTY_MODIFIER) {
 				$params = $this->mapParams($params, null, $state);
@@ -2812,8 +2909,9 @@ 
 
 				$params = $this->mapParams($params, $callback, $state);
 
-				foreach ($params as &$p)
-					$p = $p[0];
+				foreach ($params as &$p) {
+									$p = $p[0];
+				}
 
 				if ($pluginType & Dwoo_Core::FUNC_PLUGIN) {
 					if ($pluginType & Dwoo_Core::COMPILABLE_PLUGIN) {
@@ -2904,8 +3002,9 @@ 
 		foreach ($params as $k=>$p) {
 			if (is_array($p)) {
 				$out2 = 'array(';
-				foreach ($p as $k2=>$v)
-					$out2 .= var_export($k2, true).' => '.(is_array($v) ? 'array('.self::implode_r($v, true).')' : $v).', ';
+				foreach ($p as $k2=>$v) {
+									$out2 .= var_export($k2, true).' => '.(is_array($v) ? 'array('.self::implode_r($v, true).')' : $v).', ';
+				}
 				$p = rtrim($out2, ', ').')';
 			}
 			if ($recursiveCall) {

lib/Dwoo/Adapters/CodeIgniter/libraries/Dwootemplate.php

Indentation +149 added lines, -149 removed lines

@@ -20,153 +20,153 @@
  * @uses the dwoo package from http://dwoo.org
  */
 class Dwootemplate extends Dwoo_Core {
-    protected $dwoo_data = array();
-
-    /**
-     * Constructor for the DwooTemplate engine
-     *
-     */
-    public function __construct() {
-        // Call parents constructor
-        parent::__construct();
-
-        // Set the config settings
-        $this->initialize();
-
-        // Assign some defaults to dwoo
-        $CI                         = get_instance();
-        $this->dwoo_data            = new Dwoo_Data();
-        $this->dwoo_data->js_files  = array();
-        $this->dwoo_data->css_files = array();
-        $this->dwoo_data->CI        = $CI;
-        $this->dwoo_data->site_url  = $CI->config->site_url(); // so we can get the full path to CI easily
-        $this->dwoo_data->uniqid    = uniqid();
-        $this->dwoo_data->timestamp = mktime();
-
-        log_message('debug', "Dwoo Template Class Initialized");
-    }
-
-
-    /**
-     * Assign data to dwoo data object
-     *
-     * @param string $key
-     * @param mixed $value
-     */
-    public function assign($key, $value) {
-        $this->dwoo_data->$key = $value;
-    }
-
-
-    /**
-     * Add Javascript files to template
-     *
-     * @param string $js
-     */
-    public function add_js($js) {
-        $current   = $this->dwoo_data->js_files;
-        $current[] = $js;
-        $this->dwoo_data->js_files = $current;
-    }
-
-
-    /**
-     * Add Css stylesheets to template
-     *
-     * @param string $css
-     */
-    public function add_css($css) {
-        $current   = $this->dwoo_data->css_files;
-        $current[] = $css;
-        $this->dwoo_data->css_files = $current;
-    }
-
-
-    /**
-     * Display or return the compiled template
-     * Since we assign the results to the standard CI output module
-     * you can also use the helper from CI in your templates!!
-     *
-     * @param string $sTemplate
-     * @param boolean $return
-     * @return mixed
-     */
-    public function display($sTemplate, $return = FALSE) {
-        // Start benchmark
-        $CI = get_instance();
-        $CI->benchmark->mark('dwoo_parse_start');
-
-        // Check if file exists
-        if ( !file_exists($this->template_dir . $sTemplate ) ) {
-            $message = sprintf('Template file \'%s\' not found.', $sTemplate);
-            show_error($message);
-            log_message('error', $message);
-        }
-
-        // Create new template
-        $tpl = new Dwoo_Template_File($this->template_dir . $sTemplate);
-
-        // render the template
-        $template = $this->get($tpl, $this->dwoo_data);
-
-        // Finish benchmark
-        $CI->benchmark->mark('dwoo_parse_end');
-
-        // Return results or not ?
-        if ($return == FALSE) {
-            $CI->output->final_output = $template;
-        } else {
-            return $template;
-        }
-    }
-
-
-    /**
-     * Toggle Codeigniter profiler on/off
-     *
-     */
-    public function enable_profiler($toggle = TRUE) {
-        $CI = get_instance();
-        $CI->output->enable_profiler($toggle);
-    }
-
-
-    /**
-     * Set http header
-     *
-     * @example $this->output->set_header("HTTP/1.1 200 OK");
-     * @example $this->output->set_header('Last-Modified: '.gmdate('D, d M Y H:i:s', $last_update).' GMT');
-     * @param string $header
-     */
-    public function set_header($header) {
-        $CI = get_instance();
-        $CI->output->set_header($header);
-    }
-
-
-    /**
-     * Set status header
-     *
-     * @example $this->output->set_status_header('401');
-     * @example // Sets the header as: Unauthorized
-     * @param string $header
-     */
-    public function set_status_header($header) {
-        $CI = get_instance();
-        $CI->output->set_status_header($header);
-    }
-
-
-    /**
-     * Assign the dwootemplate config items to the instance
-     *
-     */
-    private function initialize() {
-        $CI = get_instance();
-        $CI->config->load('dwootemplate', TRUE);
-        $config = $CI->config->item('dwootemplate');
-        foreach ($config as $key => $val) {
-                $this->$key = $val;
-        }
-    }
+	protected $dwoo_data = array();
+
+	/**
+	 * Constructor for the DwooTemplate engine
+	 *
+	 */
+	public function __construct() {
+		// Call parents constructor
+		parent::__construct();
+
+		// Set the config settings
+		$this->initialize();
+
+		// Assign some defaults to dwoo
+		$CI                         = get_instance();
+		$this->dwoo_data            = new Dwoo_Data();
+		$this->dwoo_data->js_files  = array();
+		$this->dwoo_data->css_files = array();
+		$this->dwoo_data->CI        = $CI;
+		$this->dwoo_data->site_url  = $CI->config->site_url(); // so we can get the full path to CI easily
+		$this->dwoo_data->uniqid    = uniqid();
+		$this->dwoo_data->timestamp = mktime();
+
+		log_message('debug', "Dwoo Template Class Initialized");
+	}
+
+
+	/**
+	 * Assign data to dwoo data object
+	 *
+	 * @param string $key
+	 * @param mixed $value
+	 */
+	public function assign($key, $value) {
+		$this->dwoo_data->$key = $value;
+	}
+
+
+	/**
+	 * Add Javascript files to template
+	 *
+	 * @param string $js
+	 */
+	public function add_js($js) {
+		$current   = $this->dwoo_data->js_files;
+		$current[] = $js;
+		$this->dwoo_data->js_files = $current;
+	}
+
+
+	/**
+	 * Add Css stylesheets to template
+	 *
+	 * @param string $css
+	 */
+	public function add_css($css) {
+		$current   = $this->dwoo_data->css_files;
+		$current[] = $css;
+		$this->dwoo_data->css_files = $current;
+	}
+
+
+	/**
+	 * Display or return the compiled template
+	 * Since we assign the results to the standard CI output module
+	 * you can also use the helper from CI in your templates!!
+	 *
+	 * @param string $sTemplate
+	 * @param boolean $return
+	 * @return mixed
+	 */
+	public function display($sTemplate, $return = FALSE) {
+		// Start benchmark
+		$CI = get_instance();
+		$CI->benchmark->mark('dwoo_parse_start');
+
+		// Check if file exists
+		if ( !file_exists($this->template_dir . $sTemplate ) ) {
+			$message = sprintf('Template file \'%s\' not found.', $sTemplate);
+			show_error($message);
+			log_message('error', $message);
+		}
+
+		// Create new template
+		$tpl = new Dwoo_Template_File($this->template_dir . $sTemplate);
+
+		// render the template
+		$template = $this->get($tpl, $this->dwoo_data);
+
+		// Finish benchmark
+		$CI->benchmark->mark('dwoo_parse_end');
+
+		// Return results or not ?
+		if ($return == FALSE) {
+			$CI->output->final_output = $template;
+		} else {
+			return $template;
+		}
+	}
+
+
+	/**
+	 * Toggle Codeigniter profiler on/off
+	 *
+	 */
+	public function enable_profiler($toggle = TRUE) {
+		$CI = get_instance();
+		$CI->output->enable_profiler($toggle);
+	}
+
+
+	/**
+	 * Set http header
+	 *
+	 * @example $this->output->set_header("HTTP/1.1 200 OK");
+	 * @example $this->output->set_header('Last-Modified: '.gmdate('D, d M Y H:i:s', $last_update).' GMT');
+	 * @param string $header
+	 */
+	public function set_header($header) {
+		$CI = get_instance();
+		$CI->output->set_header($header);
+	}
+
+
+	/**
+	 * Set status header
+	 *
+	 * @example $this->output->set_status_header('401');
+	 * @example // Sets the header as: Unauthorized
+	 * @param string $header
+	 */
+	public function set_status_header($header) {
+		$CI = get_instance();
+		$CI->output->set_status_header($header);
+	}
+
+
+	/**
+	 * Assign the dwootemplate config items to the instance
+	 *
+	 */
+	private function initialize() {
+		$CI = get_instance();
+		$CI->config->load('dwootemplate', TRUE);
+		$config = $CI->config->item('dwootemplate');
+		foreach ($config as $key => $val) {
+				$this->$key = $val;
+		}
+	}
 }
\ No newline at end of file

Braces +3 added lines, -1 removed lines

@@ -1,4 +1,6 @@
-<?php if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php if (!defined('BASEPATH')) {
+	exit('No direct script access allowed');
+}
 
 require "dwoo/dwooAutoload.php";
 

lib/Dwoo/Adapters/CodeIgniter/config/dwootemplate.php

Braces +3 added lines, -1 removed lines

@@ -1,4 +1,6 @@
-<?php  if (!defined('BASEPATH')) exit('No direct script access allowed');
+<?php  if (!defined('BASEPATH')) {
+	exit('No direct script access allowed');
+}
 
 // The name of the directory where templates are located.
 $config['template_dir'] = dirname(FCPATH) . '/../application/views/';

lib/Dwoo/Adapters/CodeIgniter/controllers/dwoowelcome.php

Indentation +10 added lines, -10 removed lines

@@ -2,15 +2,15 @@
 
 class Dwoowelcome extends Controller {
 
-    function __construct()
-    {
-        parent::Controller();
-    }
+	function __construct()
+	{
+		parent::Controller();
+	}
 
-    function index()
-    {
-    	$this->load->library('Dwootemplate');
-    	$this->dwootemplate->assign('itshowlate', date('H:i:s'));
-    	$this->dwootemplate->display('dwoowelcome.tpl');
-    }
+	function index()
+	{
+		$this->load->library('Dwootemplate');
+		$this->dwootemplate->assign('itshowlate', date('H:i:s'));
+		$this->dwootemplate->display('dwoowelcome.tpl');
+	}
 }
\ No newline at end of file

lib/Dwoo/Adapters/ZendFramework/View.php

Braces +4 added lines, -8 removed lines

@@ -248,8 +248,7 @@ 
 		//
 		elseif (is_subclass_of($engine, 'Dwoo') || 'Dwoo' === $engine) {
 			$this->_engine = new $engine();
-		}
-		else {
+		} else {
 			throw new Dwoo_Exception("Custom engine must be a subclass of Dwoo");
 		}
 	}
@@ -277,11 +276,9 @@ 
 	{
 		if ($data instanceof Dwoo_IDataProvider) {
 			$this->_dataProvider = $data;
-		}
-		elseif (is_subclass_of($data, 'Dwoo_Data') || 'Dwoo_Data' == $data) {
+		} elseif (is_subclass_of($data, 'Dwoo_Data') || 'Dwoo_Data' == $data) {
 			$this->_dataProvider = new $data();
-		}
-		else {
+		} else {
 			throw new Dwoo_Exception("Custom data provider must be a subclass of Dwoo_Data or instance of Dwoo_IDataProvider");
 		}
 	}
@@ -320,8 +317,7 @@ 
 		// if param given as a string
 		elseif (is_subclass_of($compiler, 'Dwoo_Compiler') || 'Dwoo_Compiler' == $compiler) {
 			$this->_compiler = new $compiler;
-		}
-		else {
+		} else {
 			throw new Dwoo_Exception("Custom compiler must be a subclass of Dwoo_Compiler or instance of Dwoo_ICompiler");
 		}
 	}

lib/Dwoo/Adapters/CakePHP/dwoo.php

Indentation +1 added lines, -1 removed lines

@@ -64,7 +64,7 @@
 		$this->_sv_compile_id = $controller->name;
 
 		$this->_dwoo->sv_this = $this;
-        $this->_dwoo->setSecurityPolicy();
+		$this->_dwoo->setSecurityPolicy();
 
 		return;
 	}