Source for file jApp.class.php

Documentation is available at jApp.class.php

  1. <?php
  2. /**
  3. * @package    jelix
  4. * @subpackage core
  5. * @author     Laurent Jouanneau
  6. * @copyright  2011-2012 Laurent Jouanneau
  7. * @link       http://jelix.org
  8. * @licence    http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
  9. */
  10.  
  11. /**
  12. *
  13. * @package    jelix
  14. * @subpackage core
  15. */
  16. class jApp {
  17.  
  18.     protected static $tempBasePath = '';
  19.  
  20.     protected static $appPath = '';
  21.  
  22.     protected static $varPath = '';
  23.  
  24.     protected static $logPath = '';
  25.  
  26.     protected static $configPath = '';
  27.  
  28.     protected static $wwwPath = '';
  29.  
  30.     protected static $scriptPath = '';
  31.  
  32.     protected static $_isInit = false;
  33.  
  34.     protected static $env = 'www/';
  35.  
  36.     protected static $configAutoloader = null;
  37.  
  38.     /**
  39.      * initialize the application paths
  40.      *
  41.      * Warning: given paths should be ended by a directory separator.
  42.      * @param string $appPath  application directory
  43.      * @param string $wwwPath  www directory
  44.      * @param string $varPath  var directory
  45.      * @param string $logPath log directory
  46.      * @param string $configPath config directory
  47.      * @param string $scriptPath scripts directory
  48.      */
  49.     public static function initPaths ($appPath,
  50.                                  $wwwPath = null,
  51.                                  $varPath = null,
  52.                                  $logPath = null,
  53.                                  $configPath = null,
  54.                                  $scriptPath = null
  55.                                  ) {
  56.         self::$appPath = $appPath;
  57.         self::$wwwPath = (is_null($wwwPath)?$appPath.'www/':$wwwPath);
  58.         self::$varPath = (is_null($varPath)?$appPath.'var/':$varPath);
  59.         self::$logPath = (is_null($logPath)?self::$varPath.'log/':$logPath);
  60.         self::$configPath = (is_null($configPath)?self::$varPath.'config/':$configPath);
  61.         self::$scriptPath = (is_null($scriptPath)?$appPath.'scripts/':$scriptPath);
  62.         self::$_isInit = true;
  63.     }
  64.  
  65.     /**
  66.      * indicate if path have been set
  67.      * @return boolean  true if it is ok
  68.      */
  69.     public static function isInit() { return self::$_isInit; }
  70.  
  71.     /**
  72.      * init path from JELIX_APP_* defines or define JELIX_APP_*,
  73.      * depending of how the bootstrap has been initialized.
  74.      * The goal of this method is to support the transition
  75.      * between the old way of defining path, and the new way
  76.      * in jelix 1.3.
  77.      * @deprecated
  78.      */
  79.     public static function initLegacy() {
  80.         if (self::$_isInit) {
  81.             if (!defined('JELIX_APP_PATH')) {
  82.                 define ('JELIX_APP_PATH',         self::$appPath);
  83.                 define ('JELIX_APP_TEMP_PATH',    self::tempPath());
  84.                 define ('JELIX_APP_VAR_PATH',     self::$varPath);
  85.                 define ('JELIX_APP_LOG_PATH',     self::$logPath);
  86.                 define ('JELIX_APP_CONFIG_PATH',  self::$configPath);
  87.                 define ('JELIX_APP_WWW_PATH',     self::$wwwPath);
  88.                 define ('JELIX_APP_CMD_PATH',     self::$scriptPath);
  89.             }
  90.         }
  91.         else if (defined('JELIX_APP_PATH')) {
  92.             self::initPaths(JELIX_APP_PATH,
  93.                             JELIX_APP_WWW_PATH,
  94.                             JELIX_APP_VAR_PATH,
  95.                             JELIX_APP_LOG_PATH,
  96.                             JELIX_APP_CONFIG_PATH,
  97.                             JELIX_APP_CMD_PATH);
  98.             self::setTempBasePath(JELIX_APP_TEMP_PATH);
  99.         }
  100.  
  101.         global $gJConfig;
  102.         if (!$gJConfig)
  103.             $gJConfig = self::$_config;
  104.         global $gJCoord;
  105.         if (!$gJCoord)
  106.             $gJCoord = self::$_coord;
  107.     }
  108.  
  109.     public static function appPath($file='') { return self::$appPath.$file; }
  110.     public static function varPath($file='') { return self::$varPath.$file; }
  111.     public static function logPath($file='') { return self::$logPath.$file; }
  112.     public static function configPath($file='') { return self::$configPath.$file; }
  113.     public static function wwwPath($file='') { return self::$wwwPath.$file; }
  114.     public static function scriptsPath($file='') { return self::$scriptPath.$file; }
  115.     public static function tempPath($file='') { return self::$tempBasePath.self::$env.$file; }
  116.     public static function tempBasePath() { return self::$tempBasePath; }
  117.  
  118.     public static function setTempBasePath($path) {
  119.         self::$tempBasePath = $path;
  120.     }
  121.  
  122.     public static function setEnv($env) {
  123.         if (substr($env,-1) != '/')
  124.             $env.='/';
  125.         self::$env = $env;
  126.     }
  127.  
  128.     /**
  129.      * @var object  object containing all configuration options of the application
  130.      */
  131.     protected static $_config = null;
  132.  
  133.     /**
  134.      * @return object object containing all configuration options of the application
  135.      */
  136.     public static function config() {
  137.         return self::$_config;
  138.     }
  139.  
  140.     public static function setConfig($config) {
  141.         if (self::$configAutoloader) {
  142.             spl_autoload_unregister(array(self::$configAutoloader, 'loadClass'));
  143.             self::$configAutoloader = null;
  144.         }
  145.  
  146.         self::$_config = $config;
  147.         if ($config) {
  148.             date_default_timezone_set(self::$_config->timeZone);
  149.             self::$configAutoloader = new jConfigAutoloader($config);
  150.             spl_autoload_register(array(self::$configAutoloader, 'loadClass'));
  151.             foreach(self::$_config->_autoload_autoloader as $autoloader)
  152.                 require_once($autoloader);
  153.         }
  154.     }
  155.  
  156.     /**
  157.      * Load the configuration from the given file.
  158.      *
  159.      * Call it after initPaths
  160.      * @param  string|object $configFile name of the ini file to configure the framework or a configuration object
  161.      * @param  boolean $enableErrorHandler enable the error handler of jelix.
  162.      *                  keep it to true, unless you have something to debug
  163.      *                  and really have to use the default handler or an other handler
  164.      */
  165.     public static function loadConfig ($configFile, $enableErrorHandler=true) {
  166.         if ($enableErrorHandler) {
  167.             jBasicErrorHandler::register();
  168.         }
  169.         if (is_object($configFile))
  170.             self::setConfig($configFile);
  171.         else
  172.             self::setConfig(jConfig::load($configFile));
  173.         self::$_config->enableErrorHandler = $enableErrorHandler;
  174.     }
  175.  
  176.     protected static $_coord = null;
  177.     
  178.     public static function coord() {
  179.         return self::$_coord;
  180.     }
  181.  
  182.     public static function setCoord($coord) {
  183.         self::$_coord = $coord;
  184.     }
  185.  
  186.     protected static $contextBackup = array();
  187.  
  188.     /**
  189.      * save all path and others variables relatives to the application, so you can
  190.      * temporary change the context to an other application
  191.      */
  192.     public static function saveContext() {
  193.         if (self::$_config)
  194.             $conf = clone self::$_config;
  195.         else
  196.             $conf = null;
  197.         if (self::$_coord)
  198.             $coord = clone self::$_coord;
  199.         else
  200.             $coord = null;
  201.         self::$contextBackup[] = array(self::$appPath, self::$varPath, self::$logPath, self::$configPath,
  202.                                        self::$wwwPath, self::$scriptPath, self::$tempBasePath, self::$env, $conf, $coord);
  203.     }
  204.  
  205.     /**
  206.      * restore the previous context of the application
  207.      */
  208.     public static function restoreContext() {
  209.         if (!count(self::$contextBackup))
  210.             return;
  211.         list(self::$appPath, self::$varPath, self::$logPath, self::$configPath,
  212.              self::$wwwPath, self::$scriptPath, self::$tempBasePath, self::$env,
  213.              $conf, self::$_coord) = array_pop(self::$contextBackup);
  214.         self::setConfig($conf);
  215.     }
  216.  
  217.     /**
  218.      * load a plugin from a plugin directory (any type of plugins)
  219.      * @param string $name the name of the plugin
  220.      * @param string $type the type of the plugin
  221.      * @param string $suffix the suffix of the filename
  222.      * @param string $classname the name of the class to instancy
  223.      * @param mixed $args  the argument for the constructor of the class. null = no argument.
  224.      * @return null|object   null if the plugin doesn't exists
  225.      */
  226.     public static function loadPlugin($name, $type, $suffix, $classname, $args = null) {
  227.  
  228.         if (!class_exists($classname,false)) {
  229.             $optname = '_pluginsPathList_'.$type;
  230.             if (!isset(jApp::config()->$optname))
  231.                 return null;
  232.             $opt = & jApp::config()->$optname;
  233.             if (!isset($opt[$name])
  234.                 || !file_exists($opt[$name].$name.$suffix) ){
  235.                 return null;
  236.             }
  237.             require_once($opt[$name].$name.$suffix);
  238.         }
  239.         if (!is_null($args))
  240.             return new $classname($args);
  241.         else
  242.             return new $classname();
  243.     }
  244.  
  245.     /**
  246.     * Says if the given module $name is enabled
  247.     * @param string $moduleName 
  248.     * @param boolean $includingExternal  true if we want to know if the module
  249.     *                is also an external module, e.g. in an other entry point
  250.     * @return boolean true : module is ok
  251.     */
  252.     public static function isModuleEnabled ($moduleName, $includingExternal = false) {
  253.         if (!self::$_config)
  254.             throw new Exception ('Configuration is not loaded');
  255.         if ($includingExternal && isset(self::$_config->_externalModulesPathList[$moduleName])) {
  256.             return true;
  257.         }
  258.         return isset(self::$_config->_modulesPathList[$moduleName]);
  259.     }
  260.  
  261.     /**
  262.      * return the real path of a module
  263.      * @param string $module a module name
  264.      * @param boolean $includingExternal  true if we want to know if the module
  265.      *                is also an external module, e.g. in an other entry point
  266.      * @return string the corresponding path
  267.      */
  268.     public static function getModulePath($module, $includingExternal = false){
  269.         if (!self::$_config)
  270.             throw new Exception ('Configuration is not loaded');
  271.  
  272.         if (!isset(self::$_config->_modulesPathList[$module])) {
  273.             if ($includingExternal && isset(self::$_config->_externalModulesPathList[$module])) {
  274.                 return self::$_config->_externalModulesPathList[$module];
  275.             }
  276.             throw new Exception('getModulePath : invalid module name');
  277.         }
  278.         return self::$_config->_modulesPathList[$module];
  279.     }
  280. }

Documentation generated on Mon, 26 Oct 2015 21:51:34 +0100 by phpDocumentor 1.4.3