Router.php
TLDR
The Router.php file is part of the Illuminate\Routing namespace and it contains the code for the Router class.
Methods
get
The get method is used to register a new GET route with the router.
post
The post method is used to register a new POST route with the router.
put
The put method is used to register a new PUT route with the router.
patch
The patch method is used to register a new PATCH route with the router.
delete
The delete method is used to register a new DELETE route with the router.
options
The options method is used to register a new OPTIONS route with the router.
any
The any method is used to register a new route that responds to all verbs.
fallback
The fallback method is used to register a new fallback route with the router.
redirect
The redirect method is used to create a redirect from one URI to another.
permanentRedirect
The permanentRedirect method is used to create a permanent redirect from one URI to another.
view
The view method is used to register a new route that returns a view.
match
The match method is used to register a new route with the given verbs.
resources
The resources method is used to register a group of resource controllers.
resource
The resource method is used to route a resource to a controller.
apiResources
The apiResources method is used to register a group of API resource controllers.
apiResource
The apiResource method is used to route an API resource to a controller.
singletons
The singletons method is used to register a group of singleton resource controllers.
singleton
The singleton method is used to route a singleton resource to a controller.
apiSingletons
The apiSingletons method is used to register a group of API singleton resource controllers.
apiSingleton
The apiSingleton method is used to route an API singleton resource to a controller.
group
The group method is used to create a route group with shared attributes.
addRoute
The addRoute method is used to add a route to the underlying route collection.
addWhereClausesToRoute
The addWhereClausesToRoute method is used to add the necessary where clauses to the route based on its initial registration.
createRoute
The createRoute method is used to create a new route instance.
newRoute
The newRoute method is used to create a new Route object.
prefix
The prefix method is used to prefix the given URI with the last prefix.
loadRoutes
The loadRoutes method is used to load the provided routes.
getLastGroupPrefix
The getLastGroupPrefix method is used to get the prefix from the last group on the stack.
updateGroupStack
The updateGroupStack method is used to update the group stack with the given attributes.
mergeWithLastGroup
The mergeWithLastGroup method is used to merge the given array with the last group stack.
runRoute
The runRoute method is used to run the given route within a Stack "onion" instance.
runRouteWithinStack
The runRouteWithinStack method is used to run the given route within a Stack "onion" instance.
gatherRouteMiddleware
The gatherRouteMiddleware method is used to gather the middleware for the given route with resolved class names.
resolveMiddleware
The resolveMiddleware method is used to resolve a flat array of middleware classes from the provided array.
sortMiddleware
The sortMiddleware method is used to sort the given middleware by priority.
prepareResponse
The prepareResponse method is used to create a response instance from the given value.
toResponse
The toResponse method is a static version of prepareResponse.
substituteBindings
The substituteBindings method is used to substitute the route bindings onto the route.
substituteImplicitBindings
The substituteImplicitBindings method is used to substitute the implicit route bindings for the given route.
substituteImplicitBindingsUsing
The substituteImplicitBindingsUsing method is used to register a callback to run after implicit bindings are substituted.
performBinding
The performBinding method is used to call the binding callback for the given key.
matched
The matched method is used to register a route matched event listener.
getMiddleware
The getMiddleware method is used to get all of the defined middleware short-hand names.
aliasMiddleware
The aliasMiddleware method is used to register a short-hand name for a middleware.
hasMiddlewareGroup
The hasMiddlewareGroup method is used to check if a middlewareGroup with the given name exists.
getMiddlewareGroups
The getMiddlewareGroups method is used to get all of the defined middleware groups.
middlewareGroup
The middlewareGroup method is used to register a group of middleware.
prependMiddlewareToGroup
The prependMiddlewareToGroup method is used to add a middleware to the beginning of a middleware group.
pushMiddlewareToGroup
The pushMiddlewareToGroup method is used to add a middleware to the end of a middleware group.
removeMiddlewareFromGroup
The removeMiddlewareFromGroup method is used to remove the given middleware from the specified group.
flushMiddlewareGroups
The flushMiddlewareGroups method is used to flush the router's middleware groups.
bind
The bind method is used to add a new route parameter binder.
model
The model method is used to register a model binder for a wildcard.
getBindingCallback
The getBindingCallback method is used to get the binding callback for a given binding.
getPatterns
The getPatterns method is used to get the global "where" patterns.
pattern
The pattern method is used to set a global where pattern on all routes.
patterns
The patterns method is used to set a group of global where patterns on all routes.
hasGroupStack
The hasGroupStack method is used to determine if the router currently has a group stack.
getGroupStack
The getGroupStack method is used to get the current group stack for the router.
input
The input method is used to get a route parameter for the current route.
getCurrentRequest
The getCurrentRequest method is used to get the request currently being dispatched.
getCurrentRoute
The getCurrentRoute method is used to get the currently dispatched route instance.
current
The current method is used to get the currently dispatched route instance.
has
The has method is used to check if a route with the given name exists.
currentRouteName
The currentRouteName method is used to get the current route name.
is
The is method is an alias for the currentRouteNamed method.
currentRouteNamed
The currentRouteNamed method is used to determine if the current route matches a pattern.
uses
The uses method is an alias for the currentRouteUses method.
currentRouteUses
The currentRouteUses method is used to determine if the current route action matches a given action.
substituteBindings
The substituteBindings method is used to substitute the route bindings onto the route.
substituteImplicitBindings
The substituteImplicitBindings method is used to substitute the implicit route bindings for the given route.
substituteImplicitBindingsUsing
The substituteImplicitBindingsUsing method is used to register a callback to run after implicit bindings are substituted.
prepareResponse
The prepareResponse method is used to create a response instance from the given value.
setContainer
The setContainer method is used to set the container instance used by the router.
Classes
Class 1: Router
The Router class is responsible for managing the routing functionality in the Illuminate framework. It handles registering routes, dispatching requests to the appropriate route, and generating URLs for named routes.
<?php
namespace Illuminate\Routing;
use ArrayObject;
use Closure;
use Illuminate\Container\Container;
use Illuminate\Contracts\Events\Dispatcher;
use Illuminate\Contracts\Routing\BindingRegistrar;
use Illuminate\Contracts\Routing\Registrar as RegistrarContract;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Contracts\Support\Responsable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Routing\Events\PreparingResponse;
use Illuminate\Routing\Events\ResponsePrepared;
use Illuminate\Routing\Events\RouteMatched;
use Illuminate\Routing\Events\Routing;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
use Illuminate\Support\Traits\Macroable;
use JsonSerializable;
use Psr\Http\Message\ResponseInterface as PsrResponseInterface;
use ReflectionClass;
use stdClass;
use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
/**
* @mixin \Illuminate\Routing\RouteRegistrar
*/
class Router implements BindingRegistrar, RegistrarContract
{
use Macroable {
__call as macroCall;
}
/**
* The event dispatcher instance.
*
* @var \Illuminate\Contracts\Events\Dispatcher
*/
protected $events;
/**
* The IoC container instance.
*
* @var \Illuminate\Container\Container
*/
protected $container;
/**
* The route collection instance.
*
* @var \Illuminate\Routing\RouteCollectionInterface
*/
protected $routes;
/**
* The currently dispatched route instance.
*
* @var \Illuminate\Routing\Route|null
*/
protected $current;
/**
* The request currently being dispatched.
*
* @var \Illuminate\Http\Request
*/
protected $currentRequest;
/**
* All of the short-hand keys for middlewares.
*
* @var array
*/
protected $middleware = [];
/**
* All of the middleware groups.
*
* @var array
*/
protected $middlewareGroups = [];
/**
* The priority-sorted list of middleware.
*
* Forces the listed middleware to always be in the given order.
*
* @var array
*/
public $middlewarePriority = [];
/**
* The registered route value binders.
*
* @var array
*/
protected $binders = [];
/**
* The globally available parameter patterns.
*
* @var array
*/
protected $patterns = [];
/**
* The route group attribute stack.
*
* @var array
*/
protected $groupStack = [];
/**
* The registered custom implicit binding callback.
*
* @var array
*/
protected $implicitBindingCallback;
/**
* All of the verbs supported by the router.
*
* @var string[]
*/
public static $verbs = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];
/**
* Create a new Router instance.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @param \Illuminate\Container\Container|null $container
* @return void
*/
public function __construct(Dispatcher $events, Container $container = null)
{
$this->events = $events;
$this->routes = new RouteCollection;
$this->container = $container ?: new Container;
}
/**
* Register a new GET route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function get($uri, $action = null)
{
return $this->addRoute(['GET', 'HEAD'], $uri, $action);
}
/**
* Register a new POST route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function post($uri, $action = null)
{
return $this->addRoute('POST', $uri, $action);
}
/**
* Register a new PUT route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function put($uri, $action = null)
{
return $this->addRoute('PUT', $uri, $action);
}
/**
* Register a new PATCH route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function patch($uri, $action = null)
{
return $this->addRoute('PATCH', $uri, $action);
}
/**
* Register a new DELETE route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function delete($uri, $action = null)
{
return $this->addRoute('DELETE', $uri, $action);
}
/**
* Register a new OPTIONS route with the router.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function options($uri, $action = null)
{
return $this->addRoute('OPTIONS', $uri, $action);
}
/**
* Register a new route responding to all verbs.
*
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function any($uri, $action = null)
{
return $this->addRoute(self::$verbs, $uri, $action);
}
/**
* Register a new fallback route with the router.
*
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function fallback($action)
{
$placeholder = 'fallbackPlaceholder';
return $this->addRoute(
'GET', "{{$placeholder}}", $action
)->where($placeholder, '.*')->fallback();
}
/**
* Create a redirect from one URI to another.
*
* @param string $uri
* @param string $destination
* @param int $status
* @return \Illuminate\Routing\Route
*/
public function redirect($uri, $destination, $status = 302)
{
return $this->any($uri, '\Illuminate\Routing\RedirectController')
->defaults('destination', $destination)
->defaults('status', $status);
}
/**
* Create a permanent redirect from one URI to another.
*
* @param string $uri
* @param string $destination
* @return \Illuminate\Routing\Route
*/
public function permanentRedirect($uri, $destination)
{
return $this->redirect($uri, $destination, 301);
}
/**
* Register a new route that returns a view.
*
* @param string $uri
* @param string $view
* @param array $data
* @param int|array $status
* @param array $headers
* @return \Illuminate\Routing\Route
*/
public function view($uri, $view, $data = [], $status = 200, array $headers = [])
{
return $this->match(['GET', 'HEAD'], $uri, '\Illuminate\Routing\ViewController')
->setDefaults([
'view' => $view,
'data' => $data,
'status' => is_array($status) ? 200 : $status,
'headers' => is_array($status) ? $status : $headers,
]);
}
/**
* Register a new route with the given verbs.
*
* @param array|string $methods
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function match($methods, $uri, $action = null)
{
return $this->addRoute(array_map('strtoupper', (array) $methods), $uri, $action);
}
/**
* Register an array of resource controllers.
*
* @param array $resources
* @param array $options
* @return void
*/
public function resources(array $resources, array $options = [])
{
foreach ($resources as $name => $controller) {
$this->resource($name, $controller, $options);
}
}
/**
* Route a resource to a controller.
*
* @param string $name
* @param string $controller
* @param array $options
* @return \Illuminate\Routing\PendingResourceRegistration
*/
public function resource($name, $controller, array $options = [])
{
if ($this->container && $this->container->bound(ResourceRegistrar::class)) {
$registrar = $this->container->make(ResourceRegistrar::class);
} else {
$registrar = new ResourceRegistrar($this);
}
return new PendingResourceRegistration(
$registrar, $name, $controller, $options
);
}
/**
* Register an array of API resource controllers.
*
* @param array $resources
* @param array $options
* @return void
*/
public function apiResources(array $resources, array $options = [])
{
foreach ($resources as $name => $controller) {
$this->apiResource($name, $controller, $options);
}
}
/**
* Route an API resource to a controller.
*
* @param string $name
* @param string $controller
* @param array $options
* @return \Illuminate\Routing\PendingResourceRegistration
*/
public function apiResource($name, $controller, array $options = [])
{
$only = ['index', 'show', 'store', 'update', 'destroy'];
if (isset($options['except'])) {
$only = array_diff($only, (array) $options['except']);
}
return $this->resource($name, $controller, array_merge([
'only' => $only,
], $options));
}
/**
* Register an array of singleton resource controllers.
*
* @param array $singletons
* @param array $options
* @return void
*/
public function singletons(array $singletons, array $options = [])
{
foreach ($singletons as $name => $controller) {
$this->singleton($name, $controller, $options);
}
}
/**
* Route a singleton resource to a controller.
*
* @param string $name
* @param string $controller
* @param array $options
* @return \Illuminate\Routing\PendingSingletonResourceRegistration
*/
public function singleton($name, $controller, array $options = [])
{
if ($this->container && $this->container->bound(ResourceRegistrar::class)) {
$registrar = $this->container->make(ResourceRegistrar::class);
} else {
$registrar = new ResourceRegistrar($this);
}
return new PendingSingletonResourceRegistration(
$registrar, $name, $controller, $options
);
}
/**
* Register an array of API singleton resource controllers.
*
* @param array $singletons
* @param array $options
* @return void
*/
public function apiSingletons(array $singletons, array $options = [])
{
foreach ($singletons as $name => $controller) {
$this->apiSingleton($name, $controller, $options);
}
}
/**
* Route an API singleton resource to a controller.
*
* @param string $name
* @param string $controller
* @param array $options
* @return \Illuminate\Routing\PendingSingletonResourceRegistration
*/
public function apiSingleton($name, $controller, array $options = [])
{
$only = ['store', 'show', 'update', 'destroy'];
if (isset($options['except'])) {
$only = array_diff($only, (array) $options['except']);
}
return $this->singleton($name, $controller, array_merge([
'only' => $only,
], $options));
}
/**
* Create a route group with shared attributes.
*
* @param array $attributes
* @param \Closure|array|string $routes
* @return $this
*/
public function group(array $attributes, $routes)
{
foreach (Arr::wrap($routes) as $groupRoutes) {
$this->updateGroupStack($attributes);
// Once we have updated the group stack, we'll load the provided routes and
// merge in the group's attributes when the routes are created. After we
// have created the routes, we will pop the attributes off the stack.
$this->loadRoutes($groupRoutes);
array_pop($this->groupStack);
}
return $this;
}
/**
* Update the group stack with the given attributes.
*
* @param array $attributes
* @return void
*/
protected function updateGroupStack(array $attributes)
{
if ($this->hasGroupStack()) {
$attributes = $this->mergeWithLastGroup($attributes);
}
$this->groupStack[] = $attributes;
}
/**
* Merge the given array with the last group stack.
*
* @param array $new
* @param bool $prependExistingPrefix
* @return array
*/
public function mergeWithLastGroup($new, $prependExistingPrefix = true)
{
return RouteGroup::merge($new, end($this->groupStack), $prependExistingPrefix);
}
/**
* Load the provided routes.
*
* @param \Closure|string $routes
* @return void
*/
protected function loadRoutes($routes)
{
if ($routes instanceof Closure) {
$routes($this);
} else {
(new RouteFileRegistrar($this))->register($routes);
}
}
/**
* Get the prefix from the last group on the stack.
*
* @return string
*/
public function getLastGroupPrefix()
{
if ($this->hasGroupStack()) {
$last = end($this->groupStack);
return $last['prefix'] ?? '';
}
return '';
}
/**
* Add a route to the underlying route collection.
*
* @param array|string $methods
* @param string $uri
* @param array|string|callable|null $action
* @return \Illuminate\Routing\Route
*/
public function addRoute($methods, $uri, $action)
{
return $this->routes->add($this->createRoute($methods, $uri, $action));
}
/**
* Create a new route instance.
*
* @param array|string $methods
* @param string $uri
* @param mixed $action
* @return \Illuminate\Routing\Route
*/
protected function createRoute($methods, $uri, $action)
{
// If the route is routing to a controller we will parse the route action into
// an acceptable array format before registering it and creating this route
// instance itself. We need to build the Closure that will call this out.
if ($this->actionReferencesController($action)) {
$action = $this->convertToControllerAction($action);
}
$route = $this->newRoute(
$methods, $this->prefix($uri), $action
);
// If we have groups that need to be merged, we will merge them now after this
// route has already been created and is ready to go. After we're done with
// the merge we will be ready to return the route back out to the caller.
if ($this->hasGroupStack()) {
$this->mergeGroupAttributesIntoRoute($route);
}
$this->addWhereClausesToRoute($route);
return $route;
}
/**
* Determine if the action is routing to a controller.
*
* @param mixed $action
* @return bool
*/
protected function actionReferencesController($action)
{
if (! $action instanceof Closure) {
return is_string($action) || (isset($action['uses']) && is_string($action['uses']));
}
return false;
}
/**
* Add a controller based route action to the action array.
*
* @param array|string $action
* @return array
*/
protected function convertToControllerAction($action)
{
if (is_string($action)) {
$action = ['uses' => $action];
}
// Here we'll merge any group "controller" and "uses" statements if necessary so that
// the action has the proper clause for this property. Then, we can simply set the
// name of this controller on the action plus return the action array for usage.
if ($this->hasGroupStack()) {
$action['uses'] = $this->prependGroupController($action['uses']);
$action['uses'] = $this->prependGroupNamespace($action['uses']);
}
// Here we will set this controller name on the action array just so we always
// have a copy of it for reference if we need it. This can be used while we
// search for a controller name or do some other type of fetch operation.
$action['controller'] = $action['uses'];
return $action;
}
/**
* Prepend the last group namespace onto the use clause.
*
* @param string $class
* @return string
*/
protected function prependGroupNamespace($class)
{
$group = end($this->groupStack);
return isset($group['namespace']) && ! str_starts_with($class, '\\') && ! str_starts_with($class, $group['namespace'])
? $group['namespace'].'\\'.$class : $class;
}
/**
* Prepend the last group controller onto the use clause.
*
* @param string $class
* @return string
*/
protected function prependGroupController($class)
{
$group = end($this->groupStack);
if (! isset($group['controller'])) {
return $class;
}
if (class_exists($class)) {
return $class;
}
if (str_contains($class, '@')) {
return $class;
}
return $group['controller'].'@'.$class;
}
/**
* Create a new Route object.
*
* @param array|string $methods
* @param string $uri
* @param mixed $action
* @return \Illuminate\Routing\Route
*/
public function newRoute($methods, $uri, $action)
{
return (new Route($methods, $uri, $action))
->setRouter($this)
->setContainer($this->container);
}
/**
* Prefix the given URI with the last prefix.
*
* @param string $uri
* @return string
*/
protected function prefix($uri)
{
return trim(trim($this->getLastGroupPrefix(), '/').'/'.trim($uri, '/'), '/') ?: '/';
}
/**
* Add the necessary where clauses to the route based on its initial registration.
*
* @param \Illuminate\Routing\Route $route
* @return \Illuminate\Routing\Route
*/
protected function addWhereClausesToRoute($route)
{
$route->where(array_merge(
$this->patterns, $route->getAction()['where'] ?? []
));
return $route;
}
/**
* Merge the group stack with the controller action.
*
* @param \Illuminate\Routing\Route $route
* @return void
*/
protected function mergeGroupAttributesIntoRoute($route)
{
$route->setAction($this->mergeWithLastGroup(
$route->getAction(),
$prependExistingPrefix = false
));
}
/**
* Return the response returned by the given route.
*
* @param string $name
* @return \Symfony\Component\HttpFoundation\Response
*/
public function respondWithRoute($name)
{
$route = tap($this->routes->getByName($name))->bind($this->currentRequest);
return $this->runRoute($this->currentRequest, $route);
}
/**
* Dispatch the request to the application.
*
* @param \Illuminate\Http\Request $request
* @return \Symfony\Component\HttpFoundation\Response
*/
public function dispatch(Request $request)
{
$this->currentRequest = $request;
return $this->dispatchToRoute($request);
}
/**
* Dispatch the request to a route and return the response.
*
* @param \Illuminate\Http\Request $request
* @return \Symfony\Component\HttpFoundation\Response
*/
public function dispatchToRoute(Request $request)
{
return $this->runRoute($request, $this->findRoute($request));
}
/**
* Find the route matching a given request.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Routing\Route
*/
protected function findRoute($request)
{
$this->events->dispatch(new Routing($request));
$this->current = $route = $this->routes->match($request);
$route->setContainer($this->container);
$this->container->instance(Route::class, $route);
return $route;
}
/**
* Return the response for the given route.
*
* @param \Illuminate\Http\Request $request
* @param \Illuminate\Routing\Route $route
* @return \Symfony\Component\HttpFoundation\Response
*/
protected function runRoute(Request $request, Route $route)
{
$request->setRouteResolver(fn () => $route);
$this->events->dispatch(new RouteMatched($route, $request));
return $this->prepareResponse($request,
$this->runRouteWithinStack($route, $request)
);
}
/**
* Run the given route within a Stack "onion" instance.
*
* @param \Illuminate\Routing\Route $route
* @param \Illuminate\Http\Request $request
* @return mixed
*/
protected function runRouteWithinStack(Route $route, Request $request)
{
$shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
$this->container->make('middleware.disable') === true;
$middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
return (new Pipeline($this->container))
->send($request)
->through($middleware)
->then(fn ($request) => $this->prepareResponse(
$request, $route->run()
));
}
/**
* Gather the middleware for the given route with resolved class names.
*
* @param \Illuminate\Routing\Route $route
* @return array
*/
public function gatherRouteMiddleware(Route $route)
{
return $this->resolveMiddleware($route->gatherMiddleware(), $route->excludedMiddleware());
}
/**
* Resolve a flat array of middleware classes from the provided array.
*
* @param array $middleware
* @param array $excluded
* @return array
*/
public function resolveMiddleware(array $middleware, array $excluded = [])
{
$excluded = collect($excluded)->map(function ($name) {
return (array) MiddlewareNameResolver::resolve($name, $this->middleware, $this->middlewareGroups);
})->flatten()->values()->all();
$middleware = collect($middleware)->map(function ($name) {
return (array) MiddlewareNameResolver::resolve($name, $this->middleware, $this->middlewareGroups);
})->flatten()->reject(function ($name) use ($excluded) {
if (empty($excluded)) {
return false;
}
if ($name instanceof Closure) {
return false;
}
if (in_array($name, $excluded, true)) {
return true;
}
if (! class_exists($name)) {
return false;
}
$reflection = new ReflectionClass($name);
return collect($excluded)->contains(
fn ($exclude) => class_exists($exclude) && $reflection->isSubclassOf($exclude)
);
})->values();
return $this->sortMiddleware($middleware);
}
/**
* Sort the given middleware by priority.
*
* @param \Illuminate\Support\Collection $middlewares
* @return array
*/
protected function sortMiddleware(Collection $middlewares)
{
return (new SortedMiddleware($this->middlewarePriority, $middlewares))->all();
}
/**
* Create a response instance from the given value.
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @param mixed $response
* @return \Symfony\Component\HttpFoundation\Response
*/
public function prepareResponse($request, $response)
{
$this->events->dispatch(new PreparingResponse($request, $response));
return tap(static::toResponse($request, $response), function ($response) use ($request) {
$this->events->dispatch(new ResponsePrepared($request, $response));
});
}
/**
* Static version of prepareResponse.
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @param mixed $response
* @return \Symfony\Component\HttpFoundation\Response
*/
public static function toResponse($request, $response)
{
if ($response instanceof Responsable) {
$response = $response->toResponse($request);
}
if ($response instanceof PsrResponseInterface) {
$response = (new HttpFoundationFactory)->createResponse($response);
} elseif ($response instanceof Model && $response->wasRecentlyCreated) {
$response = new JsonResponse($response, 201);
} elseif ($response instanceof Stringable) {
$response = new Response($response->__toString(), 200, ['Content-Type' => 'text/html']);
} elseif (! $response instanceof SymfonyResponse &&
($response instanceof Arrayable ||
$response instanceof Jsonable ||
$response instanceof ArrayObject ||
$response instanceof JsonSerializable ||
$response instanceof stdClass ||
is_array($response))) {
$response = new JsonResponse($response);
} elseif (! $response instanceof SymfonyResponse) {
$response = new Response($response, 200, ['Content-Type' => 'text/html']);
}
if ($response->getStatusCode() === Response::HTTP_NOT_MODIFIED) {
$response->setNotModified();
}
return $response->prepare($request);
}
/**
* Substitute the route bindings onto the route.
*
* @param \Illuminate\Routing\Route $route
* @return \Illuminate\Routing\Route
*
* @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
* @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
*/
public function substituteBindings($route)
{
foreach ($route->parameters() as $key => $value) {
if (isset($this->binders[$key])) {
$route->setParameter($key, $this->performBinding($key, $value, $route));
}
}
return $route;
}
/**
* Substitute the implicit route bindings for the given route.
*
* @param \Illuminate\Routing\Route $route
* @return void
*
* @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
* @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
*/
public function substituteImplicitBindings($route)
{
$default = fn () => ImplicitRouteBinding::resolveForRoute($this->container, $route);
return call_user_func(
$this->implicitBindingCallback ?? $default, $this->container, $route, $default
);
}
/**
* Register a callback to to run after implicit bindings are substituted.
*
* @param callable $callback
* @return $this
*/
public function substituteImplicitBindingsUsing($callback)
{
$this->implicitBindingCallback = $callback;
return $this;
}
/**
* Call the binding callback for the given key.
*
* @param string $key
* @param string $value
* @param \Illuminate\Routing\Route $route
* @return mixed
*
* @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
*/
protected function performBinding($key, $value, $route)
{
return call_user_func($this->binders[$key], $value, $route);
}
/**
* Register a route matched event listener.
*
* @param string|callable $callback
* @return void
*/
public function matched($callback)
{
$this->events->listen(Events\RouteMatched::class, $callback);
}
/**
* Get all of the defined middleware short-hand names.
*
* @return array
*/
public function getMiddleware()
{
return $this->middleware;
}
/**
* Register a short-hand name for a middleware.
*
* @param string $name
* @param string $class
* @return $this
*/
public function aliasMiddleware($name, $class)
{
$this->middleware[$name] = $class;
return $this;
}
/**
* Check if a middlewareGroup with the given name exists.
*
* @param string $name
* @return bool
*/
public function hasMiddlewareGroup($name)
{
return array_key_exists($name, $this->middlewareGroups);
}
/**
* Get all of the defined middleware groups.
*
* @return array
*/
public function getMiddlewareGroups()
{
return $this->middlewareGroups;
}
/**
* Register a group of middleware.
*
* @param string $name
* @param array $middleware
* @return $this
*/
public function middlewareGroup($name, array $middleware)
{
$this->middlewareGroups[$name] = $middleware;
return $this;
}
/**
* Add a middleware to the beginning of a middleware group.
*
* If the middleware is already in the group, it will not be added again.
*
* @param string $group
* @param string $middleware
* @return $this
*/
public function prependMiddlewareToGroup($group, $middleware)
{
if (isset($this->middlewareGroups[$group]) && ! in_array($middleware, $this->middlewareGroups[$group])) {
array_unshift($this->middlewareGroups[$group], $middleware);
}
return $this;
}
/**
* Add a middleware to the end of a middleware group.
*
* If the middleware is already in the group, it will not be added again.
*
* @param string $group
* @param string $middleware
* @return $this
*/
public function pushMiddlewareToGroup($group, $middleware)
{
if (! array_key_exists($group, $this->middlewareGroups)) {
$this->middlewareGroups[$group] = [];
}
if (! in_array($middleware, $this->middlewareGroups[$group])) {
$this->middlewareGroups[$group][] = $middleware;
}
return $this;
}
/**
* Remove the given middleware from the specified group.
*
* @param string $group
* @param string $middleware
* @return $this
*/
public function removeMiddlewareFromGroup($group, $middleware)
{
if (! $this->hasMiddlewareGroup($group)) {
return $this;
}
$reversedMiddlewaresArray = array_flip($this->middlewareGroups[$group]);
if (! array_key_exists($middleware, $reversedMiddlewaresArray)) {
return $this;
}
$middlewareKey = $reversedMiddlewaresArray[$middleware];
unset($this->middlewareGroups[$group][$middlewareKey]);
return $this;
}
/**
* Flush the router's middleware groups.
*
* @return $this
*/
public function flushMiddlewareGroups()
{
$this->middlewareGroups = [];
return $this;
}
/**
* Add a new route parameter binder.
*
* @param string $key
* @param string|callable $binder
* @return void
*/
public function bind($key, $binder)
{
$this->binders[str_replace('-', '_', $key)] = RouteBinding::forCallback(
$this->container, $binder
);
}
/**
* Register a model binder for a wildcard.
*
* @param string $key
* @param string $class
* @param \Closure|null $callback
* @return void
*/
public function model($key, $class, Closure $callback = null)
{
$this->bind($key, RouteBinding::forModel($this->container, $class, $callback));
}
/**
* Get the binding callback for a given binding.
*
* @param string $key
* @return \Closure|null
*/
public function getBindingCallback($key)
{
if (isset($this->binders[$key = str_replace('-', '_', $key)])) {
return $this->binders[$key];
}
}
/**
* Get the global "where" patterns.
*
* @return array
*/
public function getPatterns()
{
return $this->patterns;
}
/**
* Set a global where pattern on all routes.
*
* @param string $key
* @param string $pattern
* @return void
*/
public function pattern($key, $pattern)
{
$this->patterns[$key] = $pattern;
}
/**
* Set a group of global where patterns on all routes.
*
* @param array $patterns
* @return void
*/
public function patterns($patterns)
{
foreach ($patterns as $key => $pattern) {
$this->pattern($key, $pattern);
}
}
/**
* Determine if the router currently has a group stack.
*
* @return bool
*/
public function hasGroupStack()
{
return ! empty($this->groupStack);
}
/**
* Get the current group stack for the router.
*
* @return array
*/
public function getGroupStack()
{
return $this->groupStack;
}
/**
* Get a route parameter for the current route.
*
* @param string $key
* @param string|null $default
* @return mixed
*/
public function input($key, $default = null)
{
return $this->current()->parameter($key, $default);
}
/**
* Get the request currently being dispatched.
*
* @return \Illuminate\Http\Request
*/
public function getCurrentRequest()
{
return $this->currentRequest;
}
/**
* Get the currently dispatched route instance.
*
* @return \Illuminate\Routing\Route|null
*/
public function getCurrentRoute()
{
return $this->current();
}
/**
* Get the currently dispatched route instance.
*
* @return \Illuminate\Routing\Route|null
*/
public function current()
{
return $this->current;
}
/**
* Check if a route with the given name exists.
*
* @param string|array $name
* @return bool
*/
public function has($name)
{
$names = is_array($name) ? $name : func_get_args();
foreach ($names as $value) {
if (! $this->routes->hasNamedRoute($value)) {
return false;
}
}
return true;
}
/**
* Get the current route name.
*
* @return string|null
*/
public function currentRouteName()
{
return $this->current() ? $this->current()->getName() : null;
}
/**
* Alias for the "currentRouteNamed" method.
*
* @param mixed ...$patterns
* @return bool
*/
public function is(...$patterns)
{
return $this->currentRouteNamed(...$patterns);
}
/**
* Determine if the current route matches a pattern.
*
* @param mixed ...$patterns
* @return bool
*/
public function currentRouteNamed(...$patterns)
{
return $this->current() && $this->current()->named(...$patterns);
}
/**
* Get the current route action.
*
* @return string|null
*/
public function currentRouteAction()
{
if ($this->current()) {
return $this->current()->getAction()['controller'] ?? null;
}
}
/**
* Alias for the "currentRouteUses" method.
*
* @param array ...$patterns
* @return bool
*/
public function uses(...$patterns)
{
foreach ($patterns as $pattern) {
if (Str::is($pattern, $this->currentRouteAction())) {
return true;
}
}
return false;
}
/**
* Determine if the current route action matches a given action.
*
* @param string $action
* @return bool
*/
public function currentRouteUses($action)
{
return $this->currentRouteAction() == $action;
}
/**
* Set the unmapped global resource parameters to singular.
*
* @param bool $singular
* @return void
*/
public function singularResourceParameters($singular = true)
{
ResourceRegistrar::singularParameters($singular);
}
/**
* Set the global resource parameter mapping.
*
* @param array $parameters
* @return void
*/
public function resourceParameters(array $parameters = [])
{
ResourceRegistrar::setParameters($parameters);
}
/**
* Get or set the verbs used in the resource URIs.
*
* @param array $verbs
* @return array|null
*/
public function resourceVerbs(array $verbs = [])
{
return ResourceRegistrar::verbs($verbs);
}
/**
* Get the underlying route collection.
*
* @return \Illuminate\Routing\RouteCollectionInterface
*/
public function getRoutes()
{
return $this->routes;
}
/**
* Set the route collection instance.
*
* @param \Illuminate\Routing\RouteCollection $routes
* @return void
*/
public function setRoutes(RouteCollection $routes)
{
foreach ($routes as $route) {
$route->setRouter($this)->setContainer($this->container);
}
$this->routes = $routes;
$this->container->instance('routes', $this->routes);
}
/**
* Set the compiled route collection instance.
*
* @param array $routes
* @return void
*/
public function setCompiledRoutes(array $routes)
{
$this->routes = (new CompiledRouteCollection($routes['compiled'], $routes['attributes']))
->setRouter($this)
->setContainer($this->container);
$this->container->instance('routes', $this->routes);
}
/**
* Remove any duplicate middleware from the given array.
*
* @param array $middleware
* @return array
*/
public static function uniqueMiddleware(array $middleware)
{
$seen = [];
$result = [];
foreach ($middleware as $value) {
$key = \is_object($value) ? \spl_object_id($value) : $value;
if (! isset($seen[$key])) {
$seen[$key] = true;
$result[] = $value;
}
}
return $result;
}
/**
* Set the container instance used by the router.
*
* @param \Illuminate\Container\Container $container
* @return $this
*/
public function setContainer(Container $container)
{
$this->container = $container;
return $this;
}
/**
* Dynamically handle calls into the router instance.
*
* @param string $method
* @param array $parameters
* @return mixed
*/
public function __call($method, $parameters)
{
if (static::hasMacro($method)) {
return $this->macroCall($method, $parameters);
}
if ($method === 'middleware') {
return (new RouteRegistrar($this))->attribute($method, is_array($parameters[0]) ? $parameters[0] : $parameters);
}
if ($method !== 'where' && Str::startsWith($method, 'where')) {
return (new RouteRegistrar($this))->{$method}(...$parameters);
}
return (new RouteRegistrar($this))->attribute($method, array_key_exists(0, $parameters) ? $parameters[0] : true);
}
}