library/Zend/Application.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Application
  17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  18  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  19  * @version    $Id$
  20  */
  21
  22 /**
  23  * @category   Zend
  24  * @package    Zend_Application
  25  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
  26  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  27  */
  28 class Zend_Application
  29 {
  30     /**
  31      * Autoloader to use
  32      *
  33      * @var Zend_Loader_Autoloader
  34      */
  35     protected $_autoloader;
  36
  37     /**
  38      * Bootstrap
  39      *
  40      * @var Zend_Application_Bootstrap_BootstrapAbstract
  41      */
  42     protected $_bootstrap;
  43
  44     /**
  45      * Application environment
  46      *
  47      * @var string
  48      */
  49     protected $_environment;
  50
  51     /**
  52      * Flattened (lowercase) option keys
  53      *
  54      * @var array
  55      */
  56     protected $_optionKeys = array();
  57
  58     /**
  59      * Options for Zend_Application
  60      *
  61      * @var array
  62      */
  63     protected $_options = array();
  64
  65     /**
  66      * Constructor
  67      *
  68      * Initialize application. Potentially initializes include_paths, PHP
  69      * settings, and bootstrap class.
  70      *
  71      * @param  string                   $environment
  72      * @param  string|array|Zend_Config $options String path to configuration file, or array/Zend_Config of configuration options
  73      * @throws Zend_Application_Exception When invalid options are provided
  74      * @return void
  75      */
  76     public function __construct($environment, $options = null)
  77     {
  78         $this->_environment = (string) $environment;
  79
  80         require_once 'Zend/Loader/Autoloader.php';
  81         $this->_autoloader = Zend_Loader_Autoloader::getInstance();
  82
  83         if (null !== $options) {
  84             if (is_string($options)) {
  85                 $options = $this->_loadConfig($options);
  86             } elseif ($options instanceof Zend_Config) {
  87                 $options = $options->toArray();
  88             } elseif (!is_array($options)) {
  89                 throw new Zend_Application_Exception('Invalid options provided; must be location of config file, a config object, or an array');
  90             }
  91
  92             $this->setOptions($options);
  93         }
  94     }
  95
  96     /**
  97      * Retrieve current environment
  98      *
  99      * @return string
 100      */
 101     public function getEnvironment()
 102     {
 103         return $this->_environment;
 104     }
 105
 106     /**
 107      * Retrieve autoloader instance
 108      *
 109      * @return Zend_Loader_Autoloader
 110      */
 111     public function getAutoloader()
 112     {
 113         return $this->_autoloader;
 114     }
 115
 116     /**
 117      * Set application options
 118      *
 119      * @param  array $options
 120      * @throws Zend_Application_Exception When no bootstrap path is provided
 121      * @throws Zend_Application_Exception When invalid bootstrap information are provided
 122      * @return Zend_Application
 123      */
 124     public function setOptions(array $options)
 125     {
 126         if (!empty($options['config'])) {
 127             if (is_array($options['config'])) {
 128                 $_options = array();
 129                 foreach ($options['config'] as $tmp) {
 130                     $_options = $this->mergeOptions($_options, $this->_loadConfig($tmp));
 131                 }
 132                 $options = $this->mergeOptions($_options, $options);
 133             } else {
 134                 $options = $this->mergeOptions($this->_loadConfig($options['config']), $options);
 135             }
 136         }
 137
 138         $this->_options = $options;
 139
 140         $options = array_change_key_case($options, CASE_LOWER);
 141
 142         $this->_optionKeys = array_keys($options);
 143
 144         if (!empty($options['phpsettings'])) {
 145             $this->setPhpSettings($options['phpsettings']);
 146         }
 147
 148         if (!empty($options['includepaths'])) {
 149             $this->setIncludePaths($options['includepaths']);
 150         }
 151
 152         if (!empty($options['autoloadernamespaces'])) {
 153             $this->setAutoloaderNamespaces($options['autoloadernamespaces']);
 154         }
 155
 156         if (!empty($options['autoloaderzfpath'])) {
 157             $autoloader = $this->getAutoloader();
 158             if (method_exists($autoloader, 'setZfPath')) {
 159                 $zfPath    = $options['autoloaderzfpath'];
 160                 $zfVersion = !empty($options['autoloaderzfversion'])
 161                            ? $options['autoloaderzfversion']
 162                            : 'latest';
 163                 $autoloader->setZfPath($zfPath, $zfVersion);
 164             }
 165         }
 166
 167         if (!empty($options['bootstrap'])) {
 168             $bootstrap = $options['bootstrap'];
 169
 170             if (is_string($bootstrap)) {
 171                 $this->setBootstrap($bootstrap);
 172             } elseif (is_array($bootstrap)) {
 173                 if (empty($bootstrap['path'])) {
 174                     throw new Zend_Application_Exception('No bootstrap path provided');
 175                 }
 176
 177                 $path  = $bootstrap['path'];
 178                 $class = null;
 179
 180                 if (!empty($bootstrap['class'])) {
 181                     $class = $bootstrap['class'];
 182                 }
 183
 184                 $this->setBootstrap($path, $class);
 185             } else {
 186                 throw new Zend_Application_Exception('Invalid bootstrap information provided');
 187             }
 188         }
 189
 190         return $this;
 191     }
 192
 193     /**
 194      * Retrieve application options (for caching)
 195      *
 196      * @return array
 197      */
 198     public function getOptions()
 199     {
 200         return $this->_options;
 201     }
 202
 203     /**
 204      * Is an option present?
 205      *
 206      * @param  string $key
 207      * @return bool
 208      */
 209     public function hasOption($key)
 210     {
 211         return in_array(strtolower($key), $this->_optionKeys);
 212     }
 213
 214     /**
 215      * Retrieve a single option
 216      *
 217      * @param  string $key
 218      * @return mixed
 219      */
 220     public function getOption($key)
 221     {
 222         if ($this->hasOption($key)) {
 223             $options = $this->getOptions();
 224             $options = array_change_key_case($options, CASE_LOWER);
 225             return $options[strtolower($key)];
 226         }
 227         return null;
 228     }
 229
 230     /**
 231      * Merge options recursively
 232      *
 233      * @param  array $array1
 234      * @param  mixed $array2
 235      * @return array
 236      */
 237     public function mergeOptions(array $array1, $array2 = null)
 238     {
 239         if (is_array($array2)) {
 240             foreach ($array2 as $key => $val) {
 241                 if (is_array($array2[$key])) {
 242                     $array1[$key] = (array_key_exists($key, $array1) && is_array($array1[$key]))
 243                                   ? $this->mergeOptions($array1[$key], $array2[$key])
 244                                   : $array2[$key];
 245                 } else {
 246                     $array1[$key] = $val;
 247                 }
 248             }
 249         }
 250         return $array1;
 251     }
 252
 253     /**
 254      * Set PHP configuration settings
 255      *
 256      * @param  array $settings
 257      * @param  string $prefix Key prefix to prepend to array values (used to map . separated INI values)
 258      * @return Zend_Application
 259      */
 260     public function setPhpSettings(array $settings, $prefix = '')
 261     {
 262         foreach ($settings as $key => $value) {
 263             $key = empty($prefix) ? $key : $prefix . $key;
 264             if (is_scalar($value)) {
 265                 ini_set($key, $value);
 266             } elseif (is_array($value)) {
 267                 $this->setPhpSettings($value, $key . '.');
 268             }
 269         }
 270
 271         return $this;
 272     }
 273
 274     /**
 275      * Set include path
 276      *
 277      * @param  array $paths
 278      * @return Zend_Application
 279      */
 280     public function setIncludePaths(array $paths)
 281     {
 282         $path = implode(PATH_SEPARATOR, $paths);
 283         set_include_path($path . PATH_SEPARATOR . get_include_path());
 284         return $this;
 285     }
 286
 287     /**
 288      * Set autoloader namespaces
 289      *
 290      * @param  array $namespaces
 291      * @return Zend_Application
 292      */
 293     public function setAutoloaderNamespaces(array $namespaces)
 294     {
 295         $autoloader = $this->getAutoloader();
 296
 297         foreach ($namespaces as $namespace) {
 298             $autoloader->registerNamespace($namespace);
 299         }
 300
 301         return $this;
 302     }
 303
 304     /**
 305      * Set bootstrap path/class
 306      *
 307      * @param  string $path
 308      * @param  string $class
 309      * @return Zend_Application
 310      */
 311     public function setBootstrap($path, $class = null)
 312     {
 313         // setOptions() can potentially send a null value; specify default
 314         // here
 315         if (null === $class) {
 316             $class = 'Bootstrap';
 317         }
 318
 319         if (!class_exists($class, false)) {
 320             require_once $path;
 321             if (!class_exists($class, false)) {
 322                 throw new Zend_Application_Exception('Bootstrap class not found');
 323             }
 324         }
 325         $this->_bootstrap = new $class($this);
 326
 327         if (!$this->_bootstrap instanceof Zend_Application_Bootstrap_Bootstrapper) {
 328             throw new Zend_Application_Exception('Bootstrap class does not implement Zend_Application_Bootstrap_Bootstrapper');
 329         }
 330
 331         return $this;
 332     }
 333
 334     /**
 335      * Get bootstrap object
 336      *
 337      * @return Zend_Application_Bootstrap_BootstrapAbstract
 338      */
 339     public function getBootstrap()
 340     {
 341         if (null === $this->_bootstrap) {
 342             $this->_bootstrap = new Zend_Application_Bootstrap_Bootstrap($this);
 343         }
 344         return $this->_bootstrap;
 345     }
 346
 347     /**
 348      * Bootstrap application
 349      *
 350      * @param  null|string|array $resource
 351      * @return Zend_Application
 352      */
 353     public function bootstrap($resource = null)
 354     {
 355         $this->getBootstrap()->bootstrap($resource);
 356         return $this;
 357     }
 358
 359     /**
 360      * Run the application
 361      *
 362      * @return void
 363      */
 364     public function run()
 365     {
 366         $this->getBootstrap()->run();
 367     }
 368
 369     /**
 370      * Load configuration file of options
 371      *
 372      * @param  string $file
 373      * @throws Zend_Application_Exception When invalid configuration file is provided
 374      * @return array
 375      */
 376     protected function _loadConfig($file)
 377     {
 378         $environment = $this->getEnvironment();
 379         $suffix      = strtolower(pathinfo($file, PATHINFO_EXTENSION));
 380
 381         switch ($suffix) {
 382             case 'ini':
 383                 $config = new Zend_Config_Ini($file, $environment);
 384                 break;
 385
 386             case 'xml':
 387                 $config = new Zend_Config_Xml($file, $environment);
 388                 break;
 389
 390             case 'php':
 391             case 'inc':
 392                 $config = include $file;
 393                 if (!is_array($config)) {
 394                     throw new Zend_Application_Exception('Invalid configuration file provided; PHP file does not return array value');
 395                 }
 396                 return $config;
 397                 break;
 398
 399             default:
 400                 throw new Zend_Application_Exception('Invalid configuration file provided; unknown config type');
 401         }
 402
 403         return $config->toArray();
 404     }
 405 }