PHP Bundle::parse方法代码示例

 /**
  * 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, '/');
 }