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

Documentation generated on Thu, 19 Sep 2013 00:05:28 +0200 by phpDocumentor 1.4.3