PHP Bundle::start方法代码示例

 /**
  * Call a filter or set of filters.
  *
  * @param  array   $collections
  * @param  array   $pass
  * @param  bool    $override
  * @return mixed
  */
 public static function run($collections, $pass = array(), $override = false)
 {
     foreach ($collections as $collection) {
         foreach ($collection->filters as $filter) {
             list($filter, $parameters) = $collection->get($filter);
             // We will also go ahead and start the bundle for the developer. This allows
             // the developer to specify bundle filters on routes without starting the
             // bundle manually, and performance is improved since the bundle is only
             // started when needed.
             Bundle::start(Bundle::name($filter));
             if (!isset(static::$filters[$filter])) {
                 continue;
             }
             $callback = static::$filters[$filter];
             // Parameters may be passed into filters by specifying the list of parameters
             // as an array, or by registering a Closure which will return the array of
             // parameters. If parameters are present, we will merge them with the
             // parameters that were given to the method.
             $response = call_user_func_array($callback, array_merge($pass, $parameters));
             // "Before" filters may override the request cycle. For example, an auth
             // filter may redirect a user to a login view if they are not logged in.
             // Because of this, we will return the first filter response if
             // overriding is enabled for the filter collections
             if (!is_null($response) and $override) {
                 return $response;
             }
         }
     }
 }

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

 /**
  * Run a CLI task with the given arguments.
  *
  * <code>
  *		// Call the migrate artisan task
  *		Command::run(array('migrate'));
  *
  *		// Call the migrate task with some arguments
  *		Command::run(array('migrate:rollback', 'bundle-name'))
  * </code>
  *
  * @param  array  $arguments
  * @return void
  */
 public static function run($arguments = array())
 {
     static::validate($arguments);
     list($bundle, $task, $method) = static::parse($arguments[0]);
     // If the task exists within a bundle, we will start the bundle so that any
     // dependencies can be registered in the application IoC container. If the
     // task is registered in the container,  we'll resolve it.
     if (Bundle::exists($bundle)) {
         Bundle::start($bundle);
     }
     $task = static::resolve($bundle, $task);
     // Once the bundle has been resolved, we'll make sure we could actually
     // find that task, and then verify that the method exists on the task
     // so we can successfully call it without a problem.
     if (is_null($task)) {
         throw new \Exception("Sorry, I can't find that task.");
     }
     if (is_callable(array($task, $method))) {
         $task->{$method}(array_slice($arguments, 1));
     } else {
         throw new \Exception("Sorry, I can't find that method!");
     }
 }

<?php

namespace Laravel\CLI;

defined('DS') or die('No direct script access.');
use Laravel\Bundle;
use Laravel\Config;
use Laravel\Request;
/**
 * Fire up the default bundle. This will ensure any dependencies that
 * need to be registered in the IoC container are registered and that
 * the auto-loader mappings are registered.
 */
Bundle::start(DEFAULT_BUNDLE);
/**
 * The default database connection may be set by specifying a value
 * for the "database" CLI option. This allows migrations to be run
 * conveniently for a test or staging database.
 */
if (!is_null($database = get_cli_option('db'))) {
    Config::set('database.default', $database);
}
/**
 * We will register all of the Laravel provided tasks inside the IoC
 * container so they can be resolved by the task class. This allows
 * us to seamlessly add tasks to the CLI so that the Task class
 * doesn't have to worry about how to resolve core tasks.
 */
require path('sys') . 'cli/dependencies' . EXT;
/**
 * We will wrap the command execution in a try / catch block and

 /**
  * Search the routes for the route matching a method and URI.
  *
  * @param  string   $method
  * @param  string   $uri
  * @return Route
  */
 public static function route($method, $uri)
 {
     Bundle::start($bundle = Bundle::handles($uri));
     $routes = (array) static::method($method);
     // Of course literal route matches are the quickest to find, so we will
     // check for those first. If the destination key exists in the routes
     // array we can just return that route now.
     if (array_key_exists($uri, $routes)) {
         $action = $routes[$uri];
         return new Route($method, $uri, $action);
     }
     // If we can't find a literal match we'll iterate through all of the
     // registered routes to find a matching route based on the route's
     // regular expressions and wildcards.
     if (!is_null($route = static::match($method, $uri))) {
         return $route;
     }
 }

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

 public static function install()
 {
     $database_settings = Config::get("database.connections.default");
     $core_modules = self::get_core_modules_list();
     require path('sys') . 'cli' . DS . 'dependencies' . EXT;
     $mig = \Laravel\CLI\Command::run(array('migrate:install'));
     if (!empty($core_modules)) {
         //copy every module to the bundles folder
         foreach ($core_modules as $module => $module_path) {
             static::migrate($module);
         }
         Bundle::register('modules');
         Bundle::start('modules');
         foreach ($core_modules as $module => $module_path) {
             $mod = \Modules\Module::make($module)->is_valid();
             $new_bundle = new \Modules\Model\Module();
             $new_bundle->name = $mod->name;
             $new_bundle->slug = $mod->slug;
             $new_bundle->description = isset($mod->description) ? $mod->description : '';
             $new_bundle->version = $mod->version;
             $new_bundle->is_frontend = isset($mod->is_frontend) ? $mod->is_frontend : 0;
             $new_bundle->is_backend = isset($mod->is_backend) ? $mod->is_backend : 0;
             $new_bundle->is_core = isset($mod->is_core) ? 1 : 0;
             $new_bundle->required = $mod->decode('required');
             $new_bundle->recommended = $mod->decode('recommended');
             $new_bundle->options = $mod->decode('options');
             $new_bundle->roles = $mod->decode('roles');
             $new_bundle->menu = $mod->decode('menu');
             $new_bundle->enabled = 1;
             $new_bundle->save();
         }
         Bundle::disable('modules');
         foreach ($core_modules as $module => $module_path) {
             static::schema('install', $module);
             //
             // Publish module assets if any
             //
             static::publish($module);
         }
     }
     return true;
 }

 /**
  * Create a new HelpSpot Migration instance.
  *
  * @return void
  */
 public function __construct()
 {
     Bundle::start('doctrine');
     $this->em = IoC::resolve('doctrine::manager');
     $this->sm = $this->em->getConnection()->getSchemaManager();
 }

 public static function route($method, $uri)
 {
     Bundle::start($bundle = Bundle::handles($uri));
     $routes = (array) static::method($method);
     if (array_key_exists($uri, $routes)) {
         $action = $routes[$uri];
         return new Route($method, $uri, $action);
     }
     if (!is_null($route = static::match($method, $uri))) {
         return $route;
     }
 }

    #require_once path('sys') . 'error' . EXT;
    Error::exception($e);
});
set_error_handler(function ($code, $error, $file, $line) {
    #require_once path('sys') . 'error' . EXT;
    Error::native($code, $error, $file, $line);
});
register_shutdown_function(function () {
    #require_once path('sys') . 'error' . EXT;
    Error::shutdown();
});
error_reporting(-1);
Bundle::start(DEFAULT_BUNDLE);
foreach (Bundle::$bundles as $bundle => $config) {
    if ($config['auto']) {
        Bundle::start($bundle);
    }
}
Router::register('*', '(:all)', function () {
    return Event::first('404');
});
$uri = URI::current();
$languages = Config::get('application.languages', array());
$languages[] = Config::get('application.language');
foreach ($languages as $language) {
    if (preg_match("#^{$language}(?:\$|/)#i", $uri)) {
        Config::set('application.language', $language);
        $uri = trim(substr($uri, strlen($language)), '/');
        break;
    }
}