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