[5.4] Allow routes to be registered fluently

src/Illuminate/Foundation/Http/Kernel.php

@@ -98,7 +98,7 @@ public function __construct(Application $app, Router $router)
         }
 
         foreach ($this->routeMiddleware as $key => $middleware) {
-            $router->middleware($key, $middleware);
+            $router->aliasMiddleware($key, $middleware);
         }
     }
 

src/Illuminate/Routing/ControllerDispatcher.php

@@ -44,7 +44,7 @@ public function dispatch(Route $route, $controller, $method)
             return $controller->callAction($method, $parameters);
         }
 
-        return call_user_func_array([$controller, $method], $parameters);
+        return $controller->{$method}(...array_values($parameters));
     }
 
     /**

src/Illuminate/Routing/ResourceRegistrar.php

@@ -196,7 +196,13 @@ protected function getResourceAction($resource, $controller, $method, $options)
     {
         $name = $this->getResourceName($resource, $method, $options);
 
-        return ['as' => $name, 'uses' => $controller.'@'.$method];
+        $action = ['as' => $name, 'uses' => $controller.'@'.$method];
+
+        if (isset($options['middleware'])) {
+            $action['middleware'] = $options['middleware'];
+        }
+
+        return $action;
     }
 
     /**

src/Illuminate/Routing/Route.php

@@ -132,10 +132,9 @@ public function __construct($methods, $uri, $action)
     /**
      * Run the route action and return the response.
      *
-     * @param  \Illuminate\Http\Request  $request
      * @return mixed
      */
-    public function run(Request $request)
+    public function run()
     {
         $this->container = $this->container ?: new Container;
 

src/Illuminate/Routing/RouteRegistrar.php

@@ -0,0 +1,168 @@
+<?php
+
+namespace Illuminate\Routing;
+
+use Closure;
+use BadMethodCallException;
+
+class RouteRegistrar
+{
+    /**
+     * The router instance.
+     *
+     * @var \Illuminate\Routing\Router
+     */
+    protected $router;
+
+    /**
+     * The attributes to pass on to the router.
+     *
+     * @var array
+     */
+    protected $attributes = [];
+
+    /**
+     * The methods to dynamically pass through to the router.
+     *
+     * @var array
+     */
+    protected $passthru = [
+        'get', 'post', 'put', 'patch', 'delete', 'options', 'any',
+    ];
+
+    /**
+     * The attributes that can be set through this class.
+     *
+     * @var array
+     */
+    protected $allowedAttributes = [
+        'as', 'domain', 'middleware', 'name', 'namespace', 'prefix',
+    ];
+
+    /**
+     * The attributes that are aliased.
+     *
+     * @var array
+     */
+    protected $aliases = [
+        'name' => 'as',
+    ];
+
+    /**
+     * Create a new route registrar instance.
+     *
+     * @param  \Illuminate\Routing\Router  $router
+     * @return void
+     */
+    public function __construct(Router $router)
+    {
+        $this->router = $router;
+    }
+
+    /**
+     * Set the value for a given attribute.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @return $this
+     */
+    public function attribute($key, $value)
+    {
+        $this->attributes[array_get($this->aliases, $key, $key)] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Route a resource to a controller.
+     *
+     * @param  string  $name
+     * @param  string  $controller
+     * @param  array  $options
+     * @return void
+     */
+    public function resource($name, $controller, array $options = [])
+    {
+        $this->router->resource($name, $controller, $this->attributes + $options);
+    }
+
+    /**
+     * Create a route group with shared attributes.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function group($callback)
+    {
+        $this->router->group($this->attributes, $callback);
+    }
+
+    /**
+     * Register a new route with the given verbs.
+     *
+     * @param  array|string  $methods
+     * @param  string  $uri
+     * @param  \Closure|array|string|null  $action
+     * @return \Illuminate\Routing\Route
+     */
+    public function match($methods, $uri, $action = null)
+    {
+        return $this->router->match($methods, $uri, $this->compileAction($action));
+    }
+
+    /**
+     * Register a new route with the router.
+     *
+     * @param  string  $method
+     * @param  string  $uri
+     * @param  \Closure|array|string|null  $action
+     * @return \Illuminate\Routing\Route
+     */
+    protected function registerRoute($method, $uri, $action = null)
+    {
+        if (! is_array($action)) {
+            $action = array_merge($this->attributes, $action ? ['uses' => $action] : []);
+        }
+
+        return $this->router->{$method}($uri, $this->compileAction($action));
+    }
+
+    /**
+     * Compile the action into an array including the attributes.
+     *
+     * @param  \Closure|array|string|null  $action
+     * @return array
+     */
+    protected function compileAction($action)
+    {
+        if (is_null($action)) {
+            return $this->attributes;
+        }
+
+        if (is_string($action) || $action instanceof Closure) {
+            $action = ['uses' => $action];
+        }
+
+        return array_merge($this->attributes, $action);
+    }
+
+    /**
+     * Dynamically handle calls into the route registrar.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return \Illuminate\Routing\Route|$this
+     */
+    public function __call($method, $parameters)
+    {
+        if (in_array($method, $this->passthru)) {
+            return $this->registerRoute($method, ...$parameters);
+        }
+
+        if (in_array($method, $this->allowedAttributes)) {
+            return $this->attribute($method, $parameters[0]);
+        }
+
+        throw new BadMethodCallException("Method [{$method}] does not exist.");
+    }
+}

src/Illuminate/Routing/Router.php

@@ -21,7 +21,9 @@
 
 class Router implements RegistrarContract, BindingRegistrar
 {
-    use Macroable;
+    use Macroable {
+        __call as macroCall;
+    }
 
     /**
      * The event dispatcher instance.
@@ -640,7 +642,7 @@ protected function runRouteWithinStack(Route $route, Request $request)
                         ->through($middleware)
                         ->then(function ($request) use ($route) {
                             return $this->prepareResponse(
-                                $request, $route->run($request)
+                                $request, $route->run()
                             );
                         });
     }
@@ -846,7 +848,7 @@ public function getMiddleware()
      * @param  string  $class
      * @return $this
      */
-    public function middleware($name, $class)
+    public function aliasMiddleware($name, $class)
     {
         $this->middleware[$name] = $class;
 
@@ -1223,4 +1225,20 @@ public function getPatterns()
     {
         return $this->patterns;
     }
+
+    /**
+     * 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);
+        }
+
+        return (new RouteRegistrar($this))->attribute($method, $parameters[0]);
+    }
 }

tests/Auth/AuthorizesResourcesTest.php

@@ -61,7 +61,7 @@ protected function assertHasMiddleware($controller, $method, $middleware)
     {
         $router = new Router(new Illuminate\Events\Dispatcher);
 
-        $router->middleware('can', 'AuthorizesResourcesMiddleware');
+        $router->aliasMiddleware('can', 'AuthorizesResourcesMiddleware');
         $router->get($method)->uses('AuthorizesResourcesController@'.$method);
 
         $this->assertEquals(