PHP Zend::isReadable方法代码示例

 public function testIsReadable()
 {
     $this->assertTrue(Zend::isReadable(__FILE__));
     $this->assertFalse(Zend::isReadable(__FILE__ . '.foobaar'));
 }

 /**
  * If $performDispatch is FALSE, this method will check if a controller
  * file exists.  This still doesn't necessarily mean that it can be dispatched
  * in the stricted sense, as file may not contain the controller class or the
  * controller may reject the action.
  *
  * If $performDispatch is TRUE, then this method will actually
  * instantiate the controller and call its action.  Calling the action
  * is done by passing a Zend_Controller_Dispatcher_Token to the controller's constructor.
  *
  * @param Zend_Controller_Dispatcher_Token $action
  * @param boolean $performDispatch
  * @return boolean|Zend_Controller_Dispatcher_Token
  */
 protected function _dispatch(Zend_Controller_Dispatcher_Token $action, $performDispatch)
 {
     if ($this->_directory === null) {
         throw new Zend_Controller_Dispatcher_Exception('Controller directory never set.  Use setControllerDirectory() first.');
     }
     $className = $this->formatControllerName($action->getControllerName());
     /**
      * If $performDispatch is FALSE, only determine if the controller file
      * can be accessed.
      */
     if (!$performDispatch) {
         return Zend::isReadable($this->_directory . DIRECTORY_SEPARATOR . $className . '.php');
     }
     Zend::loadClass($className, $this->_directory);
     $controller = new $className();
     if (!$controller instanceof Zend_Controller_Action) {
         throw new Zend_Controller_Dispatcher_Exception("Controller \"{$className}\" is not an instance of Zend_Controller_Action.");
     }
     /**
      * Dispatch
      *
      * Call the action of the Zend_Controller_Action.  It will return either null or a
      * new Zend_Controller_Dispatcher_Token object.  If a Zend_Controller_Dispatcher_Token object is returned, this will be returned
      * back to ZFrontController, which will call $this again to forward to
      * another action.
      */
     $nextAction = $controller->run($this, $action);
     // Destroy the page controller instance
     $controller = null;
     // Return either null (finished) or a Zend_Controller_Dispatcher_Token object (forward to another action).
     return $nextAction;
 }

 /**
  * Get controller name
  *
  * Try request first; if not found, try pulling from request parameter; 
  * if still not found, fallback to default
  *
  * @param Zend_Controller_Request_Abstract $request
  * @param array $directories
  * @return string|false Returns class name on success
  */
 protected function _getController($request, $directories = null)
 {
     if (null === $directories) {
         $directories = $this->getControllerDirectory();
     }
     if (empty($directories)) {
         throw Zend::exception('Zend_Controller_Dispatcher_Exception', 'Controller directory never set.  Use setControllerDirectory() first');
     }
     $controllerName = $request->getControllerName();
     if (empty($controllerName)) {
         $controllerName = $this->getDefaultController();
         $request->setControllerName($controllerName);
     }
     $className = $this->formatControllerName($controllerName);
     /**
      * Determine if controller is dispatchable
      *
      * Checks to see if a module name is present in the request; if so, 
      * checks for class file existing in module directory. Otherwise, loops through 
      * directories in FIFO order to find it.
      */
     $dispatchable = false;
     $module = (string) $request->getParam('module', false);
     if ($module && isset($directories[$module])) {
         $dispatchable = Zend::isReadable($directories[$module] . DIRECTORY_SEPARATOR . $className . '.php');
         if ($dispatchable) {
             $this->_curDirectory = $directories[$module];
         }
     } else {
         foreach ($directories as $directory) {
             $dispatchable = Zend::isReadable($directory . DIRECTORY_SEPARATOR . $className . '.php');
             if ($dispatchable) {
                 $this->_curDirectory = $directory;
                 break;
             }
         }
     }
     return $dispatchable ? $className : false;
 }

 /**
  * If $performDispatch is FALSE, this method will check if a controller
  * file exists.  This still doesn't necessarily mean that it can be dispatched
  * in the stricted sense, as file may not contain the controller class or the
  * controller may reject the action.
  *
  * If $performDispatch is TRUE, then this method will actually
  * instantiate the controller and call its action.  Calling the action
  * is done by passing a Zend_Controller_Dispatcher_Token to the controller's constructor.
  *
  * @param Zend_Controller_Request_Abstract $request
  * @param boolean $performDispatch
  * @return void
  */
 protected function _dispatch(Zend_Controller_Request_Abstract $request, $performDispatch = true)
 {
     /**
      * Controller directory check
      */
     if ($this->_directory === null) {
         throw new Zend_Controller_Dispatcher_Exception('Controller directory never set.  Use setControllerDirectory() first');
     }
     /**
      * Get controller name
      *
      * Try request first; if not found, try pulling from request parameter; 
      * if still not found, fallback to default
      */
     $controllerName = $request->getControllerName();
     if (empty($controllerName)) {
         $controllerName = $this->getDefaultController();
     }
     $className = $this->formatControllerName($controllerName);
     /**
      * Determine if controller is dispatchable
      */
     $dispatchable = Zend::isReadable($this->_directory . DIRECTORY_SEPARATOR . $className . '.php');
     /**
      * If $performDispatch is FALSE, only determine if the controller file
      * can be accessed.
      */
     if (!$performDispatch) {
         return $dispatchable;
     }
     /**
      * If not dispatchable, get the default controller; if this is already 
      * the default controller, throw an exception
      */
     if (!$dispatchable) {
         if ($controllerName == $this->getDefaultController()) {
             throw new Zend_Controller_Dispatcher_Exception('Default controller class not defined');
         }
         $className = $this->formatControllerName($this->getDefaultController());
     }
     /**
      * Load the controller class file
      */
     Zend::loadClass($className, $this->_directory);
     /**
      * Perform reflection on the class and verify it's a controller
      */
     $reflection = new ReflectionClass($className);
     if (!$reflection->isSubclassOf(new ReflectionClass('Zend_Controller_Action'))) {
         throw new Zend_Controller_Dispatcher_Exception("Controller \"{$className}\" is not an instance of Zend_Controller_Action");
     }
     /**
      * Get any instance arguments and instantiate a controller object
      */
     $argv = $this->getParams();
     /**
      * Prepend response object to arguments
      */
     array_unshift($argv, $this->getResponse());
     /**
      * Prepend request object to arguments
      */
     array_unshift($argv, $request);
     /**
      * Instantiate controller with arguments
      */
     $controller = $reflection->newInstanceArgs($argv);
     /**
      * Determine the action name
      *
      * First attempt to retrieve from request; then from request params 
      * using action key; default to default action
      */
     $action = $request->getActionName();
     if (empty($action)) {
         $action = $this->getDefaultAction();
     }
     $action = $this->formatActionName($action);
     $invokeArgs = array();
     /**
      * If method does not exist, default to __call()
      */
     if (!$reflection->hasMethod($action)) {
         $invokeArgs = array($action, array());
         $action = '__call';
     }
//.........这里部分代码省略.........

 /**
  * Loads a helper or filter class.
  *
  * @param string $type The class type ('helper' or 'filter').
  * @param string $name The base name.
  * @param string The full class name.
  */
 private function _loadClass($type, $name)
 {
     // check to see if name => class mapping exists for helper/filter
     $classLoaded = '_' . $type . 'Loaded';
     $classAccess = '_set' . ucfirst($type) . 'Class';
     if (isset($this->{$classLoaded}[$name])) {
         echo "Already loaded {$name} per {$classLoaded}\n", var_export($this->{$classLoaded}, 1), "\n";
         return $this->{$classLoaded}[$name];
     }
     // only look for "$Name.php"
     $file = ucfirst($name) . '.php';
     // do LIFO search for helper
     foreach ($this->_path[$type] as $info) {
         $dir = $info['dir'];
         $prefix = $info['prefix'];
         $class = $prefix . ucfirst($name);
         if (class_exists($class, false)) {
             $this->{$classAccess}($name, $class);
             return $class;
         } elseif (Zend::isReadable($dir . $file)) {
             include_once $dir . $file;
             if (class_exists($class, false)) {
                 $this->{$classAccess}($name, $class);
                 return $class;
             }
         }
     }
     require_once 'Zend/View/Exception.php';
     throw new Zend_View_Exception("{$type} '{$name}' not found in path");
 }

 /**
  * Retrieve default controller class
  *
  * Determines whether the default controller to use lies within the 
  * requested module, or if the global default should be used.
  *
  * By default, will only use the module default unless that controller does 
  * not exist; if this is the case, it falls back to the default controller 
  * in the default module.
  * 
  * @param Zend_Controller_Request_Abstract $request 
  * @return string
  */
 public function getDefaultControllerClass(Zend_Controller_Request_Abstract $request)
 {
     $controller = $this->getDefaultControllerName();
     $default = $this->formatControllerName($controller);
     $request->setControllerName($controller)->setActionName(null);
     $module = $request->getModuleName();
     $controllerDirs = $this->getControllerDirectory();
     $this->_curModule = 'default';
     $this->_curDirectory = $controllerDirs['default'];
     if ($this->isValidModule($module)) {
         $moduleDir = $controllerDirs[$module];
         $fileSpec = $moduleDir . DIRECTORY_SEPARATOR . $this->classToFilename($default);
         if (Zend::isReadable($fileSpec)) {
             $this->_curModule = $this->formatModuleName($module);
             $this->_curDirectory = $moduleDir;
         }
     }
     return $default;
 }