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.         $cachefile = $aSelector->getCompiledFilePath();
87.  
88.         if($cachefile == '' || isset(jIncluder::$_includedFiles[$cachefile])){
89.             return;
90.         }
91.  
92.         $mustCompile = $gJConfig->compilation['force'] || !file_exists($cachefile);
93.  
94.         if(!$mustCompile && $gJConfig->compilation['checkCacheFiletime']){
95.             $sourcefile = $aSelector->getPath();
96.             if($sourcefile == '' || !file_exists($sourcefile)){
97.                 throw new jException('jelix~errors.includer.source.missing',array( $aSelector->toString(true)));
98.             }
99.             if( filemtime($sourcefile) > filemtime($cachefile)){
100.                 $mustCompile = true;
101.             }
102.         }
103.  
104.         if($mustCompile){
105.             $compiler = $aSelector->getCompiler();
106.             if($compiler && $compiler->compile($aSelector)){
107.                 require($cachefile);
108.                 jIncluder::$_includedFiles[$cachefile]=true;
109.             }
110.         }else{
111.             require($cachefile);
112.             jIncluder::$_includedFiles[$cachefile]=true;
113.         }
114.     }
115.  
116.     /**
117.      * include a cache file which is the results of the compilation of multiple file sotred in multiple modules
118.     * @param    array    aType
119.     *     = array(
120.     *     'compilator class name',
121.     *     'relative path of the compilator class file to lib/jelix/',
122.     *     'foo.xml', // file name to compile (in each modules)
123.     *     'foo.php',  //cache filename
124.     *     );
125.     */
126.     public static function incAll($aType){
127.  
128.         global $gJConfig,$gJCoord;
129.         $cachefile = JELIX_APP_TEMP_PATH.'compiled/'.$aType[3];
130.         if(isset(jIncluder::$_includedFiles[$cachefile])){
131.             return;
132.         }
133.  
134.         $mustCompile = $gJConfig->compilation['force'] || !file_exists($cachefile);
135.  
136.         if(!$mustCompile && $gJConfig->compilation['checkCacheFiletime']){
137.             $compiledate = filemtime($cachefile);
138.             foreach($gJConfig->_modulesPathList as $module=>$path){
139.                 $sourcefile = $path.$aType[2];
140.                 if (is_readable ($sourcefile)){
141.                     if( filemtime($sourcefile) > $compiledate){
142.                         $mustCompile = true;
143.                         break;
144.                     }
145.                 }
146.             }
147.         }
148.  
149.         if($mustCompile){
150.             require_once(JELIX_LIB_PATH.$aType[1]);
151.             $compiler = new $aType[0];
152.             $compileok = true;
153.             foreach($gJConfig->_modulesPathList as $module=>$path){
154.                 $compileok = $compiler->compileItem($path.$aType[2], $module);
155.                 if(!$compileok) break;
156.             }
157.  
158.             if($compileok){
159.                 $compiler->endCompile($cachefile);
160.                 require($cachefile);
161.                 jIncluder::$_includedFiles[$cachefile]=true;
162.             }
163.         }else{
164.             require($cachefile);
165.             jIncluder::$_includedFiles[$cachefile]=true;
166.         }
167.     }
168. }

Documentation generated on Thu, 22 Mar 2012 22:16:13 +0100 by phpDocumentor 1.4.3