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

Documentation generated on Wed, 07 Sep 2011 13:47:30 +0200 by phpDocumentor 1.4.3