Source for file jIncluder.class.php

Documentation is available at jIncluder.class.php

  1. <?php
  2. /**
  3.  * @package    jelix
  4.  * @subpackage core
  5.  * @author     Laurent Jouanneau
  6.  * @copyright  2005-2006 Laurent Jouanneau
  7.  *    Idea of this class was picked from the Copix project (CopixInclude, Copix 2.3dev20050901, http://www.copix.org)
  8.  * @link       http://www.jelix.org
  9.  * @licence    GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  10.  */
  11.  
  12. /**
  13.  * interface for compiler which needs only one source file
  14.  * @package  jelix
  15.  * @subpackage core
  16.  */
  17. interface jISimpleCompiler {
  18.     /**
  19.      * parse the given file, and store the result in a cache file
  20.      * @param jSelector $aSelector the file selector
  21.      * @return boolean true : process ok
  22.      */
  23.     public function compile($aSelector);
  24. }
  25.  
  26. /**
  27.  * interface for compiler which needs many source files
  28.  * @package  jelix
  29.  * @subpackage core
  30.  */
  31. interface jIMultiFileCompiler {
  32.  
  33.     /**
  34.      * parse one of needed file
  35.      * @param string $sourceFile the file selector
  36.      * @param string $module    the module name of the file
  37.      * @return boolean true : process ok
  38.      */
  39.     public function compileItem($sourceFile$module);
  40.  
  41.     /**
  42.      * save the results in a temporary file
  43.      * called at the end of the compilation.
  44.      * @param string $cachefile the name of cache file
  45.      */
  46.     public function endCompile($cachefile);
  47. }
  48. /**
  49.  * This object is responsible to load cache files.
  50.  * Some jelix files needs to be compiled in PHP (templates, daos etc..) and their
  51.  * correspondant php content are stored in a cache file.
  52.  * jIncluder verify that cache file exists, is not obsolete, and if not,
  53.  * it calls the correspondant compiler.
  54.  * And then include the cache.
  55.  * @package  jelix
  56.  * @subpackage core
  57.  * @author     Laurent Jouanneau
  58.  * @copyright  2001-2005 CopixTeam, 2005-2006 Laurent Jouanneau
  59.  * @licence    GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html .
  60.  *  few line of code are copyrighted Copyright 2001-2005 CopixTeam (LGPL licence)
  61.  *  and piked from CopixInclude class of Copix 2.3dev20050901 framework.
  62.  *  initial author : Laurent Jouanneau
  63.  */
  64. class jIncluder {
  65.     /**
  66.      * list of loaded cache file.
  67.      * It avoids to do all verification when a file is include many time
  68.      * @var array 
  69.      */
  70.     protected static $_includedFiles array();
  71.  
  72.     /**
  73.      * This is a static class, so private constructor
  74.      */
  75.     private function __construct(){}
  76.  
  77.     /**
  78.      * includes cache of the correspondant file selector
  79.      * check the cache, compile if needed, and include the cache
  80.      * @param    jISelector   $aSelectorId    the selector corresponding to the file
  81.     */
  82.     public static function inc($aSelector){
  83.        global $gJConfig,$gJCoord;
  84.  
  85.         $cachefile $aSelector->getCompiledFilePath();
  86.  
  87.         if($cachefile == '' || isset(jIncluder::$_includedFiles[$cachefile])){
  88.             return;
  89.         }
  90.  
  91.         $mustCompile $gJConfig->compilation['force'|| !file_exists($cachefile);
  92.  
  93.         if(!$mustCompile && $gJConfig->compilation['checkCacheFiletime']){
  94.             $sourcefile $aSelector->getPath();
  95.             if($sourcefile == '' || !file_exists($sourcefile)){
  96.                 throw new jException('jelix~errors.includer.source.missing',array$aSelector->toString(true)));
  97.             }
  98.             iffilemtime($sourcefilefilemtime($cachefile)){
  99.                 $mustCompile true;
  100.             }
  101.         }
  102.  
  103.         if($mustCompile){
  104.             $compiler $aSelector->getCompiler();
  105.             if($compiler && $compiler->compile($aSelector)){
  106.                 require($cachefile);
  107.                 jIncluder::$_includedFiles[$cachefile]=true;
  108.             }
  109.             else {
  110.                 throw new jException('jelix~errors.includer.source.compile',array$aSelector->toString(true)));
  111.             }
  112.         }else{
  113.             require($cachefile);
  114.             jIncluder::$_includedFiles[$cachefile]=true;
  115.         }
  116.     }
  117.  
  118.     /**
  119.      * include a cache file which is the results of the compilation of multiple file sotred in multiple modules
  120.     * @param    array    $aType 
  121.     *     = array(
  122.     *     'compilator class name',
  123.     *     'relative path of the compilator class file to lib/jelix/',
  124.     *     'foo.xml', // file name to compile (in each modules)
  125.     *     'foo.php',  //cache filename
  126.     *     );
  127.     */
  128.     public static function incAll($aType){
  129.  
  130.         global $gJConfig,$gJCoord;
  131.         $cachefile jApp::tempPath('compiled/'.$aType[3]);
  132.         if(isset(jIncluder::$_includedFiles[$cachefile])){
  133.             return;
  134.         }
  135.  
  136.         $mustCompile $gJConfig->compilation['force'|| !file_exists($cachefile);
  137.  
  138.         if(!$mustCompile && $gJConfig->compilation['checkCacheFiletime']){
  139.             $compiledate filemtime($cachefile);
  140.             foreach($gJConfig->_modulesPathList as $module=>$path){
  141.                 $sourcefile $path.$aType[2];
  142.                 if (is_readable ($sourcefile)){
  143.                     iffilemtime($sourcefile$compiledate){
  144.                         $mustCompile true;
  145.                         break;
  146.                     }
  147.                 }
  148.             }
  149.         }
  150.  
  151.         if($mustCompile){
  152.             require_once(JELIX_LIB_PATH.$aType[1]);
  153.             $compiler new $aType[0];
  154.             $compileok true;
  155.             foreach($gJConfig->_modulesPathList as $module=>$path){
  156.                 $compileok $compiler->compileItem($path.$aType[2]$module);
  157.                 if(!$compileokbreak;
  158.             }
  159.  
  160.             if($compileok){
  161.                 $compiler->endCompile($cachefile);
  162.                 require($cachefile);
  163.                 jIncluder::$_includedFiles[$cachefile]=true;
  164.             }
  165.         }else{
  166.             require($cachefile);
  167.             jIncluder::$_includedFiles[$cachefile]=true;
  168.         }
  169.     }
  170. }

Documentation generated on Mon, 19 Sep 2011 14:12:59 +0200 by phpDocumentor 1.4.3