/** * Create a new Doctrine migration. * * @param array $arguments * @return void */ public function make($arguments) { if (count($arguments) == 0) { throw new \Exception("I need to know what to name the migration."); } list($bundle, $migration) = Bundle::parse($arguments[0]); // The migration path is prefixed with the date timestamp, which // is a better way of ordering migrations than a simple integer // incrementation, since developers may start working on the // next migration at the same time unknowingly. $prefix = date('Y_m_d_His'); $path = Bundle::path($bundle) . 'migrations' . DS; // If the migration directory does not exist for the bundle, // we will create the directory so there aren't errors when // when we try to write the migration file. if (!is_dir($path)) { mkdir($path); } $file = $path . $prefix . '_' . $migration . EXT; File::put($file, $this->stub($bundle, $migration)); echo "Great! New migration created!"; // Once the migration has been created, we'll return the // migration file name so it can be used by the task // consumer if necessary for futher work. return $file; }
/** * Parse the task name to extract the bundle, task, and method. * * @param string $task * @return array */ protected static function parse($task) { list($bundle, $task) = Bundle::parse($task); // Extract the task method from the task string. Methods are called // on tasks by separating the task and method with a single colon. // If no task is specified, "run" is used as the default. if (str_contains($task, ':')) { list($task, $method) = explode(':', $task); } else { $method = 'run'; } return array($bundle, $task, $method); }
/** * Call an action method on a controller. * * <code> * // Call the "show" method on the "user" controller * $response = Controller::call('user@show'); * * // Call the "user/admin" controller and pass parameters * $response = Controller::call('user.admin@profile', array($username)); * </code> * * @param string $destination * @param array $parameters * @return Response */ public static function call($destination, $parameters = array()) { static::references($destination, $parameters); list($bundle, $destination) = Bundle::parse($destination); // We will always start the bundle, just in case the developer is pointing // a route to another bundle. This allows us to lazy load the bundle and // improve speed since the bundle is not loaded on every request. Bundle::start($bundle); list($controller, $method) = explode('@', $destination); $controller = static::resolve($bundle, $controller); // If the controller could not be resolved, we're out of options and // will return the 404 error response. If we found the controller, // we can execute the requested method on the instance. if (is_null($controller)) { return Event::first('404'); } return $controller->execute($method, $parameters); }
/** * Generate an action URI by convention. * * @param string $action * @param array $parameters * @return string */ protected static function convention($action, $parameters) { list($bundle, $action) = Bundle::parse($action); $bundle = Bundle::get($bundle); // If a bundle exists for the action, we will attempt to use it's "handles" // clause as the root of the generated URL, as the bundle can only handle // URIs that begin with that string and no others. $root = $bundle['handles'] ?: ''; $parameters = implode('/', $parameters); // We'll replace both dots and @ signs in the URI since both are used // to specify the controller and action, and by convention should be // translated into URI slashes for the URL. $uri = $root . '/' . str_replace(array('.', '@'), '/', $action); $uri = static::to(str_finish($uri, '/') . $parameters); return trim($uri, '/'); }
/** * Determine if the given view exists. * * @param string $view * @param boolean $return_path * @return string|bool */ public static function exists($view, $return_path = false) { list($bundle, $view) = Bundle::parse($view); $view = str_replace('.', '/', $view); // We delegate the determination of view paths to the view loader event // so that the developer is free to override and manage the loading // of views in any way they see fit for their application. $path = Event::until(static::loader, array($bundle, $view)); if (!is_null($path)) { return $return_path ? $path : true; } return false; }
/** * Register a controller with the router. * * @param string|array $controllers * @param string|array $defaults * @param bool $https * @return void */ public static function controller($controllers, $defaults = 'index', $https = null) { foreach ((array) $controllers as $identifier) { list($bundle, $controller) = Bundle::parse($identifier); // First we need to replace the dots with slashes in the controller name // so that it is in directory format. The dots allow the developer to use // a cleaner syntax when specifying the controller. We will also grab the // root URI for the controller's bundle. $controller = str_replace('.', '/', $controller); $root = Bundle::option($bundle, 'handles'); // If the controller is a "home" controller, we'll need to also build an // index method route for the controller. We'll remove "home" from the // route root and setup a route to point to the index method. if (ends_with($controller, 'home')) { static::root($identifier, $controller, $root); } // The number of method arguments allowed for a controller is set by a // "segments" constant on this class which allows for the developer to // increase or decrease the limit on method arguments. $wildcards = static::repeat('(:any?)', static::$segments); // Once we have the path and root URI we can build a simple route for // the controller that should handle a conventional controller route // setup of controller/method/segment/segment, etc. $pattern = trim("{$root}/{$controller}/{$wildcards}", '/'); // Finally we can build the "uses" clause and the attributes for the // controller route and register it with the router with a wildcard // method so it is available on every request method. $uses = "{$identifier}@(:1)"; $attributes = compact('uses', 'defaults', 'https'); static::register('*', $pattern, $attributes); } }
/** * Call an action method on a controller. * * <code> * // Call the "show" method on the "user" controller * $response = Controller::call('user@show'); * * // Call the "user/admin" controller and pass parameters * $response = Controller::call('user.admin@profile', array($username)); * </code> * * @param string $destination * @param array $parameters * @return Response */ public static function call($destination, $parameters = array()) { static::references($destination, $parameters); list($bundle, $destination) = Bundle::parse($destination); // We will always start the bundle, just in case the developer is pointing // a route to another bundle. This allows us to lazy load the bundle and // improve speed since the bundle is not loaded on every request. Bundle::start($bundle); list($name, $method) = explode('@', $destination); $controller = static::resolve($bundle, $name); // For convenience we will set the current controller and action on the // Request's route instance so they can be easily accessed from the // application. This is sometimes useful for dynamic situations. if (!is_null($route = Request::route())) { $route->controller = $name; $route->controller_action = $method; } // If the controller could not be resolved, we're out of options and // will return the 404 error response. If we found the controller, // we can execute the requested method on the instance. if (is_null($controller)) { return Event::first('404'); } return $controller->execute($method, $parameters); }
/** * Parse the path to the form or page * * @param string $name * @param string $type * * @return array($file,$class_name,$method) */ protected static function parse($name, $type) { list($path, $method) = explode('@', static::$modules[$type][$name]); list($bundle, $path) = Bundle::parse($path); $file = Bundle::path($bundle) . Str::plural($type) . DS . str_replace('.', DS, $path) . EXT; $class_name = static::format($bundle, $path, $type); return array($file, $class_name, $method); }
/** * Get the path to a given view on disk. * * @param string $view * @return string */ protected function path($view) { list($bundle, $view) = Bundle::parse($view); $view = str_replace('.', '/', $view); // We delegate the determination of view paths to the view loader event // so that the developer is free to override and manage the loading // of views in any way they see fit for their application. $path = Event::first(static::loader, array($bundle, $view)); if (!is_null($path)) { return $path; } throw new \Exception("View [{$view}] doesn't exist."); }
public static function controller($controllers, $defaults = 'index', $https = null) { foreach ((array) $controllers as $identifier) { list($bundle, $controller) = Bundle::parse($identifier); $controller = str_replace('.', '/', $controller); $root = Bundle::option($bundle, 'handles'); if (ends_with($controller, 'home')) { static::root($identifier, $controller, $root); } $wildcards = static::repeat('(:any?)', static::$segments); $pattern = trim("{$root}/{$controller}/{$wildcards}", '/'); $uses = "{$identifier}@(:1)"; $attributes = compact('uses', 'defaults', 'https'); static::register('*', $pattern, $attributes); } }
protected static function convention($action, $parameters) { list($bundle, $action) = Bundle::parse($action); $bundle = Bundle::get($bundle); $root = $bundle['handles'] ?: ''; $parameters = implode('/', $parameters); $uri = $root . '/' . str_replace(array('.', '@'), '/', $action); $uri = static::to(str_finish($uri, '/') . $parameters); return trim($uri, '/'); }