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.                 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.                     if( filemtime($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(!$compileok) break;
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