Beispiel #1
0
 /**
  * Dispatches a handle action taking into account the routing parameters
  *
  * @return object|boolean
  */
 public function dispatch()
 {
     if (is_object($this->_dependencyInjector) === false) {
         $this->_throwDispatchException('A dependency injection container is required to access related dispatching services', self::EXCEPTION_NO_DI);
         return false;
     }
     if (is_object($this->_eventsManager) === true) {
         if ($this->_eventsManager->fire('dispatch:beforeDispatchLoop', $this) === false) {
             return false;
         }
     }
     $numberDispatches = 0;
     $this->_finished = false;
     $handler = null;
     while (true) {
         //Loop until finished is false
         if ($this->_finished === true) {
             break;
         }
         ++$numberDispatches;
         //Throw an exception after 256 consecutive forwards
         if ($numberDispatches >= 256) {
             $this->_throwDispatchException('Dispatcher has detected a cyclic routing causing stability problems', self::EXCEPTION_CYCLIC_ROUTING);
             break;
         }
         $this->_finished = true;
         //If the current namespace is null we use the set in $this->_defaultNamespace
         if (is_null($this->_namespaceName) === true) {
             $this->_namespaceName = $this->_defaultNamespace;
         }
         //If the handler is null we use the set in $this->_defaultHandler
         if (is_null($this->_handlerName) === true) {
             $this->_handlerName = $this->_defaultHandler;
         }
         //If the action is null we use the set in $this->_defaultAction
         if (is_null($this->_actionName) === true) {
             $this->_actionName = $this->_defaultAction;
         }
         //Calling beforeDispatch
         if (is_object($this->_eventsManager) === true) {
             if ($this->_eventsManager->fire('dispatch:beforeDispatch', $this) === false) {
                 continue;
             }
             //Check if the user made a forward in the listener
             if ($this->_finished === false) {
                 continue;
             }
         }
         //We don't camelize the classes if they are in namespaces
         $p = strpos($this->_handlerName, '\\');
         if ($p === false) {
             $camelizedClass = Text::camelize($this->_handlerName);
         } elseif ($p === 0) {
             //@note this only handles one leading slash
             $camelizedClass = substr($this->_handlerName, strlen($this->_handlerName) + 1);
         } else {
             $camelizedClass = $this->_handlerName;
         }
         //Create the complete controller class name prepending the namespace
         if (is_null($this->_namespaceName) === false) {
             if (strrpos($this->_namespaceName, '\\') === strlen($this->_namespaceName) - 1) {
                 $handlerClass = $this->_namespaceName . $camelizedClass . $this->_handlerSuffix;
             } else {
                 $handlerClass = $this->_namespaceName . '\\' . $camelizedClass . $this->_handlerSuffix;
             }
         } else {
             $handlerClass = $camelizedClass . $this->_handlerSuffix;
         }
         //Handlers are retrieved as shared instances from the Service Container
         if ($this->_dependencyInjector->has($handlerClass) === false) {
             //Check using autoloading
             if (class_exists($handlerClass) === false) {
                 if ($this->_throwDispatchException($handlerClass . ' handler class cannot be loaded', self::EXCEPTION_HANDLER_NOT_FOUND) === false) {
                     if ($this->_finished === false) {
                         continue;
                     }
                 }
                 break;
             }
         }
         //Handlers must be only objects
         $handler = $this->_dependencyInjector->getShared($handlerClass);
         if (is_object($handler) === false) {
             if ($this->_throwDispatchException('Invalid handler returned from the services container', self::EXCEPTION_INVALID_HANDLER) === false) {
                 if ($this->_finished === false) {
                     continue;
                 }
             }
             break;
         }
         //If the object was recently created in the DI we initialize it
         $wasFresh = $this->_dependencyInjector->wasFreshInstance();
         $this->_activeHandler = $handler;
         //Check if the method exists in the handler
         $actionMethod = $this->_actionName . $this->_actionSuffix;
         if (method_exists($handler, $actionMethod) === false) {
             //Call beforeNotFoundAction
             if (is_object($this->_eventsManager) === true) {
                 if ($this->_eventsManager->fire('dispatch:beforeNotFoundAction', $this) === false) {
                     continue;
                 }
                 if ($this->_finished === false) {
                     continue;
                 }
             }
             if ($this->_throwDispatchException('Action \'' . $this->_actionName . '\' was not found on handler \'' . $this->_handlerName . '\'', self::EXCEPTION_ACTION_NOT_FOUND) === false) {
                 if ($this->_finished === false) {
                     continue;
                 }
             }
             break;
         }
         //Calling beforeExecuteRoute
         if (is_object($this->_eventsManager) === true) {
             if ($this->_eventsManager->fire('dispatch:beforeExecuteRoute', $this) === false) {
                 continue;
             }
             //Check if the user made a forward in the listener
             if ($this->_finished === false) {
                 continue;
             }
         }
         //Calling beforeExecuteRoute as callback and event
         if (method_exists($handler, 'beforeExecuteRoute') === true) {
             if ($handler->beforeExecuteRoute($this) === false) {
                 continue;
             }
             //Check if the user made a forward in the listener
             if ($this->_finished === false) {
                 continue;
             }
         }
         //Check if params is an array
         if (is_array($this->_params) === false) {
             if ($this->_throwDispatchException('Action parameters must be an Array', self::EXCEPTION_INVALID_PARAMS) === false) {
                 if ($this->_finished === false) {
                     continue;
                 }
             }
             break;
         }
         //Call the 'initialize' method just once per request
         if ($wasFresh === true) {
             if (method_exists($handler, 'initialize') === true) {
                 $handler->initialize();
             }
         }
         //Call the method with/without exceptions if an events manager is present
         if (is_object($this->_eventsManager) === true) {
             try {
                 //Call the method allowing exceptions
                 $m = new ReflectionMethod($handler, $actionMethod);
                 $value = $m->invokeArgs($handler, $this->_params);
             } catch (\Exception $exception) {
                 //Copy the exception to rethrow it later if needed
                 //Try to handle the exception
                 if ($this->_handleException($exception) === false) {
                     if ($this->_finished === false) {
                         continue;
                     }
                 } else {
                     //Exception wasn't handled, rethrow it
                     throw new Exception($exception);
                 }
             }
             //Update the latest value produced by the latest handler
             $this->_returnedValue = $value;
         } else {
             //Call the method handling exceptions as normal
             $this->_returnedValue = call_user_func_array(array($handler, $actionMethod), $this->_params);
         }
         $this->_lastHandler = $handler;
         //Calling afterExecuteRoute
         if (is_object($this->_eventsManager) === true) {
             if ($this->_eventsManager->fire('dispatch:afterExecuteRoute', $this) === false) {
                 continue;
             }
             if ($this->_finished === false) {
                 continue;
             }
             //Calling afetDispatch
             $this->_eventsManager->fire('dispatch:afterDispatch', $this);
         }
         //Calling afterExecuteRoute as callback and event
         if (method_exists($handler, 'afterExecuteRoute') === true) {
             if ($handler->afterExecuteRoute($this, $this->_returnedValue) === false) {
                 continue;
             }
             if ($this->_finished === false) {
                 continue;
             }
         }
     }
     //Call afterDispatchLoop
     if (is_object($this->_eventsManager) === true) {
         $this->_eventsManager->fire('dispatch:afterDispatchLoop', $this);
     }
     return $handler;
 }