Source for file File.php

Documentation is available at File.php

  1. <?php
  2.  
  3. /**
  4.  * represents a Dwoo template contained in a file
  5.  *
  6.  * This software is provided 'as-is', without any express or implied warranty.
  7.  * In no event will the authors be held liable for any damages arising from the use of this software.
  8.  *
  9.  * This file is released under the LGPL
  10.  * "GNU Lesser General Public License"
  11.  * More information can be found here:
  12.  * {@link http://www.gnu.org/copyleft/lesser.html}
  13.  *
  14.  * @author     Jordi Boggiano <[email protected]>
  15.  * @copyright  Copyright (c) 2008, Jordi Boggiano
  16.  * @license    http://www.gnu.org/copyleft/lesser.html  GNU Lesser General Public License
  17.  * @link       http://dwoo.org/
  18.  * @version    0.9.1
  19.  * @date       2008-05-30
  20.  * @package    Dwoo
  21.  */
  22. class Dwoo_Template_File extends Dwoo_Template_String
  23. {
  24.     /**
  25.      * template filename
  26.      *
  27.      * @var string 
  28.      */
  29.     protected $file;
  30.  
  31.     /**
  32.      * include path(s) to look into to find this template
  33.      *
  34.      * @var array 
  35.      */
  36.     protected $includePath = null;
  37.  
  38.     /**
  39.      * resolved path cache when looking for a file in multiple include paths
  40.      *
  41.      * this is reset when the include path is changed
  42.      *
  43.      * @var string 
  44.      */
  45.     protected $resolvedPath = null;
  46.  
  47.     /**
  48.      * creates a template from a file
  49.      *
  50.      * @param string $file the path to the template file, make sure it exists
  51.      * @param int $cacheTime duration of the cache validity for this template,
  52.      *                           if null it defaults to the Dwoo instance that will
  53.      *                           render this template
  54.      * @param string $cacheId the unique cache identifier of this page or anything else that
  55.      *                            makes this template's content unique, if null it defaults
  56.      *                            to the current url
  57.      * @param string $compileId the unique compiled identifier, which is used to distinguish this
  58.      *                              template from others, if null it defaults to the filename+bits of the path
  59.      * @param mixed $includePath a string for a single path to look into for the given file, or an array of paths
  60.      */
  61.     public function __construct($file, $cacheTime = null, $cacheId = null, $compileId = null, $includePath = null)
  62.     {
  63.         $this->file = $file;
  64.         $this->name = basename($file);
  65.         $this->cacheTime = $cacheTime;
  66.  
  67.         if ($compileId !== null) {
  68.             $this->compileId = strtr($compileId, '\\%?=!:;'.PATH_SEPARATOR, '/-------');
  69.         }
  70.  
  71.         if ($cacheId !== null) {
  72.             $this->cacheId = strtr($cacheId, '\\%?=!:;'.PATH_SEPARATOR, '/-------');
  73.         }
  74.  
  75.         if (is_string($includePath)) {
  76.             $this->includePath = array($includePath);
  77.         } elseif (is_array($includePath)) {
  78.             $this->includePath = $includePath;
  79.         }
  80.     }
  81.  
  82.     /**
  83.      * sets the include path(s) to where the given template filename must be looked up
  84.      *
  85.      * @param mixed $paths the path to look into, can be string for a single path or an array of paths
  86.      */
  87.     public function setIncludePath($paths)
  88.     {
  89.         if (is_array($paths) === false) {
  90.             $paths = array($paths);
  91.         }
  92.  
  93.         $this->includePath = $paths;
  94.         $this->resolvedPath = null;
  95.     }
  96.  
  97.     /**
  98.      * return the current include path(s)
  99.      *
  100.      * @return array 
  101.      */
  102.     public function getIncludePath()
  103.     {
  104.         return $this->includePath;
  105.     }
  106.  
  107.     /**
  108.      * returns the compiled template file name
  109.      *
  110.      * @param Dwoo $dwoo the dwoo instance that requests it
  111.      * @param Dwoo_ICompiler $compiler the compiler that must be used
  112.      * @return string 
  113.      */
  114.     public function getCompiledTemplate(Dwoo $dwoo, Dwoo_ICompiler $compiler = null)
  115.     {
  116.         $compiledFile = $this->getCompiledFilename($dwoo);
  117.  
  118.         if ($this->compilationEnforced !== true && isset(self::$cache['compiled'][$this->compileId]) === true) {
  119.             // already checked, return compiled file
  120.         } elseif ($this->compilationEnforced !== true && file_exists($compiledFile)===true && (int)$this->getUid() <= filemtime($compiledFile)) {
  121.             // template is compiled and has not been modified since the compilation
  122.             self::$cache['compiled'][$this->compileId] = true;
  123.         } else {
  124.             // compiles the template
  125.             $this->compilationEnforced = false;
  126.  
  127.             if ($compiler === null) {
  128.                 $compiler = $dwoo->getDefaultCompilerFactory('string');
  129.  
  130.                 if ($compiler === null || $compiler === array('Dwoo_Compiler', 'compilerFactory')) {
  131.                     if (class_exists('Dwoo_Compiler', false) === false) {
  132.                         include 'Dwoo/Compiler.php';
  133.                     }
  134.                     $compiler = Dwoo_Compiler::compilerFactory();
  135.                 } else {
  136.                     $compiler = call_user_func($compiler);
  137.                 }
  138.             }
  139.  
  140.             $this->compiler = $compiler;
  141.  
  142.             $compiler->setCustomPlugins($dwoo->getCustomPlugins());
  143.             $compiler->setSecurityPolicy($dwoo->getSecurityPolicy());
  144.             $this->makeDirectory(dirname($compiledFile));
  145.             file_put_contents($compiledFile, $compiler->compile($dwoo, $this));
  146.             chmod($compiledFile, DWOO_CHMOD);
  147.  
  148.             self::$cache['compiled'][$this->compileId] = true;
  149.         }
  150.  
  151.         return $compiledFile;
  152.     }
  153.  
  154.     /**
  155.      * returns the template source of this template
  156.      *
  157.      * @return string 
  158.      */
  159.     public function getSource()
  160.     {
  161.         return file_get_contents($this->getResourceIdentifier());
  162.     }
  163.  
  164.     /**
  165.      * returns the resource name for this template class
  166.      *
  167.      * @return string 
  168.      */
  169.     public function getResourceName()
  170.     {
  171.         return 'file';
  172.     }
  173.  
  174.     /**
  175.      * returns this template's source filename
  176.      *
  177.      * @return string 
  178.      */
  179.     public function getResourceIdentifier()
  180.     {
  181.         if ($this->resolvedPath !== null) {
  182.             return $this->resolvedPath;
  183.         } elseif ($this->includePath === null) {
  184.             return $this->file;
  185.         } else {
  186.             foreach ($this->includePath as $path) {
  187.                 if (file_exists($path.DIRECTORY_SEPARATOR.$this->file) === true) {
  188.                     $this->resolvedPath = $path . DIRECTORY_SEPARATOR . $this->file;
  189.                     return $this->resolvedPath;
  190.                 }
  191.             }
  192.  
  193.             throw new Dwoo_Exception('Template "'.$this->file.'" could not be found in any of your include path(s)');
  194.         }
  195.     }
  196.  
  197.     /**
  198.      * returns an unique value identifying the current version of this template,
  199.      * in this case it's the unix timestamp of the last modification
  200.      *
  201.      * @return string 
  202.      */
  203.     public function getUid()
  204.     {
  205.         return (string) filemtime($this->getResourceIdentifier());
  206.     }
  207.  
  208.     /**
  209.      * returns a new template object from the given include name, null if no include is
  210.      * possible (resource not found), or false if include is not permitted by this resource type
  211.      *
  212.      * @param Dwoo $dwoo the dwoo instance requiring it
  213.      * @param mixed $resourceId the filename (relative to this template's dir) of the template to include
  214.      * @param int $cacheTime duration of the cache validity for this template,
  215.      *                           if null it defaults to the Dwoo instance that will
  216.      *                           render this template
  217.      * @param string $cacheId the unique cache identifier of this page or anything else that
  218.      *                            makes this template's content unique, if null it defaults
  219.      *                            to the current url
  220.      * @param string $compileId the unique compiled identifier, which is used to distinguish this
  221.      *                              template from others, if null it defaults to the filename+bits of the path
  222.      * @return Dwoo_Template_File|null
  223.      */
  224.     public static function templateFactory(Dwoo $dwoo, $resourceId, $cacheTime = null, $cacheId = null, $compileId = null)
  225.     {
  226.         $resourceId = str_replace(array("\t", "\n", "\r"), array('\\t', '\\n', '\\r'), $resourceId);
  227.         if (file_exists($resourceId) === false) {
  228.             $tpl = $dwoo->getTemplate();
  229.             if ($tpl instanceof Dwoo_Template_File) {
  230.                 $resourceId = dirname($tpl->getResourceIdentifier()).DIRECTORY_SEPARATOR.$resourceId;
  231.                 if (file_exists($resourceId) === false) {
  232.                     return null;
  233.                 }
  234.             } else {
  235.                 return null;
  236.             }
  237.         }
  238.  
  239.         // prevent template recursion if security is in effect
  240.         if ($policy = $dwoo->getSecurityPolicy()) {
  241.             $tpl = $dwoo->getTemplate();
  242.             if ($tpl instanceof Dwoo_Template_File && $resourceId === $tpl->getResourceIdentifier()) {
  243.                 return $dwoo->triggerError('You can not include a template into itself', E_USER_WARNING);
  244.             }
  245.         }
  246.  
  247.         return new Dwoo_Template_File($resourceId, $cacheTime, $cacheId, $compileId);
  248.     }
  249.  
  250.     /**
  251.      * returns the full compiled file name and assigns a default value to it if
  252.      * required
  253.      *
  254.      * @param Dwoo $dwoo the dwoo instance that requests the file name
  255.      * @return string the full path to the compiled file
  256.      */
  257.     protected function getCompiledFilename(Dwoo $dwoo)
  258.     {
  259.         // no compile id was provided, set default
  260.         if ($this->compileId===null) {
  261.             $this->compileId = strtr($this->getResourceIdentifier(), '\\:', '/-');
  262.         }
  263.         return $dwoo->getCompileDir() . $this->compileId.'.d'.Dwoo::RELEASE_TAG.'.php';
  264.     }
  265. }

Documentation generated on Sun, 03 Aug 2008 15:12:35 +0200 by phpDocumentor 1.4.0