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-2012 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.  
84.         $cachefile = $aSelector->getCompiledFilePath();
85.  
86.         if($cachefile == '' || isset(jIncluder::$_includedFiles[$cachefile])){
87.             return;
88.         }
89.  
90.         $mustCompile = jApp::config()->compilation['force'] || !file_exists($cachefile);
91.  
92.         if(!$mustCompile && jApp::config()->compilation['checkCacheFiletime']){
93.             $sourcefile = $aSelector->getPath();
94.             if($sourcefile == '' || !file_exists($sourcefile)){
95.                 throw new jException('jelix~errors.includer.source.missing',array( $aSelector->toString(true)));
96.             }
97.             if( filemtime($sourcefile) > filemtime($cachefile))
98.                 $mustCompile = true;
99.         }
100.  
101.         if($mustCompile){
102.             $compiler = $aSelector->getCompiler();
103.             if($compiler && $compiler->compile($aSelector)){
104.                 require($cachefile);
105.                 jIncluder::$_includedFiles[$cachefile]=true;
106.             }
107.             else {
108.                 throw new jException('jelix~errors.includer.source.compile',array( $aSelector->toString(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.         $cachefile = jApp::tempPath('compiled/'.$aType[3]);
129.         if(isset(jIncluder::$_includedFiles[$cachefile])){
130.             return;
131.         }
132.  
133.         $config = jApp::config();
134.         $mustCompile = $config->compilation['force'] || !file_exists($cachefile);
135.  
136.         if(!$mustCompile && $config->compilation['checkCacheFiletime']){
137.             $compiledate = filemtime($cachefile);
138.             foreach($config->_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($config->_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 Mon, 26 Oct 2015 21:54:27 +0100 by phpDocumentor 1.4.3