execute($method, $parameters); } /** * Resolve a controller name to a controller instance. * * @param Container $container * @param string $controller * @return Controller */ public static function resolve($controller) { if ( ! static::load($controller)) return; // If the controller is registered in the IoC container, we will resolve // it out of the container. Using constructor injection on controllers // via the container allows more flexible and testable applications. if (IoC::container()->registered('controllers.'.$controller)) { return IoC::container()->resolve('controllers.'.$controller); } $controller = str_replace(' ', '_', ucwords(str_replace('.', ' ', $controller))).'_Controller'; $controller = new $controller; // If the controller has specified a layout to be used when rendering // views, we will instantiate the layout instance and set it to the // layout property, replacing the string layout name. if ( ! is_null($controller->layout)) { $controller->layout = View::make($controller->layout); } return $controller; } /** * Load the file for a given controller. * * @param string $controller * @return bool */ protected static function load($controller) { $controller = strtolower(str_replace('.', '/', $controller)); if (file_exists($path = CONTROLLER_PATH.$controller.EXT)) { require_once $path; return true; } return false; } /** * Execute a controller method with the given parameters. * * @param string $method * @param array $parameters * @return Response */ public function execute($method, $parameters = array()) { // Again, as was the case with route closures, if the controller // "before" filters return a response, it will be considered the // response to the request and the controller method will not be // used to handle the request to the application. $response = Filter::run($this->filters('before', $method), array(), true); if (is_null($response)) { $response = call_user_func_array(array($this, "action_{$method}"), $parameters); // If the controller has specified a layout view. The response // returned by the controller method will be bound to that view // and the layout will be considered the response. if ( ! is_null($this->layout) and $this->viewable($response)) { $response = $this->layout->with('content', $response); } } // The after filter and the framework expects all responses to // be instances of the Response class. If the method did not // return an instsance of Response, we will make on now. if ( ! $response instanceof Response) { $response = new Response($response); } Filter::run($this->filters('after', $method), array($response)); return $response; } /** * Deteremine if a given response is considered "viewable". * * This is primarily used to determine which types of responses should be * bound to the controller's layout and which should not. We do not want * to bind redirects and file downloads to the layout, as this obviously * would not make any sense. * * @param mixed $response * @return bool */ protected function viewable($response) { if ($response instanceof Response) { if ($response instanceof Redirect) { return false; } elseif ($response->headers['Content-Description'] == 'File Transfer') { return false; } } return true; } /** * Register filters on the controller's methods. * * Generally, this method will be used in the controller's constructor. * * * // Set a "foo" after filter on the controller * $this->filter('before', 'foo'); * * // Set several filters on an explicit group of methods * $this->filter('after', 'foo|bar')->only(array('user', 'profile')); * * * @param string|array $filters * @return Filter_Collection */ protected function filter($name, $filters) { $this->filters[] = new Filter_Collection($name, $filters); return $this->filters[count($this->filters) - 1]; } /** * Get an array of filter names defined for the destination. * * @param string $name * @param string $method * @return array */ protected function filters($name, $method) { $filters = array(); foreach ($this->filters as $filter) { if ($filter->name === $name and $filter->applies($method)) { $filters = array_merge($filters, $filter->filters); } } return array_unique($filters); } /** * Magic Method to handle calls to undefined functions on the controller. * * By default, the 404 response will be returned for an calls to undefined * methods on the controller. However, this method may also be overridden * and used as a pseudo-router by the controller. */ public function __call($method, $parameters) { return Response::error('404'); } /** * Dynamically resolve items from the application IoC container. * * * // Retrieve an object registered in the container as "mailer" * $mailer = $this->mailer; * * // Equivalent call using the IoC container instance * $mailer = IoC::container()->resolve('mailer'); * */ public function __get($key) { if (IoC::container()->registered($key)) { return IoC::container()->resolve($key); } throw new \Exception("Attempting to access undefined property [$key] on controller."); } }