Fatal Error Invalid controller specified (blog)
EXCEPTION_NO_CONTROLLER : 0
{main}
open/var/www/contextly-site/library/Zend/Controller/Dispatcher/Standard.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_Controller
17    * @subpackage Dispatcher
18    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
19    * @license    http://framework.zend.com/license/new-bsd     New BSD License
20    * @version    $Id: Standard.php 24594 2012-01-05 21:27:01Z matthew $
21    */
22   
23   /** Zend_Loader */
24   
require_once 'Zend/Loader.php';
25   
26   
/** Zend_Controller_Dispatcher_Abstract */
27   
require_once 'Zend/Controller/Dispatcher/Abstract.php';
28   
29   
/**
30    * @category   Zend
31    * @package    Zend_Controller
32    * @subpackage Dispatcher
33    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
34    * @license    http://framework.zend.com/license/new-bsd     New BSD License
35    */
36   
class Zend_Controller_Dispatcher_Standard extends Zend_Controller_Dispatcher_Abstract
37   
{
38       
/**
39        * Current dispatchable directory
40        * @var string
41        */
42       
protected $_curDirectory;
43   
44       
/**
45        * Current module (formatted)
46        * @var string
47        */
48       
protected $_curModule;
49   
50       
/**
51        * Controller directory(ies)
52        * @var array
53        */
54       
protected $_controllerDirectory = array();
55   
56       
/**
57        * Constructor: Set current module to default value
58        *
59        * @param  array $params
60        * @return void
61        */
62       
public function __construct(array $params = array())
63       {
64           
parent::__construct($params);
65           
$this->_curModule $this->getDefaultModule();
66       }
67   
68       
/**
69        * Add a single path to the controller directory stack
70        *
71        * @param string $path
72        * @param string $module
73        * @return Zend_Controller_Dispatcher_Standard
74        */
75       
public function addControllerDirectory($path$module null)
76       {
77           if (
null === $module) {
78               
$module $this->_defaultModule;
79           }
80   
81           
$module = (string) $module;
82           
$path   rtrim((string) $path'/\\');
83   
84           
$this->_controllerDirectory[$module] = $path;
85           return 
$this;
86       }
87   
88       
/**
89        * Set controller directory
90        *
91        * @param array|string $directory
92        * @return Zend_Controller_Dispatcher_Standard
93        */
94       
public function setControllerDirectory($directory$module null)
95       {
96           
$this->_controllerDirectory = array();
97   
98           if (
is_string($directory)) {
99               
$this->addControllerDirectory($directory$module);
100          } elseif (
is_array($directory)) {
101              foreach ((array) 
$directory as $module => $path) {
102                  
$this->addControllerDirectory($path$module);
103              }
104          } else {
105              require_once 
'Zend/Controller/Exception.php';
106              throw new 
Zend_Controller_Exception('Controller directory spec must be either a string or an array');
107          }
108  
109          return 
$this;
110      }
111  
112      
/**
113       * Return the currently set directories for Zend_Controller_Action class
114       * lookup
115       *
116       * If a module is specified, returns just that directory.
117       *
118       * @param  string $module Module name
119       * @return array|string Returns array of all directories by default, single
120       * module directory if module argument provided
121       */
122      
public function getControllerDirectory($module null)
123      {
124          if (
null === $module) {
125              return 
$this->_controllerDirectory;
126          }
127  
128          
$module = (string) $module;
129          if (
array_key_exists($module$this->_controllerDirectory)) {
130              return 
$this->_controllerDirectory[$module];
131          }
132  
133          return 
null;
134      }
135  
136      
/**
137       * Remove a controller directory by module name
138       *
139       * @param  string $module
140       * @return bool
141       */
142      
public function removeControllerDirectory($module)
143      {
144          
$module = (string) $module;
145          if (
array_key_exists($module$this->_controllerDirectory)) {
146              unset(
$this->_controllerDirectory[$module]);
147              return 
true;
148          }
149          return 
false;
150      }
151  
152      
/**
153       * Format the module name.
154       *
155       * @param string $unformatted
156       * @return string
157       */
158      
public function formatModuleName($unformatted)
159      {
160          if ((
$this->_defaultModule == $unformatted) && !$this->getParam('prefixDefaultModule')) {
161              return 
$unformatted;
162          }
163  
164          return 
ucfirst($this->_formatName($unformatted));
165      }
166  
167      
/**
168       * Format action class name
169       *
170       * @param string $moduleName Name of the current module
171       * @param string $className Name of the action class
172       * @return string Formatted class name
173       */
174      
public function formatClassName($moduleName$className)
175      {
176          return 
$this->formatModuleName($moduleName) . '_' $className;
177      }
178  
179      
/**
180       * Convert a class name to a filename
181       *
182       * @param string $class
183       * @return string
184       */
185      
public function classToFilename($class)
186      {
187          return 
str_replace('_'DIRECTORY_SEPARATOR$class) . '.php';
188      }
189  
190      
/**
191       * Returns TRUE if the Zend_Controller_Request_Abstract object can be
192       * dispatched to a controller.
193       *
194       * Use this method wisely. By default, the dispatcher will fall back to the
195       * default controller (either in the module specified or the global default)
196       * if a given controller does not exist. This method returning false does
197       * not necessarily indicate the dispatcher will not still dispatch the call.
198       *
199       * @param Zend_Controller_Request_Abstract $action
200       * @return boolean
201       */
202      
public function isDispatchable(Zend_Controller_Request_Abstract $request)
203      {
204          
$className $this->getControllerClass($request);
205          if (!
$className) {
206              return 
false;
207          }
208  
209          
$finalClass  $className;
210          if ((
$this->_defaultModule != $this->_curModule)
211              || 
$this->getParam('prefixDefaultModule'))
212          {
213              
$finalClass $this->formatClassName($this->_curModule$className);
214          }
215          if (
class_exists($finalClassfalse)) {
216              return 
true;
217          }
218  
219          
$fileSpec    $this->classToFilename($className);
220          
$dispatchDir $this->getDispatchDirectory();
221          
$test        $dispatchDir DIRECTORY_SEPARATOR $fileSpec;
222          return 
Zend_Loader::isReadable($test);
223      }
224  
225      
/**
226       * Dispatch to a controller/action
227       *
228       * By default, if a controller is not dispatchable, dispatch() will throw
229       * an exception. If you wish to use the default controller instead, set the
230       * param 'useDefaultControllerAlways' via {@link setParam()}.
231       *
232       * @param Zend_Controller_Request_Abstract $request
233       * @param Zend_Controller_Response_Abstract $response
234       * @return void
235       * @throws Zend_Controller_Dispatcher_Exception
236       */
237      
public function dispatch(Zend_Controller_Request_Abstract $requestZend_Controller_Response_Abstract $response)
238      {
239          
$this->setResponse($response);
240  
241          
/**
242           * Get controller class
243           */
244          
if (!$this->isDispatchable($request)) {
245              
$controller $request->getControllerName();
246              if (!
$this->getParam('useDefaultControllerAlways') && !empty($controller)) {
247                  require_once 
'Zend/Controller/Dispatcher/Exception.php';
248                  throw new 
Zend_Controller_Dispatcher_Exception('Invalid controller specified (' $request->getControllerName() . ')');
249              }
250  
251              
$className $this->getDefaultControllerClass($request);
252          } else {
253              
$className $this->getControllerClass($request);
254              if (!
$className) {
255                  
$className $this->getDefaultControllerClass($request);
256              }
257          }
258  
259          
/**
260           * Load the controller class file
261           */
262          
$className $this->loadClass($className);
263  
264          
/**
265           * Instantiate controller with request, response, and invocation
266           * arguments; throw exception if it's not an action controller
267           */
268          
$controller = new $className($request$this->getResponse(), $this->getParams());
269          if (!(
$controller instanceof Zend_Controller_Action_Interface) &&
270              !(
$controller instanceof Zend_Controller_Action)) {
271              require_once 
'Zend/Controller/Dispatcher/Exception.php';
272              throw new 
Zend_Controller_Dispatcher_Exception(
273                  
'Controller "' $className '" is not an instance of Zend_Controller_Action_Interface'
274              
);
275          }
276  
277          
/**
278           * Retrieve the action name
279           */
280          
$action $this->getActionMethod($request);
281  
282          
/**
283           * Dispatch the method call
284           */
285          
$request->setDispatched(true);
286  
287          
// by default, buffer output
288          
$disableOb $this->getParam('disableOutputBuffering');
289          
$obLevel   ob_get_level();
290          if (empty(
$disableOb)) {
291              
ob_start();
292          }
293  
294          try {
295              
$controller->dispatch($action);
296          } catch (
Exception $e) {
297              
// Clean output buffer on error
298              
$curObLevel ob_get_level();
299              if (
$curObLevel $obLevel) {
300                  do {
301                      
ob_get_clean();
302                      
$curObLevel ob_get_level();
303                  } while (
$curObLevel $obLevel);
304              }
305              throw 
$e;
306          }
307  
308          if (empty(
$disableOb)) {
309              
$content ob_get_clean();
310              
$response->appendBody($content);
311          }
312  
313          
// Destroy the page controller instance and reflection objects
314          
$controller null;
315      }
316  
317      
/**
318       * Load a controller class
319       *
320       * Attempts to load the controller class file from
321       * {@link getControllerDirectory()}.  If the controller belongs to a
322       * module, looks for the module prefix to the controller class.
323       *
324       * @param string $className
325       * @return string Class name loaded
326       * @throws Zend_Controller_Dispatcher_Exception if class not loaded
327       */
328      
public function loadClass($className)
329      {
330          
$finalClass  $className;
331          if ((
$this->_defaultModule != $this->_curModule)
332              || 
$this->getParam('prefixDefaultModule'))
333          {
334              
$finalClass $this->formatClassName($this->_curModule$className);
335          }
336          if (
class_exists($finalClassfalse)) {
337              return 
$finalClass;
338          }
339  
340          
$dispatchDir $this->getDispatchDirectory();
341          
$loadFile    $dispatchDir DIRECTORY_SEPARATOR $this->classToFilename($className);
342  
343          if (
Zend_Loader::isReadable($loadFile)) {
344              include_once 
$loadFile;
345          } else {
346              require_once 
'Zend/Controller/Dispatcher/Exception.php';
347              throw new 
Zend_Controller_Dispatcher_Exception('Cannot load controller class "' $className '" from file "' $loadFile "'");
348          }
349  
350          if (!
class_exists($finalClassfalse)) {
351              require_once 
'Zend/Controller/Dispatcher/Exception.php';
352              throw new 
Zend_Controller_Dispatcher_Exception('Invalid controller class ("' $finalClass '")');
353          }
354  
355          return 
$finalClass;
356      }
357  
358      
/**
359       * Get controller class name
360       *
361       * Try request first; if not found, try pulling from request parameter;
362       * if still not found, fallback to default
363       *
364       * @param Zend_Controller_Request_Abstract $request
365       * @return string|false Returns class name on success
366       */
367      
public function getControllerClass(Zend_Controller_Request_Abstract $request)
368      {
369          
$controllerName $request->getControllerName();
370          if (empty(
$controllerName)) {
371              if (!
$this->getParam('useDefaultControllerAlways')) {
372                  return 
false;
373              }
374              
$controllerName $this->getDefaultControllerName();
375              
$request->setControllerName($controllerName);
376          }
377  
378          
$className $this->formatControllerName($controllerName);
379  
380          
$controllerDirs      $this->getControllerDirectory();
381          
$module $request->getModuleName();
382          if (
$this->isValidModule($module)) {
383              
$this->_curModule    $module;
384              
$this->_curDirectory $controllerDirs[$module];
385          } elseif (
$this->isValidModule($this->_defaultModule)) {
386              
$request->setModuleName($this->_defaultModule);
387              
$this->_curModule    $this->_defaultModule;
388              
$this->_curDirectory $controllerDirs[$this->_defaultModule];
389          } else {
390              require_once 
'Zend/Controller/Exception.php';
391              throw new 
Zend_Controller_Exception('No default module defined for this application');
392          }
393  
394          return 
$className;
395      }
396  
397      
/**
398       * Determine if a given module is valid
399       *
400       * @param  string $module
401       * @return bool
402       */
403      
public function isValidModule($module)
404      {
405          if (!
is_string($module)) {
406              return 
false;
407          }
408  
409          
$module        strtolower($module);
410          
$controllerDir $this->getControllerDirectory();
411          foreach (
array_keys($controllerDir) as $moduleName) {
412              if (
$module == strtolower($moduleName)) {
413                  return 
true;
414              }
415          }
416  
417          return 
false;
418      }
419  
420      
/**
421       * Retrieve default controller class
422       *
423       * Determines whether the default controller to use lies within the
424       * requested module, or if the global default should be used.
425       *
426       * By default, will only use the module default unless that controller does
427       * not exist; if this is the case, it falls back to the default controller
428       * in the default module.
429       *
430       * @param Zend_Controller_Request_Abstract $request
431       * @return string
432       */
433      
public function getDefaultControllerClass(Zend_Controller_Request_Abstract $request)
434      {
435          
$controller $this->getDefaultControllerName();
436          
$default    $this->formatControllerName($controller);
437          
$request->setControllerName($controller)
438                  ->
setActionName(null);
439  
440          
$module              $request->getModuleName();
441          
$controllerDirs      $this->getControllerDirectory();
442          
$this->_curModule    $this->_defaultModule;
443          
$this->_curDirectory $controllerDirs[$this->_defaultModule];
444          if (
$this->isValidModule($module)) {
445              
$found false;
446              if (
class_exists($defaultfalse)) {
447                  
$found true;
448              } else {
449                  
$moduleDir $controllerDirs[$module];
450                  
$fileSpec  $moduleDir DIRECTORY_SEPARATOR $this->classToFilename($default);
451                  if (
Zend_Loader::isReadable($fileSpec)) {
452                      
$found true;
453                      
$this->_curDirectory $moduleDir;
454                  }
455              }
456              if (
$found) {
457                  
$request->setModuleName($module);
458                  
$this->_curModule    $this->formatModuleName($module);
459              }
460          } else {
461              
$request->setModuleName($this->_defaultModule);
462          }
463  
464          return 
$default;
465      }
466  
467      
/**
468       * Return the value of the currently selected dispatch directory (as set by
469       * {@link getController()})
470       *
471       * @return string
472       */
473      
public function getDispatchDirectory()
474      {
475          return 
$this->_curDirectory;
476      }
477  
478      
/**
479       * Determine the action name
480       *
481       * First attempt to retrieve from request; then from request params
482       * using action key; default to default action
483       *
484       * Returns formatted action name
485       *
486       * @param Zend_Controller_Request_Abstract $request
487       * @return string
488       */
489      
public function getActionMethod(Zend_Controller_Request_Abstract $request)
490      {
491          
$action $request->getActionName();
492          if (empty(
$action)) {
493              
$action $this->getDefaultAction();
494              
$request->setActionName($action);
495          }
496  
497          return 
$this->formatActionName($action);
498      }
499  }
500  
Stack trace
  1. open/var/www/contextly-site/library/Zend/Controller/Front.php
    Zend_Controller_Dispatcher_Standard->dispatch(Zend_Controller_Request_Http, Zend_Controller_Response_Http)
    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_Controller
    17    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
    18    * @license    http://framework.zend.com/license/new-bsd     New BSD License
    19    * @version    $Id: Front.php 24594 2012-01-05 21:27:01Z matthew $
    20    */
    21   
    22   
    23   /** Zend_Loader */
    24   
    require_once 'Zend/Loader.php';
    25   
    26   
    /** Zend_Controller_Action_HelperBroker */
    27   
    require_once 'Zend/Controller/Action/HelperBroker.php';
    28   
    29   
    /** Zend_Controller_Plugin_Broker */
    30   
    require_once 'Zend/Controller/Plugin/Broker.php';
    31   
    32   
    /**
    33    * @category   Zend
    34    * @package    Zend_Controller
    35    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
    36    * @license    http://framework.zend.com/license/new-bsd     New BSD License
    37    */
    38   
    class Zend_Controller_Front
    39   
    {
    40       
    /**
    41        * Base URL
    42        * @var string
    43        */
    44       
    protected $_baseUrl null;
    45   
    46       
    /**
    47        * Directory|ies where controllers are stored
    48        *
    49        * @var string|array
    50        */
    51       
    protected $_controllerDir null;
    52   
    53       
    /**
    54        * Instance of Zend_Controller_Dispatcher_Interface
    55        * @var Zend_Controller_Dispatcher_Interface
    56        */
    57       
    protected $_dispatcher null;
    58   
    59       
    /**
    60        * Singleton instance
    61        *
    62        * Marked only as protected to allow extension of the class. To extend,
    63        * simply override {@link getInstance()}.
    64        *
    65        * @var Zend_Controller_Front
    66        */
    67       
    protected static $_instance null;
    68   
    69       
    /**
    70        * Array of invocation parameters to use when instantiating action
    71        * controllers
    72        * @var array
    73        */
    74       
    protected $_invokeParams = array();
    75   
    76       
    /**
    77        * Subdirectory within a module containing controllers; defaults to 'controllers'
    78        * @var string
    79        */
    80       
    protected $_moduleControllerDirectoryName 'controllers';
    81   
    82       
    /**
    83        * Instance of Zend_Controller_Plugin_Broker
    84        * @var Zend_Controller_Plugin_Broker
    85        */
    86       
    protected $_plugins null;
    87   
    88       
    /**
    89        * Instance of Zend_Controller_Request_Abstract
    90        * @var Zend_Controller_Request_Abstract
    91        */
    92       
    protected $_request null;
    93   
    94       
    /**
    95        * Instance of Zend_Controller_Response_Abstract
    96        * @var Zend_Controller_Response_Abstract
    97        */
    98       
    protected $_response null;
    99   
    100      
    /**
    101       * Whether or not to return the response prior to rendering output while in
    102       * {@link dispatch()}; default is to send headers and render output.
    103       * @var boolean
    104       */
    105      
    protected $_returnResponse false;
    106  
    107      
    /**
    108       * Instance of Zend_Controller_Router_Interface
    109       * @var Zend_Controller_Router_Interface
    110       */
    111      
    protected $_router null;
    112  
    113      
    /**
    114       * Whether or not exceptions encountered in {@link dispatch()} should be
    115       * thrown or trapped in the response object
    116       * @var boolean
    117       */
    118      
    protected $_throwExceptions false;
    119  
    120      
    /**
    121       * Constructor
    122       *
    123       * Instantiate using {@link getInstance()}; front controller is a singleton
    124       * object.
    125       *
    126       * Instantiates the plugin broker.
    127       *
    128       * @return void
    129       */
    130      
    protected function __construct()
    131      {
    132          
    $this->_plugins = new Zend_Controller_Plugin_Broker();
    133      }
    134  
    135      
    /**
    136       * Enforce singleton; disallow cloning
    137       *
    138       * @return void
    139       */
    140      
    private function __clone()
    141      {
    142      }
    143  
    144      
    /**
    145       * Singleton instance
    146       *
    147       * @return Zend_Controller_Front
    148       */
    149      
    public static function getInstance()
    150      {
    151          if (
    null === self::$_instance) {
    152              
    self::$_instance = new self();
    153          }
    154  
    155          return 
    self::$_instance;
    156      }
    157  
    158      
    /**
    159       * Resets all object properties of the singleton instance
    160       *
    161       * Primarily used for testing; could be used to chain front controllers.
    162       *
    163       * Also resets action helper broker, clearing all registered helpers.
    164       *
    165       * @return void
    166       */
    167      
    public function resetInstance()
    168      {
    169          
    $reflection = new ReflectionObject($this);
    170          foreach (
    $reflection->getProperties() as $property) {
    171              
    $name $property->getName();
    172              switch (
    $name) {
    173                  case 
    '_instance':
    174                      break;
    175                  case 
    '_controllerDir':
    176                  case 
    '_invokeParams':
    177                      
    $this->{$name} = array();
    178                      break;
    179                  case 
    '_plugins':
    180                      
    $this->{$name} = new Zend_Controller_Plugin_Broker();
    181                      break;
    182                  case 
    '_throwExceptions':
    183                  case 
    '_returnResponse':
    184                      
    $this->{$name} = false;
    185                      break;
    186                  case 
    '_moduleControllerDirectoryName':
    187                      
    $this->{$name} = 'controllers';
    188                      break;
    189                  default:
    190                      
    $this->{$name} = null;
    191                      break;
    192              }
    193          }
    194          
    Zend_Controller_Action_HelperBroker::resetHelpers();
    195      }
    196  
    197      
    /**
    198       * Convenience feature, calls setControllerDirectory()->setRouter()->dispatch()
    199       *
    200       * In PHP 5.1.x, a call to a static method never populates $this -- so run()
    201       * may actually be called after setting up your front controller.
    202       *
    203       * @param string|array $controllerDirectory Path to Zend_Controller_Action
    204       * controller classes or array of such paths
    205       * @return void
    206       * @throws Zend_Controller_Exception if called from an object instance
    207       */
    208      
    public static function run($controllerDirectory)
    209      {
    210          
    self::getInstance()
    211              ->
    setControllerDirectory($controllerDirectory)
    212              ->
    dispatch();
    213      }
    214  
    215      
    /**
    216       * Add a controller directory to the controller directory stack
    217       *
    218       * If $args is presented and is a string, uses it for the array key mapping
    219       * to the directory specified.
    220       *
    221       * @param string $directory
    222       * @param string $module Optional argument; module with which to associate directory. If none provided, assumes 'default'
    223       * @return Zend_Controller_Front
    224       * @throws Zend_Controller_Exception if directory not found or readable
    225       */
    226      
    public function addControllerDirectory($directory$module null)
    227      {
    228          
    $this->getDispatcher()->addControllerDirectory($directory$module);
    229          return 
    $this;
    230      }
    231  
    232      
    /**
    233       * Set controller directory
    234       *
    235       * Stores controller directory(ies) in dispatcher. May be an array of
    236       * directories or a string containing a single directory.
    237       *
    238       * @param string|array $directory Path to Zend_Controller_Action controller
    239       * classes or array of such paths
    240       * @param  string $module Optional module name to use with string $directory
    241       * @return Zend_Controller_Front
    242       */
    243      
    public function setControllerDirectory($directory$module null)
    244      {
    245          
    $this->getDispatcher()->setControllerDirectory($directory$module);
    246          return 
    $this;
    247      }
    248  
    249      
    /**
    250       * Retrieve controller directory
    251       *
    252       * Retrieves:
    253       * - Array of all controller directories if no $name passed
    254       * - String path if $name passed and exists as a key in controller directory array
    255       * - null if $name passed but does not exist in controller directory keys
    256       *
    257       * @param  string $name Default null
    258       * @return array|string|null
    259       */
    260      
    public function getControllerDirectory($name null)
    261      {
    262          return 
    $this->getDispatcher()->getControllerDirectory($name);
    263      }
    264  
    265      
    /**
    266       * Remove a controller directory by module name
    267       *
    268       * @param  string $module
    269       * @return bool
    270       */
    271      
    public function removeControllerDirectory($module)
    272      {
    273          return 
    $this->getDispatcher()->removeControllerDirectory($module);
    274      }
    275  
    276      
    /**
    277       * Specify a directory as containing modules
    278       *
    279       * Iterates through the directory, adding any subdirectories as modules;
    280       * the subdirectory within each module named after {@link $_moduleControllerDirectoryName}
    281       * will be used as the controller directory path.
    282       *
    283       * @param  string $path
    284       * @return Zend_Controller_Front
    285       */
    286      
    public function addModuleDirectory($path)
    287      {
    288          try{
    289              
    $dir = new DirectoryIterator($path);
    290          } catch(
    Exception $e) {
    291              require_once 
    'Zend/Controller/Exception.php';
    292              throw new 
    Zend_Controller_Exception("Directory $path not readable"0$e);
    293          }
    294          foreach (
    $dir as $file) {
    295              if (
    $file->isDot() || !$file->isDir()) {
    296                  continue;
    297              }
    298  
    299              
    $module    $file->getFilename();
    300  
    301              
    // Don't use SCCS directories as modules
    302              
    if (preg_match('/^[^a-z]/i'$module) || ('CVS' == $module)) {
    303                  continue;
    304              }
    305  
    306              
    $moduleDir $file->getPathname() . DIRECTORY_SEPARATOR $this->getModuleControllerDirectoryName();
    307              
    $this->addControllerDirectory($moduleDir$module);
    308          }
    309  
    310          return 
    $this;
    311      }
    312  
    313      
    /**
    314       * Return the path to a module directory (but not the controllers directory within)
    315       *
    316       * @param  string $module
    317       * @return string|null
    318       */
    319      
    public function getModuleDirectory($module null)
    320      {
    321          if (
    null === $module) {
    322              
    $request $this->getRequest();
    323              if (
    null !== $request) {
    324                  
    $module $this->getRequest()->getModuleName();
    325              }
    326              if (empty(
    $module)) {
    327                  
    $module $this->getDispatcher()->getDefaultModule();
    328              }
    329          }
    330  
    331          
    $controllerDir $this->getControllerDirectory($module);
    332  
    333          if ((
    null === $controllerDir) || !is_string($controllerDir)) {
    334              return 
    null;
    335          }
    336  
    337          return 
    dirname($controllerDir);
    338      }
    339  
    340      
    /**
    341       * Set the directory name within a module containing controllers
    342       *
    343       * @param  string $name
    344       * @return Zend_Controller_Front
    345       */
    346      
    public function setModuleControllerDirectoryName($name 'controllers')
    347      {
    348          
    $this->_moduleControllerDirectoryName = (string) $name;
    349  
    350          return 
    $this;
    351      }
    352  
    353      
    /**
    354       * Return the directory name within a module containing controllers
    355       *
    356       * @return string
    357       */
    358      
    public function getModuleControllerDirectoryName()
    359      {
    360          return 
    $this->_moduleControllerDirectoryName;
    361      }
    362  
    363      
    /**
    364       * Set the default controller (unformatted string)
    365       *
    366       * @param string $controller
    367       * @return Zend_Controller_Front
    368       */
    369      
    public function setDefaultControllerName($controller)
    370      {
    371          
    $dispatcher $this->getDispatcher();
    372          
    $dispatcher->setDefaultControllerName($controller);
    373          return 
    $this;
    374      }
    375  
    376      
    /**
    377       * Retrieve the default controller (unformatted string)
    378       *
    379       * @return string
    380       */
    381      
    public function getDefaultControllerName()
    382      {
    383          return 
    $this->getDispatcher()->getDefaultControllerName();
    384      }
    385  
    386      
    /**
    387       * Set the default action (unformatted string)
    388       *
    389       * @param string $action
    390       * @return Zend_Controller_Front
    391       */
    392      
    public function setDefaultAction($action)
    393      {
    394          
    $dispatcher $this->getDispatcher();
    395          
    $dispatcher->setDefaultAction($action);
    396          return 
    $this;
    397      }
    398  
    399      
    /**
    400       * Retrieve the default action (unformatted string)
    401       *
    402       * @return string
    403       */
    404      
    public function getDefaultAction()
    405      {
    406          return 
    $this->getDispatcher()->getDefaultAction();
    407      }
    408  
    409      
    /**
    410       * Set the default module name
    411       *
    412       * @param string $module
    413       * @return Zend_Controller_Front
    414       */
    415      
    public function setDefaultModule($module)
    416      {
    417          
    $dispatcher $this->getDispatcher();
    418          
    $dispatcher->setDefaultModule($module);
    419          return 
    $this;
    420      }
    421  
    422      
    /**
    423       * Retrieve the default module
    424       *
    425       * @return string
    426       */
    427      
    public function getDefaultModule()
    428      {
    429          return 
    $this->getDispatcher()->getDefaultModule();
    430      }
    431  
    432      
    /**
    433       * Set request class/object
    434       *
    435       * Set the request object.  The request holds the request environment.
    436       *
    437       * If a class name is provided, it will instantiate it
    438       *
    439       * @param string|Zend_Controller_Request_Abstract $request
    440       * @throws Zend_Controller_Exception if invalid request class
    441       * @return Zend_Controller_Front
    442       */
    443      
    public function setRequest($request)
    444      {
    445          if (
    is_string($request)) {
    446              if (!
    class_exists($request)) {
    447                  require_once 
    'Zend/Loader.php';
    448                  
    Zend_Loader::loadClass($request);
    449              }
    450              
    $request = new $request();
    451          }
    452          if (!
    $request instanceof Zend_Controller_Request_Abstract) {
    453              require_once 
    'Zend/Controller/Exception.php';
    454              throw new 
    Zend_Controller_Exception('Invalid request class');
    455          }
    456  
    457          
    $this->_request $request;
    458  
    459          return 
    $this;
    460      }
    461  
    462      
    /**
    463       * Return the request object.
    464       *
    465       * @return null|Zend_Controller_Request_Abstract
    466       */
    467      
    public function getRequest()
    468      {
    469          return 
    $this->_request;
    470      }
    471  
    472      
    /**
    473       * Set router class/object
    474       *
    475       * Set the router object.  The router is responsible for mapping
    476       * the request to a controller and action.
    477       *
    478       * If a class name is provided, instantiates router with any parameters
    479       * registered via {@link setParam()} or {@link setParams()}.
    480       *
    481       * @param string|Zend_Controller_Router_Interface $router
    482       * @throws Zend_Controller_Exception if invalid router class
    483       * @return Zend_Controller_Front
    484       */
    485      
    public function setRouter($router)
    486      {
    487          if (
    is_string($router)) {
    488              if (!
    class_exists($router)) {
    489                  require_once 
    'Zend/Loader.php';
    490                  
    Zend_Loader::loadClass($router);
    491              }
    492              
    $router = new $router();
    493          }
    494  
    495          if (!
    $router instanceof Zend_Controller_Router_Interface) {
    496              require_once 
    'Zend/Controller/Exception.php';
    497              throw new 
    Zend_Controller_Exception('Invalid router class');
    498          }
    499  
    500          
    $router->setFrontController($this);
    501          
    $this->_router $router;
    502  
    503          return 
    $this;
    504      }
    505  
    506      
    /**
    507       * Return the router object.
    508       *
    509       * Instantiates a Zend_Controller_Router_Rewrite object if no router currently set.
    510       *
    511       * @return Zend_Controller_Router_Interface
    512       */
    513      
    public function getRouter()
    514      {
    515          if (
    null == $this->_router) {
    516              require_once 
    'Zend/Controller/Router/Rewrite.php';
    517              
    $this->setRouter(new Zend_Controller_Router_Rewrite());
    518          }
    519  
    520          return 
    $this->_router;
    521      }
    522  
    523      
    /**
    524       * Set the base URL used for requests
    525       *
    526       * Use to set the base URL segment of the REQUEST_URI to use when
    527       * determining PATH_INFO, etc. Examples:
    528       * - /admin
    529       * - /myapp
    530       * - /subdir/index.php
    531       *
    532       * Note that the URL should not include the full URI. Do not use:
    533       * - http://example.com/admin
    534       * - http://example.com/myapp
    535       * - http://example.com/subdir/index.php
    536       *
    537       * If a null value is passed, this can be used as well for autodiscovery (default).
    538       *
    539       * @param string $base
    540       * @return Zend_Controller_Front
    541       * @throws Zend_Controller_Exception for non-string $base
    542       */
    543      
    public function setBaseUrl($base null)
    544      {
    545          if (!
    is_string($base) && (null !== $base)) {
    546              require_once 
    'Zend/Controller/Exception.php';
    547              throw new 
    Zend_Controller_Exception('Rewrite base must be a string');
    548          }
    549  
    550          
    $this->_baseUrl $base;
    551  
    552          if ((
    null !== ($request $this->getRequest())) && (method_exists($request'setBaseUrl'))) {
    553              
    $request->setBaseUrl($base);
    554          }
    555  
    556          return 
    $this;
    557      }
    558  
    559      
    /**
    560       * Retrieve the currently set base URL
    561       *
    562       * @return string
    563       */
    564      
    public function getBaseUrl()
    565      {
    566          
    $request $this->getRequest();
    567          if ((
    null !== $request) && method_exists($request'getBaseUrl')) {
    568              return 
    $request->getBaseUrl();
    569          }
    570  
    571          return 
    $this->_baseUrl;
    572      }
    573  
    574      
    /**
    575       * Set the dispatcher object.  The dispatcher is responsible for
    576       * taking a Zend_Controller_Dispatcher_Token object, instantiating the controller, and
    577       * call the action method of the controller.
    578       *
    579       * @param Zend_Controller_Dispatcher_Interface $dispatcher
    580       * @return Zend_Controller_Front
    581       */
    582      
    public function setDispatcher(Zend_Controller_Dispatcher_Interface $dispatcher)
    583      {
    584          
    $this->_dispatcher $dispatcher;
    585          return 
    $this;
    586      }
    587  
    588      
    /**
    589       * Return the dispatcher object.
    590       *
    591       * @return Zend_Controller_Dispatcher_Interface
    592       */
    593      
    public function getDispatcher()
    594      {
    595          
    /**
    596           * Instantiate the default dispatcher if one was not set.
    597           */
    598          
    if (!$this->_dispatcher instanceof Zend_Controller_Dispatcher_Interface) {
    599              require_once 
    'Zend/Controller/Dispatcher/Standard.php';
    600              
    $this->_dispatcher = new Zend_Controller_Dispatcher_Standard();
    601          }
    602          return 
    $this->_dispatcher;
    603      }
    604  
    605      
    /**
    606       * Set response class/object
    607       *
    608       * Set the response object.  The response is a container for action
    609       * responses and headers. Usage is optional.
    610       *
    611       * If a class name is provided, instantiates a response object.
    612       *
    613       * @param string|Zend_Controller_Response_Abstract $response
    614       * @throws Zend_Controller_Exception if invalid response class
    615       * @return Zend_Controller_Front
    616       */
    617      
    public function setResponse($response)
    618      {
    619          if (
    is_string($response)) {
    620              if (!
    class_exists($response)) {
    621                  require_once 
    'Zend/Loader.php';
    622                  
    Zend_Loader::loadClass($response);
    623              }
    624              
    $response = new $response();
    625          }
    626          if (!
    $response instanceof Zend_Controller_Response_Abstract) {
    627              require_once 
    'Zend/Controller/Exception.php';
    628              throw new 
    Zend_Controller_Exception('Invalid response class');
    629          }
    630  
    631          
    $this->_response $response;
    632  
    633          return 
    $this;
    634      }
    635  
    636      
    /**
    637       * Return the response object.
    638       *
    639       * @return null|Zend_Controller_Response_Abstract
    640       */
    641      
    public function getResponse()
    642      {
    643          return 
    $this->_response;
    644      }
    645  
    646      
    /**
    647       * Add or modify a parameter to use when instantiating an action controller
    648       *
    649       * @param string $name
    650       * @param mixed $value
    651       * @return Zend_Controller_Front
    652       */
    653      
    public function setParam($name$value)
    654      {
    655          
    $name = (string) $name;
    656          
    $this->_invokeParams[$name] = $value;
    657          return 
    $this;
    658      }
    659  
    660      
    /**
    661       * Set parameters to pass to action controller constructors
    662       *
    663       * @param array $params
    664       * @return Zend_Controller_Front
    665       */
    666      
    public function setParams(array $params)
    667      {
    668          
    $this->_invokeParams array_merge($this->_invokeParams$params);
    669          return 
    $this;
    670      }
    671  
    672      
    /**
    673       * Retrieve a single parameter from the controller parameter stack
    674       *
    675       * @param string $name
    676       * @return mixed
    677       */
    678      
    public function getParam($name)
    679      {
    680          if(isset(
    $this->_invokeParams[$name])) {
    681              return 
    $this->_invokeParams[$name];
    682          }
    683  
    684          return 
    null;
    685      }
    686  
    687      
    /**
    688       * Retrieve action controller instantiation parameters
    689       *
    690       * @return array
    691       */
    692      
    public function getParams()
    693      {
    694          return 
    $this->_invokeParams;
    695      }
    696  
    697      
    /**
    698       * Clear the controller parameter stack
    699       *
    700       * By default, clears all parameters. If a parameter name is given, clears
    701       * only that parameter; if an array of parameter names is provided, clears
    702       * each.
    703       *
    704       * @param null|string|array single key or array of keys for params to clear
    705       * @return Zend_Controller_Front
    706       */
    707      
    public function clearParams($name null)
    708      {
    709          if (
    null === $name) {
    710              
    $this->_invokeParams = array();
    711          } elseif (
    is_string($name) && isset($this->_invokeParams[$name])) {
    712              unset(
    $this->_invokeParams[$name]);
    713          } elseif (
    is_array($name)) {
    714              foreach (
    $name as $key) {
    715                  if (
    is_string($key) && isset($this->_invokeParams[$key])) {
    716                      unset(
    $this->_invokeParams[$key]);
    717                  }
    718              }
    719          }
    720  
    721          return 
    $this;
    722      }
    723  
    724      
    /**
    725       * Register a plugin.
    726       *
    727       * @param  Zend_Controller_Plugin_Abstract $plugin
    728       * @param  int $stackIndex Optional; stack index for plugin
    729       * @return Zend_Controller_Front
    730       */
    731      
    public function registerPlugin(Zend_Controller_Plugin_Abstract $plugin$stackIndex null)
    732      {
    733          
    $this->_plugins->registerPlugin($plugin$stackIndex);
    734          return 
    $this;
    735      }
    736  
    737      
    /**
    738       * Unregister a plugin.
    739       *
    740       * @param  string|Zend_Controller_Plugin_Abstract $plugin Plugin class or object to unregister
    741       * @return Zend_Controller_Front
    742       */
    743      
    public function unregisterPlugin($plugin)
    744      {
    745          
    $this->_plugins->unregisterPlugin($plugin);
    746          return 
    $this;
    747      }
    748  
    749      
    /**
    750       * Is a particular plugin registered?
    751       *
    752       * @param  string $class
    753       * @return bool
    754       */
    755      
    public function hasPlugin($class)
    756      {
    757          return 
    $this->_plugins->hasPlugin($class);
    758      }
    759  
    760      
    /**
    761       * Retrieve a plugin or plugins by class
    762       *
    763       * @param  string $class
    764       * @return false|Zend_Controller_Plugin_Abstract|array
    765       */
    766      
    public function getPlugin($class)
    767      {
    768          return 
    $this->_plugins->getPlugin($class);
    769      }
    770  
    771      
    /**
    772       * Retrieve all plugins
    773       *
    774       * @return array
    775       */
    776      
    public function getPlugins()
    777      {
    778          return 
    $this->_plugins->getPlugins();
    779      }
    780  
    781      
    /**
    782       * Set the throwExceptions flag and retrieve current status
    783       *
    784       * Set whether exceptions encounted in the dispatch loop should be thrown
    785       * or caught and trapped in the response object.
    786       *
    787       * Default behaviour is to trap them in the response object; call this
    788       * method to have them thrown.
    789       *
    790       * Passing no value will return the current value of the flag; passing a
    791       * boolean true or false value will set the flag and return the current
    792       * object instance.
    793       *
    794       * @param boolean $flag Defaults to null (return flag state)
    795       * @return boolean|Zend_Controller_Front Used as a setter, returns object; as a getter, returns boolean
    796       */
    797      
    public function throwExceptions($flag null)
    798      {
    799          if (
    $flag !== null) {
    800              
    $this->_throwExceptions = (bool) $flag;
    801              return 
    $this;
    802          }
    803  
    804          return 
    $this->_throwExceptions;
    805      }
    806  
    807      
    /**
    808       * Set whether {@link dispatch()} should return the response without first
    809       * rendering output. By default, output is rendered and dispatch() returns
    810       * nothing.
    811       *
    812       * @param boolean $flag
    813       * @return boolean|Zend_Controller_Front Used as a setter, returns object; as a getter, returns boolean
    814       */
    815      
    public function returnResponse($flag null)
    816      {
    817          if (
    true === $flag) {
    818              
    $this->_returnResponse true;
    819              return 
    $this;
    820          } elseif (
    false === $flag) {
    821              
    $this->_returnResponse false;
    822              return 
    $this;
    823          }
    824  
    825          return 
    $this->_returnResponse;
    826      }
    827  
    828      
    /**
    829       * Dispatch an HTTP request to a controller/action.
    830       *
    831       * @param Zend_Controller_Request_Abstract|null $request
    832       * @param Zend_Controller_Response_Abstract|null $response
    833       * @return void|Zend_Controller_Response_Abstract Returns response object if returnResponse() is true
    834       */
    835      
    public function dispatch(Zend_Controller_Request_Abstract $request nullZend_Controller_Response_Abstract $response null)
    836      {
    837          if (!
    $this->getParam('noErrorHandler') && !$this->_plugins->hasPlugin('Zend_Controller_Plugin_ErrorHandler')) {
    838              
    // Register with stack index of 100
    839              
    require_once 'Zend/Controller/Plugin/ErrorHandler.php';
    840              
    $this->_plugins->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(), 100);
    841          }
    842  
    843          if (!
    $this->getParam('noViewRenderer') && !Zend_Controller_Action_HelperBroker::hasHelper('viewRenderer')) {
    844              require_once 
    'Zend/Controller/Action/Helper/ViewRenderer.php';
    845              
    Zend_Controller_Action_HelperBroker::getStack()->offsetSet(-80, new Zend_Controller_Action_Helper_ViewRenderer());
    846          }
    847  
    848          
    /**
    849           * Instantiate default request object (HTTP version) if none provided
    850           */
    851          
    if (null !== $request) {
    852              
    $this->setRequest($request);
    853          } elseif ((
    null === $request) && (null === ($request $this->getRequest()))) {
    854              require_once 
    'Zend/Controller/Request/Http.php';
    855              
    $request = new Zend_Controller_Request_Http();
    856              
    $this->setRequest($request);
    857          }
    858  
    859          
    /**
    860           * Set base URL of request object, if available
    861           */
    862          
    if (is_callable(array($this->_request'setBaseUrl'))) {
    863              if (
    null !== $this->_baseUrl) {
    864                  
    $this->_request->setBaseUrl($this->_baseUrl);
    865              }
    866          }
    867  
    868          
    /**
    869           * Instantiate default response object (HTTP version) if none provided
    870           */
    871          
    if (null !== $response) {
    872              
    $this->setResponse($response);
    873          } elseif ((
    null === $this->_response) && (null === ($this->_response $this->getResponse()))) {
    874              require_once 
    'Zend/Controller/Response/Http.php';
    875              
    $response = new Zend_Controller_Response_Http();
    876              
    $this->setResponse($response);
    877          }
    878  
    879          
    /**
    880           * Register request and response objects with plugin broker
    881           */
    882          
    $this->_plugins
    883               
    ->setRequest($this->_request)
    884               ->
    setResponse($this->_response);
    885  
    886          
    /**
    887           * Initialize router
    888           */
    889          
    $router $this->getRouter();
    890          
    $router->setParams($this->getParams());
    891  
    892          
    /**
    893           * Initialize dispatcher
    894           */
    895          
    $dispatcher $this->getDispatcher();
    896          
    $dispatcher->setParams($this->getParams())
    897                     ->
    setResponse($this->_response);
    898  
    899          
    // Begin dispatch
    900          
    try {
    901              
    /**
    902               * Route request to controller/action, if a router is provided
    903               */
    904  
    905              /**
    906              * Notify plugins of router startup
    907              */
    908              
    $this->_plugins->routeStartup($this->_request);
    909  
    910              try {
    911                  
    $router->route($this->_request);
    912              }  catch (
    Exception $e) {
    913                  if (
    $this->throwExceptions()) {
    914                      throw 
    $e;
    915                  }
    916  
    917                  
    $this->_response->setException($e);
    918              }
    919  
    920              
    /**
    921              * Notify plugins of router completion
    922              */
    923              
    $this->_plugins->routeShutdown($this->_request);
    924  
    925              
    /**
    926               * Notify plugins of dispatch loop startup
    927               */
    928              
    $this->_plugins->dispatchLoopStartup($this->_request);
    929  
    930              
    /**
    931               *  Attempt to dispatch the controller/action. If the $this->_request
    932               *  indicates that it needs to be dispatched, move to the next
    933               *  action in the request.
    934               */
    935              
    do {
    936                  
    $this->_request->setDispatched(true);
    937  
    938                  
    /**
    939                   * Notify plugins of dispatch startup
    940                   */
    941                  
    $this->_plugins->preDispatch($this->_request);
    942  
    943                  
    /**
    944                   * Skip requested action if preDispatch() has reset it
    945                   */
    946                  
    if (!$this->_request->isDispatched()) {
    947                      continue;
    948                  }
    949  
    950                  
    /**
    951                   * Dispatch request
    952                   */
    953                  
    try {
    954                      
    $dispatcher->dispatch($this->_request$this->_response);
    955                  } catch (
    Exception $e) {
    956                      if (
    $this->throwExceptions()) {
    957                          throw 
    $e;
    958                      }
    959                      
    $this->_response->setException($e);
    960                  }
    961  
    962                  
    /**
    963                   * Notify plugins of dispatch completion
    964                   */
    965                  
    $this->_plugins->postDispatch($this->_request);
    966              } while (!
    $this->_request->isDispatched());
    967          } catch (
    Exception $e) {
    968              if (
    $this->throwExceptions()) {
    969                  throw 
    $e;
    970              }
    971  
    972              
    $this->_response->setException($e);
    973          }
    974  
    975          
    /**
    976           * Notify plugins of dispatch loop completion
    977           */
    978          
    try {
    979              
    $this->_plugins->dispatchLoopShutdown();
    980          } catch (
    Exception $e) {
    981              if (
    $this->throwExceptions()) {
    982                  throw 
    $e;
    983              }
    984  
    985              
    $this->_response->setException($e);
    986          }
    987  
    988          if (
    $this->returnResponse()) {
    989              return 
    $this->_response;
    990          }
    991  
    992          
    $this->_response->sendResponse();
    993      }
    994  }
    995  
  2. open/var/www/contextly-site/library/Zend/Application/Bootstrap/Bootstrap.php
    Zend_Controller_Front->dispatch()
    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    * @subpackage Bootstrap
    18    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
    19    * @license    http://framework.zend.com/license/new-bsd     New BSD License
    20    * @version    $Id: Bootstrap.php 24594 2012-01-05 21:27:01Z matthew $
    21    */
    22   
    23   /**
    24    * Concrete base class for bootstrap classes
    25    *
    26    * Registers and utilizes Zend_Controller_Front by default.
    27    *
    28    * @uses       Zend_Application_Bootstrap_Bootstrap
    29    * @category   Zend
    30    * @package    Zend_Application
    31    * @subpackage Bootstrap
    32    * @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
    33    * @license    http://framework.zend.com/license/new-bsd     New BSD License
    34    */
    35   
    class Zend_Application_Bootstrap_Bootstrap
    36       
    extends Zend_Application_Bootstrap_BootstrapAbstract
    37   
    {
    38       
    /**
    39        * Application resource namespace
    40        * @var false|string
    41        */
    42       
    protected $_appNamespace false;
    43   
    44       
    /**
    45        * Application resource autoloader
    46        * @var Zend_Loader_Autoloader_Resource
    47        */
    48       
    protected $_resourceLoader;
    49   
    50       
    /**
    51        * Constructor
    52        *
    53        * Ensure FrontController resource is registered
    54        *
    55        * @param  Zend_Application|Zend_Application_Bootstrap_Bootstrapper $application
    56        * @return void
    57        */
    58       
    public function __construct($application)
    59       {
    60           
    parent::__construct($application);
    61   
    62           if (
    $application->hasOption('resourceloader')) {
    63               
    $this->setOptions(array(
    64                   
    'resourceloader' => $application->getOption('resourceloader')
    65               ));
    66           }
    67           
    $this->getResourceLoader();
    68   
    69           if (!
    $this->hasPluginResource('FrontController')) {
    70               
    $this->registerPluginResource('FrontController');
    71           }
    72       }
    73   
    74       
    /**
    75        * Run the application
    76        *
    77        * Checks to see that we have a default controller directory. If not, an
    78        * exception is thrown.
    79        *
    80        * If so, it registers the bootstrap with the 'bootstrap' parameter of
    81        * the front controller, and dispatches the front controller.
    82        *
    83        * @return mixed
    84        * @throws Zend_Application_Bootstrap_Exception
    85        */
    86       
    public function run()
    87       {
    88           
    $front   $this->getResource('FrontController');
    89           
    $default $front->getDefaultModule();
    90           if (
    null === $front->getControllerDirectory($default)) {
    91               throw new 
    Zend_Application_Bootstrap_Exception(
    92                   
    'No default controller directory registered with front controller'
    93               
    );
    94           }
    95   
    96           
    $front->setParam('bootstrap'$this);
    97           
    $response $front->dispatch();
    98           if (
    $front->returnResponse()) {
    99               return 
    $response;
    100          }
    101      }
    102  
    103      
    /**
    104       * Set module resource loader
    105       *
    106       * @param  Zend_Loader_Autoloader_Resource $loader
    107       * @return Zend_Application_Module_Bootstrap
    108       */
    109      
    public function setResourceLoader(Zend_Loader_Autoloader_Resource $loader)
    110      {
    111          
    $this->_resourceLoader $loader;
    112          return 
    $this;
    113      }
    114  
    115      
    /**
    116       * Retrieve module resource loader
    117       *
    118       * @return Zend_Loader_Autoloader_Resource
    119       */
    120      
    public function getResourceLoader()
    121      {
    122          if ((
    null === $this->_resourceLoader)
    123              && (
    false !== ($namespace $this->getAppNamespace()))
    124          ) {
    125              
    $r    = new ReflectionClass($this);
    126              
    $path $r->getFileName();
    127              
    $this->setResourceLoader(new Zend_Application_Module_Autoloader(array(
    128                  
    'namespace' => $namespace,
    129                  
    'basePath'  => dirname($path),
    130              )));
    131          }
    132          return 
    $this->_resourceLoader;
    133      }
    134  
    135      
    /**
    136       * Get application namespace (used for module autoloading)
    137       *
    138       * @return string
    139       */
    140      
    public function getAppNamespace()
    141      {
    142          return 
    $this->_appNamespace;
    143      }
    144  
    145      
    /**
    146       * Set application namespace (for module autoloading)
    147       *
    148       * @param  string
    149       * @return Zend_Application_Bootstrap_Bootstrap
    150       */
    151      
    public function setAppNamespace($value)
    152      {
    153          
    $this->_appNamespace = (string) $value;
    154          return 
    $this;
    155      }
    156  }
    157  
  3. open/var/www/contextly-site/library/Zend/Application.php
    Zend_Application_Bootstrap_Bootstrap->run()
    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-2012 Zend Technologies USA Inc. (http://www.zend.com)
    18    * @license    http://framework.zend.com/license/new-bsd     New BSD License
    19    * @version    $Id: Application.php 24594 2012-01-05 21:27:01Z matthew $
    20    */
    21   
    22   /**
    23    * @category   Zend
    24    * @package    Zend_Application
    25    * @copyright  Copyright (c) 2005-2012 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($optionsCASE_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($optionsCASE_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($classfalse)) {
    320              require_once 
    $path;
    321              if (!
    class_exists($classfalse)) {
    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      pathinfo($filePATHINFO_EXTENSION);
    380          
    $suffix      = ($suffix === 'dist')
    381                       ? 
    pathinfo(basename($file".$suffix"), PATHINFO_EXTENSION)
    382                       : 
    $suffix;
    383  
    384          switch (
    strtolower($suffix)) {
    385              case 
    'ini':
    386                  
    $config = new Zend_Config_Ini($file$environment);
    387                  break;
    388  
    389              case 
    'xml':
    390                  
    $config = new Zend_Config_Xml($file$environment);
    391                  break;
    392  
    393              case 
    'json':
    394                  
    $config = new Zend_Config_Json($file$environment);
    395                  break;
    396  
    397              case 
    'yaml':
    398              case 
    'yml':
    399                  
    $config = new Zend_Config_Yaml($file$environment);
    400                  break;
    401  
    402              case 
    'php':
    403              case 
    'inc':
    404                  
    $config = include $file;
    405                  if (!
    is_array($config)) {
    406                      throw new 
    Zend_Application_Exception('Invalid configuration file provided; PHP file does not return array value');
    407                  }
    408                  return 
    $config;
    409                  break;
    410  
    411              default:
    412                  throw new 
    Zend_Application_Exception('Invalid configuration file provided; unknown config type');
    413          }
    414  
    415          return 
    $config->toArray();
    416      }
    417  }
    418  
  4. open/var/www/contextly-site/public/index.php
    Zend_Application->run()
    1     <?php
    2    
    3    
    // Define path to application directory
    4    
    defined('APPLICATION_PATH')
    5        || 
    define('APPLICATION_PATH'realpath(dirname(__FILE__) . '/../application'));
    6    
    7    
    // Define application environment
    8    
    defined('APPLICATION_ENV')
    9        || 
    define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));
    10   
    11   
    // Ensure library/ is on include_path
    12   
    set_include_path(implode(PATH_SEPARATOR, array(
    13       
    realpath(APPLICATION_PATH '/../library'),
    14       
    realpath(APPLICATION_PATH '/models'),
    15       
    realpath(APPLICATION_PATH '/validate'),
    16       
    get_include_path(),
    17   )));
    18   
    19   
    /** Zend_Application */
    20   
    require_once 'Zend/Application.php';
    21   require_once 
    'version.php';
    22   
    23   
    // Create application, bootstrap, and run
    24   
    $application = new Zend_Application(
    25       
    APPLICATION_ENV,
    26       
    APPLICATION_PATH '/configs/application.ini'
    27   
    );
    28   
    $application->bootstrap()
    29               ->
    run();
    30   
    31   
    32   
    // Some global function here
    33   
    34   
    function getmicrotime() {
    35       list(
    $usec$sec) = explode(" ",microtime());
    36       return ((float)
    $usec + (float)$sec);
    37   }
    38