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 <j.boggiano@seld.be>
  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 = str_replace('../', '__', strtr($compileId, '\\%?=!:;'.PATH_SEPARATOR, '/-------'));
  69.         }
  70.  
  71.         if ($cacheId !== null) {
  72.             $this->cacheId = str_replace('../', '__', 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_DIRECTORY . '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.             if ($this->chmod !== null) {
  147.                 chmod($compiledFile, $this->chmod);
  148.             }
  149.  
  150.             self::$cache['compiled'][$this->compileId] = true;
  151.         }
  152.  
  153.         return $compiledFile;
  154.     }
  155.  
  156.     /**
  157.      * returns the template source of this template
  158.      *
  159.      * @return string 
  160.      */
  161.     public function getSource()
  162.     {
  163.         return file_get_contents($this->getResourceIdentifier());
  164.     }
  165.  
  166.     /**
  167.      * returns the resource name for this template class
  168.      *
  169.      * @return string 
  170.      */
  171.     public function getResourceName()
  172.     {
  173.         return 'file';
  174.     }
  175.  
  176.     /**
  177.      * returns this template's source filename
  178.      *
  179.      * @return string 
  180.      */
  181.     public function getResourceIdentifier()
  182.     {
  183.         if ($this->resolvedPath !== null) {
  184.             return $this->resolvedPath;
  185.         } elseif ($this->includePath === null) {
  186.             return $this->file;
  187.         } else {
  188.             foreach ($this->includePath as $path) {
  189.                 if (file_exists($path.DIRECTORY_SEPARATOR.$this->file) === true) {
  190.                     $this->resolvedPath = $path . DIRECTORY_SEPARATOR . $this->file;
  191.                     return $this->resolvedPath;
  192.                 }
  193.             }
  194.  
  195.             throw new Dwoo_Exception('Template "'.$this->file.'" could not be found in any of your include path(s)');
  196.         }
  197.     }
  198.  
  199.     /**
  200.      * returns an unique value identifying the current version of this template,
  201.      * in this case it's the unix timestamp of the last modification
  202.      *
  203.      * @return string 
  204.      */
  205.     public function getUid()
  206.     {
  207.         return (string) filemtime($this->getResourceIdentifier());
  208.     }
  209.  
  210.     /**
  211.      * returns a new template object from the given include name, null if no include is
  212.      * possible (resource not found), or false if include is not permitted by this resource type
  213.      *
  214.      * @param Dwoo $dwoo the dwoo instance requiring it
  215.      * @param mixed $resourceId the filename (relative to this template's dir) of the template to include
  216.      * @param int $cacheTime duration of the cache validity for this template,
  217.      *                           if null it defaults to the Dwoo instance that will
  218.      *                           render this template
  219.      * @param string $cacheId the unique cache identifier of this page or anything else that
  220.      *                            makes this template's content unique, if null it defaults
  221.      *                            to the current url
  222.      * @param string $compileId the unique compiled identifier, which is used to distinguish this
  223.      *                              template from others, if null it defaults to the filename+bits of the path
  224.      * @param Dwoo_ITemplate $parentTemplate the template that is requesting a new template object (through
  225.      *                                              an include, extends or any other plugin)
  226.      * @return Dwoo_Template_File|null
  227.      */
  228.     public static function templateFactory(Dwoo $dwoo, $resourceId, $cacheTime = null, $cacheId = null, $compileId = null, Dwoo_ITemplate $parentTemplate = null)
  229.     {
  230.         if (DIRECTORY_SEPARATOR === '\\') {
  231.             $resourceId = str_replace(array("\t", "\n", "\r", "\f", "\v"), array('\\t', '\\n', '\\r', '\\f', '\\v'), $resourceId);
  232.         }
  233.         $resourceId = strtr($resourceId, '\\', '/');
  234.  
  235.         $includePath = null;
  236.  
  237.         if (file_exists($resourceId) === false) {
  238.             if ($parentTemplate === null) {
  239.                 $parentTemplate = $dwoo->getTemplate();
  240.             }
  241.             if ($parentTemplate instanceof Dwoo_Template_File) {
  242.                 if ($includePath = $parentTemplate->getIncludePath()) {
  243.                     if (strstr($resourceId, '../')) {
  244.                         throw new Dwoo_Exception('When using an include path you can not reference a template into a parent directory (using ../)');
  245.                     }
  246.                 } else {
  247.                     $resourceId = dirname($parentTemplate->getResourceIdentifier()).DIRECTORY_SEPARATOR.$resourceId;
  248.                     if (file_exists($resourceId) === false) {
  249.                         return null;
  250.                     }
  251.                 }
  252.             } else {
  253.                 return null;
  254.             }
  255.         }
  256.  
  257.         if ($policy = $dwoo->getSecurityPolicy()) {
  258.             while (true) {
  259.                 if (preg_match('{^([a-z]+?)://}i', $resourceId)) {
  260.                     throw new Dwoo_Security_Exception('The security policy prevents you to read files from external sources : <em>'.$resourceId.'</em>.');
  261.                 }
  262.  
  263.                 if ($includePath) {
  264.                     break;
  265.                 }
  266.  
  267.                 $resourceId = realpath($resourceId);
  268.                 $dirs = $policy->getAllowedDirectories();
  269.                 foreach ($dirs as $dir=>$dummy) {
  270.                     if (strpos($resourceId, $dir) === 0) {
  271.                         break 2;
  272.                     }
  273.                 }
  274.                 throw new Dwoo_Security_Exception('The security policy prevents you to read <em>'.$resourceId.'</em>');
  275.             }
  276.         }
  277.  
  278.         return new Dwoo_Template_File($resourceId, $cacheTime, $cacheId, $compileId, $includePath);
  279.     }
  280.  
  281.     /**
  282.      * returns the full compiled file name and assigns a default value to it if
  283.      * required
  284.      *
  285.      * @param Dwoo $dwoo the dwoo instance that requests the file name
  286.      * @return string the full path to the compiled file
  287.      */
  288.     protected function getCompiledFilename(Dwoo $dwoo)
  289.     {
  290.         // no compile id was provided, set default
  291.         if ($this->compileId===null) {
  292.             $this->compileId = str_replace('../', '__', strtr($this->getResourceIdentifier(), '\\:', '/-'));
  293.         }
  294.         return $dwoo->getCompileDir() . $this->compileId.'.d'.Dwoo::RELEASE_TAG.'.php';
  295.     }
  296. }

Documentation generated on Sun, 07 Sep 2008 23:57:47 +0200 by phpDocumentor 1.4.0