codeburnerframework / routing

src/Exceptions/NotFoundException.php

Indentation +26 added lines, -26 removed lines

@@ -20,34 +20,34 @@
 class NotFoundException extends \Exception
 {
 
-    /**
-     * The HTTP method from request.
-     *
-     * @var string
-     */
-    public $requested_method;
+	/**
+	 * The HTTP method from request.
+	 *
+	 * @var string
+	 */
+	public $requested_method;
 
-    /**
-     * The requested URi.
-     *
-     * @var string
-     */
-    public $requested_uri;
+	/**
+	 * The requested URi.
+	 *
+	 * @var string
+	 */
+	public $requested_uri;
     
-    /**
-     * Exception constructor.
-     *
-     * @param string  $requested_method The request HTTP method.
-     * @param string  $requested_uri    The request URi.
-     * @param string  $message          The exception error message.
-     * @param integer $code             The exception error code.
-     */
-    public function __construct($requested_method, $requested_uri, $message = null, $code = 405)
-    {
-        $this->requested_method = $requested_method;
-        $this->requested_uri    = $requested_uri;
+	/**
+	 * Exception constructor.
+	 *
+	 * @param string  $requested_method The request HTTP method.
+	 * @param string  $requested_uri    The request URi.
+	 * @param string  $message          The exception error message.
+	 * @param integer $code             The exception error code.
+	 */
+	public function __construct($requested_method, $requested_uri, $message = null, $code = 405)
+	{
+		$this->requested_method = $requested_method;
+		$this->requested_uri    = $requested_uri;
 
-        parent::__construct($message, $code);
-    }
+		parent::__construct($message, $code);
+	}
 	
 }

src/Exceptions/BadRouteException.php

Indentation +5 added lines, -5 removed lines

@@ -20,10 +20,10 @@
 class BadRouteException extends \Exception
 {
 
-    const UNSUPPORTED_HTTP_METHOD = "";
-    const OPTIONAL_SEGMENTS_ON_MIDDLE = "Optional segments can only occur at the end of a route.";
-    const UNCLOSED_OPTIONAL_SEGMENTS = "Number of opening [ and closing ] does not match.";
-    const EMPTY_OPTIONAL_PARTS = "Empty optional part.";
-    const BAD_DISPATCH_STRATEGY = "The route specific dispatch strategy is wrong. Check the class name.";
+	const UNSUPPORTED_HTTP_METHOD = "";
+	const OPTIONAL_SEGMENTS_ON_MIDDLE = "Optional segments can only occur at the end of a route.";
+	const UNCLOSED_OPTIONAL_SEGMENTS = "Number of opening [ and closing ] does not match.";
+	const EMPTY_OPTIONAL_PARTS = "Empty optional part.";
+	const BAD_DISPATCH_STRATEGY = "The route specific dispatch strategy is wrong. Check the class name.";
 
 }

src/Exceptions/MethodNotAllowedException.php

Indentation +55 added lines, -55 removed lines

@@ -20,66 +20,66 @@
 class MethodNotAllowedException extends \Exception
 {
 
-    /**
-     * The HTTP method from request.
-     *
-     * @var string
-     */
-    public $requested_method;
+	/**
+	 * The HTTP method from request.
+	 *
+	 * @var string
+	 */
+	public $requested_method;
 
-    /**
-     * The requested URi.
-     *
-     * @var string
-     */
-    public $requested_uri;
+	/**
+	 * The requested URi.
+	 *
+	 * @var string
+	 */
+	public $requested_uri;
 
-    /**
-     * All the allowed HTTP methods and routes for the request.
-     *
-     * @var array
-     */
-    public $allowed_methods;
+	/**
+	 * All the allowed HTTP methods and routes for the request.
+	 *
+	 * @var array
+	 */
+	public $allowed_methods;
 	
-    /**
-     * Exception constructor.
-     *
-     * @param string  $requested_method The request HTTP method.
-     * @param string  $requested_uri    The request URi.
-     * @param array   $allowed_methods  All the allowed HTTP methods and routes for the request.
-     * @param string  $message          The exception error message.
-     * @param integer $code             The exception error code.
-     */
-    public function __construct($requested_method, $requested_uri, array $allowed_methods, $message = null, $code = 405)
-    {
-        $this->requested_method = $requested_method;
-        $this->requested_uri    = $requested_uri;
-        $this->allowed_methods  = $allowed_methods;
+	/**
+	 * Exception constructor.
+	 *
+	 * @param string  $requested_method The request HTTP method.
+	 * @param string  $requested_uri    The request URi.
+	 * @param array   $allowed_methods  All the allowed HTTP methods and routes for the request.
+	 * @param string  $message          The exception error message.
+	 * @param integer $code             The exception error code.
+	 */
+	public function __construct($requested_method, $requested_uri, array $allowed_methods, $message = null, $code = 405)
+	{
+		$this->requested_method = $requested_method;
+		$this->requested_uri    = $requested_uri;
+		$this->allowed_methods  = $allowed_methods;
 
-        parent::__construct($message, $code);
-    }
+		parent::__construct($message, $code);
+	}
 
-    /**
-     * Verify if the given HTTP method is allowed for the request.
-     *
-     * @param string An HTTP method
-     * @return bool
-     */
-    public function can($method)
-    {
-        return isset($this->allowed_methods[strtoupper($method)]);
-    }
+	/**
+	 * Verify if the given HTTP method is allowed for the request.
+	 *
+	 * @param string An HTTP method
+	 * @return bool
+	 */
+	public function can($method)
+	{
+		return isset($this->allowed_methods[strtoupper($method)]);
+	}
 
-    /**
-     * The HTTP specification requires that a 405 Method Not Allowed response include the 
-     * Allow: header to detail available methods for the requested resource.
-     *
-     * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html section 14.7
-     * @return string
-     */
-    public function allowed()
-    {
-        return implode(', ', array_keys($this->allowed_methods));
-    }
+	/**
+	 * The HTTP specification requires that a 405 Method Not Allowed response include the 
+	 * Allow: header to detail available methods for the requested resource.
+	 *
+	 * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html section 14.7
+	 * @return string
+	 */
+	public function allowed()
+	{
+		return implode(', ', array_keys($this->allowed_methods));
+	}
 
 }

src/Dispatcher.php

Indentation +288 added lines, -288 removed lines

@@ -27,294 +27,294 @@
 class Dispatcher
 {
 
-    /**
-     * The action dispatch strategy object.
-     *
-     * @var string
-     */
-
-    protected $strategy;
-
-    /**
-     * The route collection.
-     *
-     * @var Collection
-     */
-
-    protected $collection;
-
-    /**
-     * Define a basepath to all routes.
-     *
-     * @var string
-     */
-
-    protected $basepath;
-
-    /**
-     * Construct the route dispatcher.
-     *
-     * @param Collection $collection The collection to save routes.
-     * @param string     $basepath   Define a URI prefix that must be excluded on matches.
-     * @param string     $strategy   The strategy to dispatch matched route action.
-     */
-
-    public function __construct(Collection $collection, $basepath = '', $strategy = 'Codeburner\Router\Strategies\UriDispatcherStrategy')
-    {
-        $this->collection = $collection;
-        $this->basepath   = (string) $basepath;
-        $this->strategy   = $strategy;
-    }
-
-    /**
-     * Find and dispatch a route based on the request http method and uri.
-     *
-     * @param string $method The HTTP method of the request, that should be GET, POST, PUT, PATCH or DELETE.
-     * @param string $uri    The URi of request.
-     *
-     * @throws NotFoundException
-     * @throws MethodNotAllowedException
-     * @return mixed The request response
-     */
-
-    public function dispatch($method, $uri)
-    {
-        if ($route = $this->match($method, $uri)) {
-            $strategy = $this->getRouteStrategy($route['strategy']);
-            return $strategy->dispatch($route['action'], $route['params']);
-        }
-
-        $this->dispatchNotFoundRoute($method, $uri);
-    }
-
-    /**
-     * Find a route that matches the given arguments.
-     * 
-     * @param string $method The HTTP method of the request, that should be GET, POST, PUT, PATCH or DELETE.
-     * @param string $uri    The URi of request.
-     *
-     * @return array|false
-     */
-
-    public function match($method, $uri)
-    {
-        $method = $this->getHttpMethod($method);
-        $uri = $this->getUriPath($uri);
-
-        if ($route = $this->collection->getStaticRoute($method, $uri)) {
-            return $route;
-        }
-
-        return $this->matchDynamicRoute($this->collection->getDynamicRoutes($method, $uri), $uri);
-    }
-
-    /**
-     * Verify if the given http method is valid.
-     *
-     * @param  int|string $method
-     * @throws Exception
-     * @return int
-     */
-
-    protected function getHttpMethod($method)
-    {
-        $methods = Mapper::getMethods();
-
-        if (in_array($method, $methods)) {
-            return $method;
-        }
-
-        if (array_key_exists($method = strtolower($method), array_map('strtolower', $methods))) {
-            return $methods[$method];
-        }
-
-        throw new Exception('The HTTP method given to the route dispatcher is not supported or is incorrect.');
-    }
-
-    /**
-     * Get only the path of a given url or uri.
-     *
-     * @param string $uri The given URL
-     *
-     * @throws Exception
-     * @return string
-     */
-
-    protected function getUriPath($uri)
-    {
-        $path = parse_url(substr(strstr(';' . $uri, ';' . $this->basepath), strlen(';' . $this->basepath)), PHP_URL_PATH);
-
-        if ($path === false) {
-            throw new Exception('Seriously malformed URL passed to route dispatcher.');
-        }
-
-        return $path;
-    }
-
-    /**
-     * Find and return the request dynamic route based on the compiled data and uri.
-     *
-     * @param array  $routes All the compiled data from dynamic routes.
-     * @param string $uri    The URi of request.
-     *
-     * @return array|false If the request match an array with the action and parameters will be returned
-     *                     otherwise a false will.
-     */
-
-    protected function matchDynamicRoute($routes, $uri)
-    {
-        foreach ($routes as $route) {
-            if (!preg_match($route['regex'], $uri, $matches)) {
-                continue;
-            }
-
-            list($routeAction, $routeParams, $strategy) = $route['map'][count($matches)];
-
-            $params = [];
-            $i = 0;
-
-            foreach ($routeParams as $name) {
-                $params[$name] = $matches[++$i];
-            }
-
-            return ['action' => $this->resolveDynamicRouteAction($routeAction, $params), 'params' => $params, 'strategy' => $strategy];
-        }
-
-        return false;
-    }
-
-    /**
-     * Generate an HTTP error request with method not allowed or not found.
-     *
-     * @param string $method The HTTP method that must not be checked.
-     * @param string $uri    The URi of request.
-     *
-     * @throws NotFoundException
-     * @throws MethodNotAllowedException
-     */
-
-    protected function dispatchNotFoundRoute($method, $uri)
-    {
-        $dm = $dm = [];
-
-        if ($sm = ($this->checkStaticRouteInOtherMethods($method, $uri)) 
-                || $dm = ($this->checkDynamicRouteInOtherMethods($method, $uri))) {
-            throw new MethodNotAllowedException($method, $uri, array_merge((array) $sm, (array) $dm));
-        }
-
-        throw new NotFoundException($method, $uri);
-    }
-
-    /**
-     * Verify if a static route match in another method than the requested.
-     *
-     * @param string $jump_method The HTTP method that must not be checked
-     * @param string $uri         The URi that must be matched.
-     *
-     * @return array
-     */
-
-    protected function checkStaticRouteInOtherMethods($jump_method, $uri)
-    {
-        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
-            return (bool) $this->collection->getStaticRoute($method, $uri);
-        });
-    }
-
-    /**
-     * Verify if a dynamic route match in another method than the requested.
-     *
-     * @param string $jump_method The HTTP method that must not be checked
-     * @param string $uri         The URi that must be matched.
-     *
-     * @return array
-     */
-
-    protected function checkDynamicRouteInOtherMethods($jump_method, $uri)
-    {
-        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
-            return (bool) $this->matchDynamicRoute($this->collection->getDynamicRoutes($method, $uri), $uri);
-        });
-    }
-
-    /**
-     * Resolve dynamic action, inserting route parameters at requested points.
-     *
-     * @param string|array|\closure $action The route action.
-     * @param array                $params The dynamic routes parameters.
-     *
-     * @return string
-     */
-
-    protected function resolveDynamicRouteAction($action, $params)
-    {
-        if (is_array($action)) {
-            foreach ($action as $key => $value) {
-                if (is_string($value)) {
-                    $action[$key] = str_replace(['{', '}'], '', str_replace(array_keys($params), array_values($params), $value));
-                }
-            }
-        }
-
-        return $action;
-    }
-
-    /**
-     * @return Collection
-     */
-
-    public function getCollection()
-    {
-        return $this->collection;
-    }
-
-    /**
-     * @return StrategyInterface
-     */
-
-    public function getStrategy()
-    {
-        return $this->strategy;
-    }
-
-    /**
-     * @return string
-     */
-
-    public function getBasePath()
-    {
-        return $this->basepath;
-    }
-
-    /**
-     * Set a new basepath, this will be a prefix that must be excluded in every
-     * requested URi.
-     *
-     * @param string $basepath The new basepath
-     */
+	/**
+	 * The action dispatch strategy object.
+	 *
+	 * @var string
+	 */
+
+	protected $strategy;
+
+	/**
+	 * The route collection.
+	 *
+	 * @var Collection
+	 */
+
+	protected $collection;
+
+	/**
+	 * Define a basepath to all routes.
+	 *
+	 * @var string
+	 */
+
+	protected $basepath;
+
+	/**
+	 * Construct the route dispatcher.
+	 *
+	 * @param Collection $collection The collection to save routes.
+	 * @param string     $basepath   Define a URI prefix that must be excluded on matches.
+	 * @param string     $strategy   The strategy to dispatch matched route action.
+	 */
+
+	public function __construct(Collection $collection, $basepath = '', $strategy = 'Codeburner\Router\Strategies\UriDispatcherStrategy')
+	{
+		$this->collection = $collection;
+		$this->basepath   = (string) $basepath;
+		$this->strategy   = $strategy;
+	}
+
+	/**
+	 * Find and dispatch a route based on the request http method and uri.
+	 *
+	 * @param string $method The HTTP method of the request, that should be GET, POST, PUT, PATCH or DELETE.
+	 * @param string $uri    The URi of request.
+	 *
+	 * @throws NotFoundException
+	 * @throws MethodNotAllowedException
+	 * @return mixed The request response
+	 */
+
+	public function dispatch($method, $uri)
+	{
+		if ($route = $this->match($method, $uri)) {
+			$strategy = $this->getRouteStrategy($route['strategy']);
+			return $strategy->dispatch($route['action'], $route['params']);
+		}
+
+		$this->dispatchNotFoundRoute($method, $uri);
+	}
+
+	/**
+	 * Find a route that matches the given arguments.
+	 * 
+	 * @param string $method The HTTP method of the request, that should be GET, POST, PUT, PATCH or DELETE.
+	 * @param string $uri    The URi of request.
+	 *
+	 * @return array|false
+	 */
+
+	public function match($method, $uri)
+	{
+		$method = $this->getHttpMethod($method);
+		$uri = $this->getUriPath($uri);
+
+		if ($route = $this->collection->getStaticRoute($method, $uri)) {
+			return $route;
+		}
+
+		return $this->matchDynamicRoute($this->collection->getDynamicRoutes($method, $uri), $uri);
+	}
+
+	/**
+	 * Verify if the given http method is valid.
+	 *
+	 * @param  int|string $method
+	 * @throws Exception
+	 * @return int
+	 */
+
+	protected function getHttpMethod($method)
+	{
+		$methods = Mapper::getMethods();
+
+		if (in_array($method, $methods)) {
+			return $method;
+		}
+
+		if (array_key_exists($method = strtolower($method), array_map('strtolower', $methods))) {
+			return $methods[$method];
+		}
+
+		throw new Exception('The HTTP method given to the route dispatcher is not supported or is incorrect.');
+	}
+
+	/**
+	 * Get only the path of a given url or uri.
+	 *
+	 * @param string $uri The given URL
+	 *
+	 * @throws Exception
+	 * @return string
+	 */
+
+	protected function getUriPath($uri)
+	{
+		$path = parse_url(substr(strstr(';' . $uri, ';' . $this->basepath), strlen(';' . $this->basepath)), PHP_URL_PATH);
+
+		if ($path === false) {
+			throw new Exception('Seriously malformed URL passed to route dispatcher.');
+		}
+
+		return $path;
+	}
+
+	/**
+	 * Find and return the request dynamic route based on the compiled data and uri.
+	 *
+	 * @param array  $routes All the compiled data from dynamic routes.
+	 * @param string $uri    The URi of request.
+	 *
+	 * @return array|false If the request match an array with the action and parameters will be returned
+	 *                     otherwise a false will.
+	 */
+
+	protected function matchDynamicRoute($routes, $uri)
+	{
+		foreach ($routes as $route) {
+			if (!preg_match($route['regex'], $uri, $matches)) {
+				continue;
+			}
+
+			list($routeAction, $routeParams, $strategy) = $route['map'][count($matches)];
+
+			$params = [];
+			$i = 0;
+
+			foreach ($routeParams as $name) {
+				$params[$name] = $matches[++$i];
+			}
+
+			return ['action' => $this->resolveDynamicRouteAction($routeAction, $params), 'params' => $params, 'strategy' => $strategy];
+		}
+
+		return false;
+	}
+
+	/**
+	 * Generate an HTTP error request with method not allowed or not found.
+	 *
+	 * @param string $method The HTTP method that must not be checked.
+	 * @param string $uri    The URi of request.
+	 *
+	 * @throws NotFoundException
+	 * @throws MethodNotAllowedException
+	 */
+
+	protected function dispatchNotFoundRoute($method, $uri)
+	{
+		$dm = $dm = [];
+
+		if ($sm = ($this->checkStaticRouteInOtherMethods($method, $uri)) 
+				|| $dm = ($this->checkDynamicRouteInOtherMethods($method, $uri))) {
+			throw new MethodNotAllowedException($method, $uri, array_merge((array) $sm, (array) $dm));
+		}
+
+		throw new NotFoundException($method, $uri);
+	}
+
+	/**
+	 * Verify if a static route match in another method than the requested.
+	 *
+	 * @param string $jump_method The HTTP method that must not be checked
+	 * @param string $uri         The URi that must be matched.
+	 *
+	 * @return array
+	 */
+
+	protected function checkStaticRouteInOtherMethods($jump_method, $uri)
+	{
+		return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
+			return (bool) $this->collection->getStaticRoute($method, $uri);
+		});
+	}
+
+	/**
+	 * Verify if a dynamic route match in another method than the requested.
+	 *
+	 * @param string $jump_method The HTTP method that must not be checked
+	 * @param string $uri         The URi that must be matched.
+	 *
+	 * @return array
+	 */
+
+	protected function checkDynamicRouteInOtherMethods($jump_method, $uri)
+	{
+		return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
+			return (bool) $this->matchDynamicRoute($this->collection->getDynamicRoutes($method, $uri), $uri);
+		});
+	}
+
+	/**
+	 * Resolve dynamic action, inserting route parameters at requested points.
+	 *
+	 * @param string|array|\closure $action The route action.
+	 * @param array                $params The dynamic routes parameters.
+	 *
+	 * @return string
+	 */
+
+	protected function resolveDynamicRouteAction($action, $params)
+	{
+		if (is_array($action)) {
+			foreach ($action as $key => $value) {
+				if (is_string($value)) {
+					$action[$key] = str_replace(['{', '}'], '', str_replace(array_keys($params), array_values($params), $value));
+				}
+			}
+		}
+
+		return $action;
+	}
+
+	/**
+	 * @return Collection
+	 */
+
+	public function getCollection()
+	{
+		return $this->collection;
+	}
+
+	/**
+	 * @return StrategyInterface
+	 */
+
+	public function getStrategy()
+	{
+		return $this->strategy;
+	}
+
+	/**
+	 * @return string
+	 */
+
+	public function getBasePath()
+	{
+		return $this->basepath;
+	}
+
+	/**
+	 * Set a new basepath, this will be a prefix that must be excluded in every
+	 * requested URi.
+	 *
+	 * @param string $basepath The new basepath
+	 */
     
-    public function setBasePath($basepath)
-    {
-        $this->basepath = $basepath;
-    }
-
-    /**
-     * @param string $strategy
-     * @throws BadRouteException
-     * @return \Codeburner\Router\Strategies\DispatcherStrategyInterface
-     */
-
-    private function getRouteStrategy($strategy)
-    {
-        if ($strategy === null) {
-            return new $this->strategy;
-        }
-
-        if (class_exists($strategy)) {
-            return new $strategy;
-        }
-
-        throw new BadRouteException(BadRouteException::BAD_DISPATCH_STRATEGY);
-    }
+	public function setBasePath($basepath)
+	{
+		$this->basepath = $basepath;
+	}
+
+	/**
+	 * @param string $strategy
+	 * @throws BadRouteException
+	 * @return \Codeburner\Router\Strategies\DispatcherStrategyInterface
+	 */
+
+	private function getRouteStrategy($strategy)
+	{
+		if ($strategy === null) {
+			return new $this->strategy;
+		}
+
+		if (class_exists($strategy)) {
+			return new $strategy;
+		}
+
+		throw new BadRouteException(BadRouteException::BAD_DISPATCH_STRATEGY);
+	}
 
 }

Spacing +2 added lines, -2 removed lines

@@ -216,7 +216,7 @@ 
 
     protected function checkStaticRouteInOtherMethods($jump_method, $uri)
     {
-        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
+        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function($method) use ($uri) {
             return (bool) $this->collection->getStaticRoute($method, $uri);
         });
     }
@@ -232,7 +232,7 @@ 
 
     protected function checkDynamicRouteInOtherMethods($jump_method, $uri)
     {
-        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function ($method) use ($uri) {
+        return array_filter(array_diff_key(Mapper::getMethods(), [$jump_method => true]), function($method) use ($uri) {
             return (bool) $this->matchDynamicRoute($this->collection->getDynamicRoutes($method, $uri), $uri);
         });
     }

src/Mapper.php

Indentation +730 added lines, -730 removed lines

@@ -21,409 +21,409 @@ 
 class Mapper
 {
 
-    /**
-     * Implement support to variations of the set method that abstract the
-     * HTTP method from the parameters.
-     */
+	/**
+	 * Implement support to variations of the set method that abstract the
+	 * HTTP method from the parameters.
+	 */
 
-    use HttpMethodMapper;
+	use HttpMethodMapper;
 
-    /**
-     * Insert support for mapping a resource.
-     *
-     * @see https://github.com/codeburnerframework/router/#resources
-     */
+	/**
+	 * Insert support for mapping a resource.
+	 *
+	 * @see https://github.com/codeburnerframework/router/#resources
+	 */
 
-    use ResourceMapper;
+	use ResourceMapper;
 
-    /**
-     * Add support to abstract a entire controller registration.
-     *
-     * @see https://github.com/codeburnerframework/router/#controllers
-     */
+	/**
+	 * Add support to abstract a entire controller registration.
+	 *
+	 * @see https://github.com/codeburnerframework/router/#controllers
+	 */
 
-    use ControllerMapper;
+	use ControllerMapper;
 
-    /**
-     * The regex used to parse all the routes patterns. For more information
-     * contact the author of this class.
-     *
-     * @var string
-     */
+	/**
+	 * The regex used to parse all the routes patterns. For more information
+	 * contact the author of this class.
+	 *
+	 * @var string
+	 */
 
-    const DYNAMIC_REGEX = '\{\s*([\w]*)\s*(?::\s*([^{}]*(?:\{(?-1)\}[^{}]*)*))?\s*\}';
+	const DYNAMIC_REGEX = '\{\s*([\w]*)\s*(?::\s*([^{}]*(?:\{(?-1)\}[^{}]*)*))?\s*\}';
     
-    /**
-     * The default pattern that will be used to match a dynamic segment of a route.
-     *
-     * @var string
-     */
-
-    const DEFAULT_PLACEHOLDER_REGEX = '([^/]+)';
-
-    /**
-     * All the supported http methods and they zones. An http method zone is the range
-     * of numeric indexes that routes separated by the number of slashes can be registered.
-     * By default the range begins on 10 and jumps 10 in every method, this give a zone
-     * of infinite routes ate 9 slashes or if you prefer, segments.
-     */
-
-    const METHOD_GET    = 100;
-    const METHOD_POST   = 200;
-    const METHOD_PUT    = 300;
-    const METHOD_PATCH  = 400;
-    const METHOD_DELETE = 500;
-
-    /**
-     * An mirror for the constants values in array form for easily iteration and validation.
-     * This will be deprecated soon, with the new support to array in constants of php 7 this static attribute and
-     * the static getter method will be refactored to a constant.
-     *
-     * @var array
-     */
-
-    protected static $methods = [
-        'get'    => self::METHOD_GET,
-        'post'   => self::METHOD_POST,
-        'put'    => self::METHOD_PUT,
-        'patch'  => self::METHOD_PATCH,
-        'delete' => self::METHOD_DELETE
-    ];
+	/**
+	 * The default pattern that will be used to match a dynamic segment of a route.
+	 *
+	 * @var string
+	 */
+
+	const DEFAULT_PLACEHOLDER_REGEX = '([^/]+)';
+
+	/**
+	 * All the supported http methods and they zones. An http method zone is the range
+	 * of numeric indexes that routes separated by the number of slashes can be registered.
+	 * By default the range begins on 10 and jumps 10 in every method, this give a zone
+	 * of infinite routes ate 9 slashes or if you prefer, segments.
+	 */
+
+	const METHOD_GET    = 100;
+	const METHOD_POST   = 200;
+	const METHOD_PUT    = 300;
+	const METHOD_PATCH  = 400;
+	const METHOD_DELETE = 500;
+
+	/**
+	 * An mirror for the constants values in array form for easily iteration and validation.
+	 * This will be deprecated soon, with the new support to array in constants of php 7 this static attribute and
+	 * the static getter method will be refactored to a constant.
+	 *
+	 * @var array
+	 */
+
+	protected static $methods = [
+		'get'    => self::METHOD_GET,
+		'post'   => self::METHOD_POST,
+		'put'    => self::METHOD_PUT,
+		'patch'  => self::METHOD_PATCH,
+		'delete' => self::METHOD_DELETE
+	];
     
-    /**
-     * A set of aliases to regex that can be used in patterns definitions.
-     *
-     * @var array
-     */
-
-    protected $patternWildcards = [
-        'int' => '\d{length}',
-        'integer' => '\d{length}',
-        'string' => '\w{length}',
-        'float' => '[-+]?(\d*[.])?\d{length}',
-        'bool' => '1|0|true|false|yes|no',
-        'boolean' => '1|0|true|false|yes|no'
-    ];
+	/**
+	 * A set of aliases to regex that can be used in patterns definitions.
+	 *
+	 * @var array
+	 */
+
+	protected $patternWildcards = [
+		'int' => '\d{length}',
+		'integer' => '\d{length}',
+		'string' => '\w{length}',
+		'float' => '[-+]?(\d*[.])?\d{length}',
+		'bool' => '1|0|true|false|yes|no',
+		'boolean' => '1|0|true|false|yes|no'
+	];
     
-    /**
-     * The delimiter in the controller/method action espefication.
-     *
-     * @var string
-     */
+	/**
+	 * The delimiter in the controller/method action espefication.
+	 *
+	 * @var string
+	 */
 
-    protected $actionDelimiter = '#';
+	protected $actionDelimiter = '#';
 
-    /**
-     * Hold all the routes without parameters.
-     *
-     * @var array [METHOD => [PATTERN => ROUTE]]
-     */
+	/**
+	 * Hold all the routes without parameters.
+	 *
+	 * @var array [METHOD => [PATTERN => ROUTE]]
+	 */
 
-    protected $statics;
+	protected $statics;
     
-    /**
-     * Routes with parameters to compute.
-     *
-     * @var array [PROCESSED_INDEX => [ROUTE]]
-     */
-
-    protected $dynamics;
-
-    /**
-     * Insert a route into the collection.
-     *
-     * @param int                   $method   The HTTP method zone of route. {GET, POST, PUT, PATCH, DELETE}
-     * @param string                $pattern  The URi that route should match.
-     * @param string|array|\closure $action   The callback for when route is matched.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-
-    public function set($method, $pattern, $action, $strategy = null)
-    {
-        $patterns = $this->parsePatternOptionals($pattern);
-        $action = $this->parseAction($action);
-
-        foreach ($patterns as $pattern) {
-            strpos($pattern, '{') === false ?
-                $this->setStatic($method, $pattern, $action, $strategy) : $this->setDynamic($method, $pattern, $action, $strategy);
-        }
-    }
-
-    /**
-     * Insert a static route into the collection.
-     *
-     * @param string                $method   The HTTP method of route. {GET, POST, PUT, PATCH, DELETE}
-     * @param string                $pattern  The URi that route should match.
-     * @param string|array|\closure $action   The callback for when route is matched.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-
-    protected function setStatic($method, $pattern, $action, $strategy)
-    {
-        $this->statics[$method][$pattern] = [
-            'action'   => $action,
-            'params'   => [],
-            'strategy' => $strategy
-        ];
-    }
-
-    /**
-     * Insert a dynamic route into the collection.
-     *
-     * @param string                $method   The HTTP method of route. {GET, POST, PUT, PATCH, DELETE}
-     * @param string                $pattern  The URi that route should match.
-     * @param string|array|\closure $action   The callback for when route is matched.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-
-    protected function setDynamic($method, $pattern, $action, $strategy)
-    {
-        $index = $this->getDynamicIndex($method, $pattern);
-
-        list($regex, $params) = $this->parsePatternPlaceholders($pattern);
-
-        $this->dynamics[$index][] = [
-            'action'   => $action,
-            'regex'    => $regex,
-            'params'   => $params,
-            'strategy' => $strategy
-        ];
-    }
-
-    /**
-     * Parses the given action to something that can be called.
-     *
-     * @param  string|array|\closure $action  The callback for when route is matched.
-     * @return string|array|\closure
-     */
-
-    protected function parseAction($action)
-    {
-        if (is_string($action)) {
-            return explode($this->actionDelimiter, $action);
-        }
-
-        return $action;
-    }
-
-    /**
-     * Separate routes pattern with optional parts into n new patterns.
-     *
-     * @param string $pattern The route pattern to parse.
-     * @return array
-     */
-
-    protected function parsePatternOptionals($pattern)
-    {
-        $patternWithoutClosingOptionals = rtrim($pattern, ']');
-        $patternOptionalsNumber = strlen($pattern) - strlen($patternWithoutClosingOptionals);
-
-        $segments = preg_split('~' . self::DYNAMIC_REGEX . '(*SKIP)(*F) | \[~x', $patternWithoutClosingOptionals);
-        $this->parseSegmentOptionals($segments, $patternOptionalsNumber, $patternWithoutClosingOptionals);
-
-        return $this->buildPatterns($segments);
-    }
-
-    /**
-     * Parse an route pattern seeking for parameters and making the route regex.
-     *
-     * @param string $pattern The route pattern to be parsed.
-     * @return array 0 => new route regex, 1 => map of parameters names.
-     */
-
-    protected function parsePatternPlaceholders($pattern)
-    {
-        $parameters = [];
-        preg_match_all('~' . self::DYNAMIC_REGEX . '~x', $pattern, $matches, PREG_SET_ORDER);
-
-        foreach ((array) $matches as $key => $match) {
-            $pattern = str_replace($match[0],
-                isset($match[2]) ? $this->getPlaceholderRegex($match[2]) : self::DEFAULT_PLACEHOLDER_REGEX, $pattern);
-            $parameters[$key] = $match[1];
-        }
-
-        return [$pattern, $parameters];
-    }
-
-    /**
-     * Find and replace wildcards in one pattern placeholder.
-     *
-     * @param string $placeholder
-     * @return string
-     */
-
-    protected function getPlaceholderRegex($placeholder)
-    {
-        $strippedPlaceholder = strstr($placeholder, '{', true) ?: $placeholder;
-
-        if (isset($this->patternWildcards[$strippedPlaceholder])) {
-            return '(' . str_replace('{length}', strstr($placeholder, '{') ?: '+', $this->patternWildcards[$strippedPlaceholder]) . ')';
-        }
-
-        return '(' . trim($placeholder) . ')';
-    }
-
-    /**
-     * Parse the pattern seeking for the error and show a more specific message.
-     *
-     * @param array $segments
-     * @param int $patternOptionalsNumber
-     * @param string $patternWithoutClosingOptionals
-     *
-     * @throws Exceptions\BadRouteException With a more specific error message.
-     */
-
-    protected function parseSegmentOptionals(array $segments, $patternOptionalsNumber, $patternWithoutClosingOptionals)
-    {
-        if ($patternOptionalsNumber !== count($segments) - 1) {
-            if (preg_match('~' . self::DYNAMIC_REGEX . '(*SKIP)(*F) | \]~x', $patternWithoutClosingOptionals)) {
-                   throw new Exceptions\BadRouteException(Exceptions\BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
-            } else throw new Exceptions\BadRouteException(Exceptions\BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
-        }
-    }
-
-    /**
-     * Build all the possibles patterns for a set of segments.
-     *
-     * @param array $segments
-     * @throws Exceptions\BadRouteException
-     * @return array
-     */
-
-    protected function buildPatterns(array $segments)
-    {
-        $pattern  = '';
-        $patterns = [];
-
-        foreach ($segments as $n => $segment) {
-            if ($segment === '' && $n !== 0) {
-                throw new Exceptions\BadRouteException(Exceptions\BadRouteException::EMPTY_OPTIONAL_PARTS);
-            }
-
-            $patterns[] = $pattern .= $segment;
-        }
-
-        return $patterns;
-    }
-
-    /**
-     * Group several routes into one unique regex.
-     *
-     * @param  array $routes All the routes that must be grouped
-     * @return array
-     */
-
-    protected function buildGroup($routes)
-    {
-        $map = []; 
-        $regex = [];
-        $groupCount = 0;
-
-        foreach ($routes as $route) {
-            $paramsCount      = count($route['params']);
-            $groupCount       = max($groupCount, $paramsCount) + 1;
-            $regex[]          = $route['regex'] . str_repeat('()', $groupCount - $paramsCount - 1);
-            $map[$groupCount] = [$route['action'], $route['params'], $route['strategy']];
-        }
-
-        return ['regex' => '~^(?|' . implode('|', $regex) . ')$~', 'map' => $map];
-    }
-
-    /**
-     * Generate an index that will hold an especific group of dynamic routes.
-     *
-     * @param int $method The http method index defined by the METHOD_* constants
-     * @param string $pattern
-     *
-     * @return int
-     */
-
-    protected function getDynamicIndex($method, $pattern)
-    {
-        return (int) $method + substr_count($pattern, '/') - 1;
-    }
-
-    /**
-     * Retrieve a specific static route or a false.
-     *
-     * @param int $method The http method index defined by the METHOD_* constants
-     * @param string $pattern
-     *
-     * @return array|false
-     */
-
-    public function getStaticRoute($method, $pattern)
-    {
-        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern])) {
-            return $this->statics[$method][$pattern];
-        }
-
-        return false;
-    }
-
-    /**
-     * Concat all dynamic routes regex for a given method, this speeds up the match.
-     *
-     * @param string $method The http method to search in.
-     * @param string $pattern
-     *
-     * @return array [['regex', 'map' => [0 => action, 1 => params]]]
-     */
-
-    public function getDynamicRoutes($method, $pattern)
-    {
-        $index = $this->getDynamicIndex($method, $pattern);
-
-        if (!isset($this->dynamics[$index])) {
-            return [];
-        }
-
-        $dynamics = $this->dynamics[$index];
-        return array_map([$this, 'buildGroup'], array_chunk($dynamics, round(1 + 3.3 * log(count($dynamics))), true));
-    }
-
-    /**
-     * @return array
-     */
-    public static function getMethods()
-    {
-        return self::$methods;
-    }
-
-    /**
-     * @return array
-     */
-    public function getPatternWildcards()
-    {
-        return $this->patternWildcards;
-    }
-
-    /**
-     * @param string $pattern
-     * @param string $wildcard
-     */
-    public function setPatternWildcard($pattern, $wildcard)
-    {
-        $this->patternWildcards[(string) $pattern] = (string) $wildcard;
-    }
-
-    /**
-     * @return string
-     */
-
-    public function getActionDelimiter()
-    {
-        return $this->actionDelimiter;
-    }
-
-    /**
-     * @param string $delimiter
-     */
-
-    public function setActionDelimiter($delimiter)
-    {
-        $this->actionDelimiter = (string) $delimiter;
-    }
+	/**
+	 * Routes with parameters to compute.
+	 *
+	 * @var array [PROCESSED_INDEX => [ROUTE]]
+	 */
+
+	protected $dynamics;
+
+	/**
+	 * Insert a route into the collection.
+	 *
+	 * @param int                   $method   The HTTP method zone of route. {GET, POST, PUT, PATCH, DELETE}
+	 * @param string                $pattern  The URi that route should match.
+	 * @param string|array|\closure $action   The callback for when route is matched.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+
+	public function set($method, $pattern, $action, $strategy = null)
+	{
+		$patterns = $this->parsePatternOptionals($pattern);
+		$action = $this->parseAction($action);
+
+		foreach ($patterns as $pattern) {
+			strpos($pattern, '{') === false ?
+				$this->setStatic($method, $pattern, $action, $strategy) : $this->setDynamic($method, $pattern, $action, $strategy);
+		}
+	}
+
+	/**
+	 * Insert a static route into the collection.
+	 *
+	 * @param string                $method   The HTTP method of route. {GET, POST, PUT, PATCH, DELETE}
+	 * @param string                $pattern  The URi that route should match.
+	 * @param string|array|\closure $action   The callback for when route is matched.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+
+	protected function setStatic($method, $pattern, $action, $strategy)
+	{
+		$this->statics[$method][$pattern] = [
+			'action'   => $action,
+			'params'   => [],
+			'strategy' => $strategy
+		];
+	}
+
+	/**
+	 * Insert a dynamic route into the collection.
+	 *
+	 * @param string                $method   The HTTP method of route. {GET, POST, PUT, PATCH, DELETE}
+	 * @param string                $pattern  The URi that route should match.
+	 * @param string|array|\closure $action   The callback for when route is matched.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+
+	protected function setDynamic($method, $pattern, $action, $strategy)
+	{
+		$index = $this->getDynamicIndex($method, $pattern);
+
+		list($regex, $params) = $this->parsePatternPlaceholders($pattern);
+
+		$this->dynamics[$index][] = [
+			'action'   => $action,
+			'regex'    => $regex,
+			'params'   => $params,
+			'strategy' => $strategy
+		];
+	}
+
+	/**
+	 * Parses the given action to something that can be called.
+	 *
+	 * @param  string|array|\closure $action  The callback for when route is matched.
+	 * @return string|array|\closure
+	 */
+
+	protected function parseAction($action)
+	{
+		if (is_string($action)) {
+			return explode($this->actionDelimiter, $action);
+		}
+
+		return $action;
+	}
+
+	/**
+	 * Separate routes pattern with optional parts into n new patterns.
+	 *
+	 * @param string $pattern The route pattern to parse.
+	 * @return array
+	 */
+
+	protected function parsePatternOptionals($pattern)
+	{
+		$patternWithoutClosingOptionals = rtrim($pattern, ']');
+		$patternOptionalsNumber = strlen($pattern) - strlen($patternWithoutClosingOptionals);
+
+		$segments = preg_split('~' . self::DYNAMIC_REGEX . '(*SKIP)(*F) | \[~x', $patternWithoutClosingOptionals);
+		$this->parseSegmentOptionals($segments, $patternOptionalsNumber, $patternWithoutClosingOptionals);
+
+		return $this->buildPatterns($segments);
+	}
+
+	/**
+	 * Parse an route pattern seeking for parameters and making the route regex.
+	 *
+	 * @param string $pattern The route pattern to be parsed.
+	 * @return array 0 => new route regex, 1 => map of parameters names.
+	 */
+
+	protected function parsePatternPlaceholders($pattern)
+	{
+		$parameters = [];
+		preg_match_all('~' . self::DYNAMIC_REGEX . '~x', $pattern, $matches, PREG_SET_ORDER);
+
+		foreach ((array) $matches as $key => $match) {
+			$pattern = str_replace($match[0],
+				isset($match[2]) ? $this->getPlaceholderRegex($match[2]) : self::DEFAULT_PLACEHOLDER_REGEX, $pattern);
+			$parameters[$key] = $match[1];
+		}
+
+		return [$pattern, $parameters];
+	}
+
+	/**
+	 * Find and replace wildcards in one pattern placeholder.
+	 *
+	 * @param string $placeholder
+	 * @return string
+	 */
+
+	protected function getPlaceholderRegex($placeholder)
+	{
+		$strippedPlaceholder = strstr($placeholder, '{', true) ?: $placeholder;
+
+		if (isset($this->patternWildcards[$strippedPlaceholder])) {
+			return '(' . str_replace('{length}', strstr($placeholder, '{') ?: '+', $this->patternWildcards[$strippedPlaceholder]) . ')';
+		}
+
+		return '(' . trim($placeholder) . ')';
+	}
+
+	/**
+	 * Parse the pattern seeking for the error and show a more specific message.
+	 *
+	 * @param array $segments
+	 * @param int $patternOptionalsNumber
+	 * @param string $patternWithoutClosingOptionals
+	 *
+	 * @throws Exceptions\BadRouteException With a more specific error message.
+	 */
+
+	protected function parseSegmentOptionals(array $segments, $patternOptionalsNumber, $patternWithoutClosingOptionals)
+	{
+		if ($patternOptionalsNumber !== count($segments) - 1) {
+			if (preg_match('~' . self::DYNAMIC_REGEX . '(*SKIP)(*F) | \]~x', $patternWithoutClosingOptionals)) {
+				   throw new Exceptions\BadRouteException(Exceptions\BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
+			} else throw new Exceptions\BadRouteException(Exceptions\BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+		}
+	}
+
+	/**
+	 * Build all the possibles patterns for a set of segments.
+	 *
+	 * @param array $segments
+	 * @throws Exceptions\BadRouteException
+	 * @return array
+	 */
+
+	protected function buildPatterns(array $segments)
+	{
+		$pattern  = '';
+		$patterns = [];
+
+		foreach ($segments as $n => $segment) {
+			if ($segment === '' && $n !== 0) {
+				throw new Exceptions\BadRouteException(Exceptions\BadRouteException::EMPTY_OPTIONAL_PARTS);
+			}
+
+			$patterns[] = $pattern .= $segment;
+		}
+
+		return $patterns;
+	}
+
+	/**
+	 * Group several routes into one unique regex.
+	 *
+	 * @param  array $routes All the routes that must be grouped
+	 * @return array
+	 */
+
+	protected function buildGroup($routes)
+	{
+		$map = []; 
+		$regex = [];
+		$groupCount = 0;
+
+		foreach ($routes as $route) {
+			$paramsCount      = count($route['params']);
+			$groupCount       = max($groupCount, $paramsCount) + 1;
+			$regex[]          = $route['regex'] . str_repeat('()', $groupCount - $paramsCount - 1);
+			$map[$groupCount] = [$route['action'], $route['params'], $route['strategy']];
+		}
+
+		return ['regex' => '~^(?|' . implode('|', $regex) . ')$~', 'map' => $map];
+	}
+
+	/**
+	 * Generate an index that will hold an especific group of dynamic routes.
+	 *
+	 * @param int $method The http method index defined by the METHOD_* constants
+	 * @param string $pattern
+	 *
+	 * @return int
+	 */
+
+	protected function getDynamicIndex($method, $pattern)
+	{
+		return (int) $method + substr_count($pattern, '/') - 1;
+	}
+
+	/**
+	 * Retrieve a specific static route or a false.
+	 *
+	 * @param int $method The http method index defined by the METHOD_* constants
+	 * @param string $pattern
+	 *
+	 * @return array|false
+	 */
+
+	public function getStaticRoute($method, $pattern)
+	{
+		if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern])) {
+			return $this->statics[$method][$pattern];
+		}
+
+		return false;
+	}
+
+	/**
+	 * Concat all dynamic routes regex for a given method, this speeds up the match.
+	 *
+	 * @param string $method The http method to search in.
+	 * @param string $pattern
+	 *
+	 * @return array [['regex', 'map' => [0 => action, 1 => params]]]
+	 */
+
+	public function getDynamicRoutes($method, $pattern)
+	{
+		$index = $this->getDynamicIndex($method, $pattern);
+
+		if (!isset($this->dynamics[$index])) {
+			return [];
+		}
+
+		$dynamics = $this->dynamics[$index];
+		return array_map([$this, 'buildGroup'], array_chunk($dynamics, round(1 + 3.3 * log(count($dynamics))), true));
+	}
+
+	/**
+	 * @return array
+	 */
+	public static function getMethods()
+	{
+		return self::$methods;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getPatternWildcards()
+	{
+		return $this->patternWildcards;
+	}
+
+	/**
+	 * @param string $pattern
+	 * @param string $wildcard
+	 */
+	public function setPatternWildcard($pattern, $wildcard)
+	{
+		$this->patternWildcards[(string) $pattern] = (string) $wildcard;
+	}
+
+	/**
+	 * @return string
+	 */
+
+	public function getActionDelimiter()
+	{
+		return $this->actionDelimiter;
+	}
+
+	/**
+	 * @param string $delimiter
+	 */
+
+	public function setActionDelimiter($delimiter)
+	{
+		$this->actionDelimiter = (string) $delimiter;
+	}
 
 }
 
@@ -438,84 +438,84 @@ 
 trait HttpMethodMapper
 {
 
-    abstract public function set($method, $pattern, $action, $strategy = null);
-
-    /**
-     * Register a set of routes for they especific http methods.
-     *
-     * @param string                $pattern  The URi pattern that should be matched.
-     * @param string|array|\closure $action   The action that must be executed in case of match.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-
-    public function get($pattern, $action, $strategy = null)
-    {
-        $this->set(Mapper::METHOD_GET, $pattern, $action, $strategy);
-    }
-
-    public function post($pattern, $action, $strategy = null)
-    {
-        $this->set(Mapper::METHOD_POST, $pattern, $action, $strategy);
-    }
-
-    public function put($pattern, $action, $strategy = null)
-    {
-        $this->set(Mapper::METHOD_PUT, $pattern, $action, $strategy);
-    }
-
-    public function patch($pattern, $action, $strategy = null)
-    {
-        $this->set(Mapper::METHOD_PATCH, $pattern, $action, $strategy);
-    }
-
-    public function delete($pattern, $action, $strategy = null)
-    {
-        $this->set(Mapper::METHOD_DELETE, $pattern, $action, $strategy);
-    }
-
-    /**
-     * Register a route into all HTTP methods.
-     *
-     * @param string                $pattern  The URi pattern that should be matched.
-     * @param string|array|\closure $action   The action that must be executed in case of match.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-    public function any($pattern, $action, $strategy = null)
-    {
-        foreach (Mapper::getMethods() as $method) {
-            $this->set($method, $pattern, $action, $strategy);
-        }
-    }
-
-    /**
-     * Register a route into all HTTP methods except by $method.
-     *
-     * @param string                $methods  The method that must be excluded.
-     * @param string                $pattern  The URi pattern that should be matched.
-     * @param string|array|\closure $action   The action that must be executed in case of match.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-    public function except($methods, $pattern, $action, $strategy = null)
-    {
-        foreach (array_diff_key(Mapper::getMethods(), array_flip((array) $methods)) as $method) {
-            $this->set($method, $pattern, $action, $strategy);
-        }
-    }
-
-    /**
-     * Register a route into given HTTP method(s).
-     *
-     * @param string|array          $methods  The method that must be matched.
-     * @param string                $pattern  The URi pattern that should be matched.
-     * @param string|array|\closure $action   The action that must be executed in case of match.
-     * @param string                $strategy The route specific dispatch strategy.
-     */
-    public function match($methods, $pattern, $action, $strategy = null)
-    {
-        foreach (array_intersect_key(Mapper::getMethods(), array_flip((array) $methods)) as $method) {
-            $this->set($method, $pattern, $action, $strategy);
-        }
-    }
+	abstract public function set($method, $pattern, $action, $strategy = null);
+
+	/**
+	 * Register a set of routes for they especific http methods.
+	 *
+	 * @param string                $pattern  The URi pattern that should be matched.
+	 * @param string|array|\closure $action   The action that must be executed in case of match.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+
+	public function get($pattern, $action, $strategy = null)
+	{
+		$this->set(Mapper::METHOD_GET, $pattern, $action, $strategy);
+	}
+
+	public function post($pattern, $action, $strategy = null)
+	{
+		$this->set(Mapper::METHOD_POST, $pattern, $action, $strategy);
+	}
+
+	public function put($pattern, $action, $strategy = null)
+	{
+		$this->set(Mapper::METHOD_PUT, $pattern, $action, $strategy);
+	}
+
+	public function patch($pattern, $action, $strategy = null)
+	{
+		$this->set(Mapper::METHOD_PATCH, $pattern, $action, $strategy);
+	}
+
+	public function delete($pattern, $action, $strategy = null)
+	{
+		$this->set(Mapper::METHOD_DELETE, $pattern, $action, $strategy);
+	}
+
+	/**
+	 * Register a route into all HTTP methods.
+	 *
+	 * @param string                $pattern  The URi pattern that should be matched.
+	 * @param string|array|\closure $action   The action that must be executed in case of match.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+	public function any($pattern, $action, $strategy = null)
+	{
+		foreach (Mapper::getMethods() as $method) {
+			$this->set($method, $pattern, $action, $strategy);
+		}
+	}
+
+	/**
+	 * Register a route into all HTTP methods except by $method.
+	 *
+	 * @param string                $methods  The method that must be excluded.
+	 * @param string                $pattern  The URi pattern that should be matched.
+	 * @param string|array|\closure $action   The action that must be executed in case of match.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+	public function except($methods, $pattern, $action, $strategy = null)
+	{
+		foreach (array_diff_key(Mapper::getMethods(), array_flip((array) $methods)) as $method) {
+			$this->set($method, $pattern, $action, $strategy);
+		}
+	}
+
+	/**
+	 * Register a route into given HTTP method(s).
+	 *
+	 * @param string|array          $methods  The method that must be matched.
+	 * @param string                $pattern  The URi pattern that should be matched.
+	 * @param string|array|\closure $action   The action that must be executed in case of match.
+	 * @param string                $strategy The route specific dispatch strategy.
+	 */
+	public function match($methods, $pattern, $action, $strategy = null)
+	{
+		foreach (array_intersect_key(Mapper::getMethods(), array_flip((array) $methods)) as $method) {
+			$this->set($method, $pattern, $action, $strategy);
+		}
+	}
 
 }
 
@@ -530,206 +530,206 @@ 
 trait ControllerMapper
 {
 
-    abstract public function getActionDelimiter();
-    abstract public function getPatternWildcards();
-    abstract public function match($methods, $pattern, $action, $strategy = null);
-
-    /**
-     * Maps all the controller methods that begins with a HTTP method, and maps the rest of
-     * name as a uri. The uri will be the method name with slashes before every camelcased 
-     * word and without the HTTP method prefix. 
-     * e.g. getSomePage will generate a route to: GET some/page
-     *
-     * @param string|object $controller The controller name or representation.
-     * @param bool          $prefix     Dict if the controller name should prefix the path.
-     *
-     * @throws \BadMethodCallException
-     * @return Mapper
-     */
-
-    public function controller($controller, $prefix = true)
-    {
-        if (!$methods = get_class_methods($controller)) {
-            throw new \BadMethodCallException('The controller class could not be inspected.');
-        }
-
-        $methods = $this->getControllerMethods($methods);
-        $prefix = $this->getControllerPrefix($prefix, $controller);
-        $delimiter = $this->getActionDelimiter();
-
-        foreach ($methods as $route) {
-            $uri = preg_replace_callback('~(^|[a-z])([A-Z])~', [$this, 'getControllerAction'], $route[1]);
-
-            $methodName = $route[0] . $route[1];
-            $methodObj = new \ReflectionMethod($controller, $methodName);
-            $dynamic = $this->getMethodConstraints($methodObj);
-
-            $this->{$route[0]}($prefix . $uri . $dynamic, $controller . $delimiter . $methodName, $this->getMethodStrategy($methodObj));
-        }
-
-        return $this;
-    }
-
-    /**
-     * Give a prefix for the controller routes paths.
-     *
-     * @param bool $prefix Must prefix?
-     * @param string|object $controller The controller name or representation.
-     *
-     * @return string
-     */
-
-    protected function getControllerPrefix($prefix, $controller)
-    {
-        $path = '/';
-
-        if ($prefix === true) {
-            $path .= $this->getControllerName($controller);
-        }
-
-        return $path;
-    }
-
-    /**
-     * Transform camelcased strings into URIs.
-     *
-     * @param array $matches
-     *
-     * @return string
-     */
-
-    public function getControllerAction(array $matches)
-    {
-        return strtolower(strlen($matches[1]) ? $matches[1] . '/' . $matches[2] : $matches[2]);
-    }
-
-    /**
-     * Get the controller name without the suffix Controller.
-     *
-     * @param string|object $controller
-     * @param array $options
-     *
-     * @return string
-     */
-
-    public function getControllerName($controller, array $options = array())
-    {
-        if (isset($options['as'])) {
-            return $options['as'];
-        }
-
-        if (is_object($controller)) {
-            $controller = get_class($controller);
-        }
-
-        return strtolower(strstr(array_reverse(explode('\\', $controller))[0], 'Controller', true));
-    }
-
-    /**
-     * Maps the controller methods to HTTP methods.
-     *
-     * @param array $classMethods All the controller public methods
-     * @return array An array keyed by HTTP methods and their controller methods.
-     */
-
-    protected function getControllerMethods($classMethods)
-    {
-        $mapMethods = [];
-        $httpMethods = array_keys(Mapper::getMethods());
-
-        foreach ($classMethods as $classMethod) {
-            foreach ($httpMethods as $httpMethod) {
-                if (strpos($classMethod, $httpMethod) === 0) {
-                    $mapMethods[] = [$httpMethod, substr($classMethod, strlen($httpMethod))];
-                }
-            }
-        }
-
-        return $mapMethods;
-    }
-
-    /**
-     * Inspect a method seeking for parameters and make a dynamic pattern.
-     *
-     * @param \ReflectionMethod $method The method to be inspected name.
-     * @return string The resulting URi.
-     */
-
-    protected function getMethodConstraints(\ReflectionMethod $method)
-    {
-        $beginUri = '';
-        $endUri = '';
-
-        if ($parameters = $method->getParameters()) {
-            $types = $this->getParamsConstraint($method);
-
-            foreach ($parameters as $parameter) {
-                if ($parameter->isOptional()) {
-                    $beginUri .= '[';
-                    $endUri .= ']';
-                }
-
-                $beginUri .= $this->getUriConstraint($parameter, $types);
-            }
-        }
-
-        return $beginUri . $endUri;
-    }
-
-    /**
-     * Return a URi segment based on parameters constraints.
-     *
-     * @param \ReflectionParameter $parameter The parameter base to build the constraint.
-     * @param array $types All the parsed constraints.
-     *
-     * @return string
-     */
-
-    protected function getUriConstraint(\ReflectionParameter $parameter, $types)
-    {
-        $name = $parameter->name;
-        $uri  = '/{' . $name;
-
-        if (isset($types[$name])) {
-            return  $uri . ':' . $types[$name] . '}';
-        } else {
-            return $uri . '}';
-        }
-    }
-
-    /**
-     * Get all parameters with they constraint.
-     *
-     * @param \ReflectionMethod $method The method to be inspected name.
-     * @return array All the parameters with they constraint.
-     */
-
-    protected function getParamsConstraint(\ReflectionMethod $method)
-    {
-        $params = [];
-        preg_match_all('~\@param\s(' . implode('|', array_keys($this->getPatternWildcards())) . ')\s\$([a-zA-Z]+)\s(Match \((.+)\))?~',
-            $method->getDocComment(), $types, PREG_SET_ORDER);
-
-        foreach ((array) $types as $type) {
-            // if a pattern is defined on Match take it otherwise take the param type by PHPDoc.
-            $params[$type[2]] = isset($type[4]) ? $type[4] : $type[1];
-        }
-
-        return $params;
-    }
-
-    /**
-     * Get the strategy defined for a controller method by comment.
-     *
-     * @param \ReflectionMethod $method
-     * @return null|string
-     */
-
-    protected function getMethodStrategy(\ReflectionMethod $method)
-    {
-        preg_match('~\@strategy\s([a-zA-Z\\\_]+)~', $method->getDocComment(), $strategy);
-        return isset($strategy[1]) ? $strategy[1] : null;
-    }
+	abstract public function getActionDelimiter();
+	abstract public function getPatternWildcards();
+	abstract public function match($methods, $pattern, $action, $strategy = null);
+
+	/**
+	 * Maps all the controller methods that begins with a HTTP method, and maps the rest of
+	 * name as a uri. The uri will be the method name with slashes before every camelcased 
+	 * word and without the HTTP method prefix. 
+	 * e.g. getSomePage will generate a route to: GET some/page
+	 *
+	 * @param string|object $controller The controller name or representation.
+	 * @param bool          $prefix     Dict if the controller name should prefix the path.
+	 *
+	 * @throws \BadMethodCallException
+	 * @return Mapper
+	 */
+
+	public function controller($controller, $prefix = true)
+	{
+		if (!$methods = get_class_methods($controller)) {
+			throw new \BadMethodCallException('The controller class could not be inspected.');
+		}
+
+		$methods = $this->getControllerMethods($methods);
+		$prefix = $this->getControllerPrefix($prefix, $controller);
+		$delimiter = $this->getActionDelimiter();
+
+		foreach ($methods as $route) {
+			$uri = preg_replace_callback('~(^|[a-z])([A-Z])~', [$this, 'getControllerAction'], $route[1]);
+
+			$methodName = $route[0] . $route[1];
+			$methodObj = new \ReflectionMethod($controller, $methodName);
+			$dynamic = $this->getMethodConstraints($methodObj);
+
+			$this->{$route[0]}($prefix . $uri . $dynamic, $controller . $delimiter . $methodName, $this->getMethodStrategy($methodObj));
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Give a prefix for the controller routes paths.
+	 *
+	 * @param bool $prefix Must prefix?
+	 * @param string|object $controller The controller name or representation.
+	 *
+	 * @return string
+	 */
+
+	protected function getControllerPrefix($prefix, $controller)
+	{
+		$path = '/';
+
+		if ($prefix === true) {
+			$path .= $this->getControllerName($controller);
+		}
+
+		return $path;
+	}
+
+	/**
+	 * Transform camelcased strings into URIs.
+	 *
+	 * @param array $matches
+	 *
+	 * @return string
+	 */
+
+	public function getControllerAction(array $matches)
+	{
+		return strtolower(strlen($matches[1]) ? $matches[1] . '/' . $matches[2] : $matches[2]);
+	}
+
+	/**
+	 * Get the controller name without the suffix Controller.
+	 *
+	 * @param string|object $controller
+	 * @param array $options
+	 *
+	 * @return string
+	 */
+
+	public function getControllerName($controller, array $options = array())
+	{
+		if (isset($options['as'])) {
+			return $options['as'];
+		}
+
+		if (is_object($controller)) {
+			$controller = get_class($controller);
+		}
+
+		return strtolower(strstr(array_reverse(explode('\\', $controller))[0], 'Controller', true));
+	}
+
+	/**
+	 * Maps the controller methods to HTTP methods.
+	 *
+	 * @param array $classMethods All the controller public methods
+	 * @return array An array keyed by HTTP methods and their controller methods.
+	 */
+
+	protected function getControllerMethods($classMethods)
+	{
+		$mapMethods = [];
+		$httpMethods = array_keys(Mapper::getMethods());
+
+		foreach ($classMethods as $classMethod) {
+			foreach ($httpMethods as $httpMethod) {
+				if (strpos($classMethod, $httpMethod) === 0) {
+					$mapMethods[] = [$httpMethod, substr($classMethod, strlen($httpMethod))];
+				}
+			}
+		}
+
+		return $mapMethods;
+	}
+
+	/**
+	 * Inspect a method seeking for parameters and make a dynamic pattern.
+	 *
+	 * @param \ReflectionMethod $method The method to be inspected name.
+	 * @return string The resulting URi.
+	 */
+
+	protected function getMethodConstraints(\ReflectionMethod $method)
+	{
+		$beginUri = '';
+		$endUri = '';
+
+		if ($parameters = $method->getParameters()) {
+			$types = $this->getParamsConstraint($method);
+
+			foreach ($parameters as $parameter) {
+				if ($parameter->isOptional()) {
+					$beginUri .= '[';
+					$endUri .= ']';
+				}
+
+				$beginUri .= $this->getUriConstraint($parameter, $types);
+			}
+		}
+
+		return $beginUri . $endUri;
+	}
+
+	/**
+	 * Return a URi segment based on parameters constraints.
+	 *
+	 * @param \ReflectionParameter $parameter The parameter base to build the constraint.
+	 * @param array $types All the parsed constraints.
+	 *
+	 * @return string
+	 */
+
+	protected function getUriConstraint(\ReflectionParameter $parameter, $types)
+	{
+		$name = $parameter->name;
+		$uri  = '/{' . $name;
+
+		if (isset($types[$name])) {
+			return  $uri . ':' . $types[$name] . '}';
+		} else {
+			return $uri . '}';
+		}
+	}
+
+	/**
+	 * Get all parameters with they constraint.
+	 *
+	 * @param \ReflectionMethod $method The method to be inspected name.
+	 * @return array All the parameters with they constraint.
+	 */
+
+	protected function getParamsConstraint(\ReflectionMethod $method)
+	{
+		$params = [];
+		preg_match_all('~\@param\s(' . implode('|', array_keys($this->getPatternWildcards())) . ')\s\$([a-zA-Z]+)\s(Match \((.+)\))?~',
+			$method->getDocComment(), $types, PREG_SET_ORDER);
+
+		foreach ((array) $types as $type) {
+			// if a pattern is defined on Match take it otherwise take the param type by PHPDoc.
+			$params[$type[2]] = isset($type[4]) ? $type[4] : $type[1];
+		}
+
+		return $params;
+	}
+
+	/**
+	 * Get the strategy defined for a controller method by comment.
+	 *
+	 * @param \ReflectionMethod $method
+	 * @return null|string
+	 */
+
+	protected function getMethodStrategy(\ReflectionMethod $method)
+	{
+		preg_match('~\@strategy\s([a-zA-Z\\\_]+)~', $method->getDocComment(), $strategy);
+		return isset($strategy[1]) ? $strategy[1] : null;
+	}
 
 }
 
@@ -743,68 +743,68 @@ 
 trait ResourceMapper
 {
 
-    abstract public function set($methods, $pattern, $action, $strategy = null);
-    abstract public function getActionDelimiter();
-    abstract public function getControllerName($controller, array $options = array());
-
-    /**
-     * A map of all routes of resources.
-     *
-     * @var array
-     */
-
-    protected $map = [
-        'index' => [Mapper::METHOD_GET, '/:name'],
-        'make' => [Mapper::METHOD_GET, '/:name/make'],
-        'create' => [Mapper::METHOD_POST, '/:name'],
-        'show' => [Mapper::METHOD_GET, '/:name/{id}'],
-        'edit' => [Mapper::METHOD_GET, '/:name/{id}/edit'],
-        'update' => [Mapper::METHOD_PUT, '/:name/{id}'],
-        'delete' => [Mapper::METHOD_DELETE, '/:name/{id}'],
-    ];
-
-    /**
-     * Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. 
-     * Instead of declaring separate routes for your index, show, new, edit, create, update and destroy actions, 
-     * a resourceful route declares them in a single line of code
-     *
-     * @param string|object $controller The controller name or representation.
-     * @param array         $options    Some options like, 'as' to name the route pattern, 'only' to
-     *                                  explicit say that only this routes will be registered, and
-     *                                  except that register all the routes except the indicates.
-     */
-
-    public function resource($controller, array $options = array())
-    {
-        $name  = isset($options['prefix']) ? $options['prefix'] : '';
-        $name .= $this->getControllerName($controller, $options);
-        $actions = $this->getResourceActions($options);
-        $delimiter = $this->getActionDelimiter();
-
-        foreach ($actions as $action => $map) {
-            $this->set($map[0], str_replace(':name', $name, $map[1]),
-                is_string($controller) ? $controller . $delimiter . $action : [$controller, $action]);
-        }
-    }
-
-    /**
-     * Parse the options to find out what actions will be registered.
-     *
-     * @param array $options
-     * @return array
-     */
-
-    protected function getResourceActions($options)
-    {
-        if (isset($options['only'])) {
-            return array_intersect_key($this->map, array_flip($options['only']));
-        }
-
-        if (isset($options['except'])) {
-            return array_diff_key($this->map, array_flip($options['except']));
-        }
-
-        return $this->map;
-    }
+	abstract public function set($methods, $pattern, $action, $strategy = null);
+	abstract public function getActionDelimiter();
+	abstract public function getControllerName($controller, array $options = array());
+
+	/**
+	 * A map of all routes of resources.
+	 *
+	 * @var array
+	 */
+
+	protected $map = [
+		'index' => [Mapper::METHOD_GET, '/:name'],
+		'make' => [Mapper::METHOD_GET, '/:name/make'],
+		'create' => [Mapper::METHOD_POST, '/:name'],
+		'show' => [Mapper::METHOD_GET, '/:name/{id}'],
+		'edit' => [Mapper::METHOD_GET, '/:name/{id}/edit'],
+		'update' => [Mapper::METHOD_PUT, '/:name/{id}'],
+		'delete' => [Mapper::METHOD_DELETE, '/:name/{id}'],
+	];
+
+	/**
+	 * Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. 
+	 * Instead of declaring separate routes for your index, show, new, edit, create, update and destroy actions, 
+	 * a resourceful route declares them in a single line of code
+	 *
+	 * @param string|object $controller The controller name or representation.
+	 * @param array         $options    Some options like, 'as' to name the route pattern, 'only' to
+	 *                                  explicit say that only this routes will be registered, and
+	 *                                  except that register all the routes except the indicates.
+	 */
+
+	public function resource($controller, array $options = array())
+	{
+		$name  = isset($options['prefix']) ? $options['prefix'] : '';
+		$name .= $this->getControllerName($controller, $options);
+		$actions = $this->getResourceActions($options);
+		$delimiter = $this->getActionDelimiter();
+
+		foreach ($actions as $action => $map) {
+			$this->set($map[0], str_replace(':name', $name, $map[1]),
+				is_string($controller) ? $controller . $delimiter . $action : [$controller, $action]);
+		}
+	}
+
+	/**
+	 * Parse the options to find out what actions will be registered.
+	 *
+	 * @param array $options
+	 * @return array
+	 */
+
+	protected function getResourceActions($options)
+	{
+		if (isset($options['only'])) {
+			return array_intersect_key($this->map, array_flip($options['only']));
+		}
+
+		if (isset($options['except'])) {
+			return array_diff_key($this->map, array_flip($options['except']));
+		}
+
+		return $this->map;
+	}
 
 }

Braces +3 added lines, -1 removed lines

@@ -278,7 +278,9 @@
         if ($patternOptionalsNumber !== count($segments) - 1) {
             if (preg_match('~' . self::DYNAMIC_REGEX . '(*SKIP)(*F) | \]~x', $patternWithoutClosingOptionals)) {
                    throw new Exceptions\BadRouteException(Exceptions\BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
-            } else throw new Exceptions\BadRouteException(Exceptions\BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+            } else {
+            	throw new Exceptions\BadRouteException(Exceptions\BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+            }
         }
     }
 

src/Strategies/DispatcherStrategyInterface.php

Indentation +9 added lines, -9 removed lines

@@ -20,14 +20,14 @@
 interface DispatcherStrategyInterface
 {
 
-    /**
-     * Dispatch the matched route action.
-     *
-     * @param string|array|closure $action The matched route action.
-     * @param array                $params The route parameters.
-     *
-     * @return mixed The response of request.
-     */
+	/**
+	 * Dispatch the matched route action.
+	 *
+	 * @param string|array|closure $action The matched route action.
+	 * @param array                $params The route parameters.
+	 *
+	 * @return mixed The response of request.
+	 */
 
-    public function dispatch($action, array $params);
+	public function dispatch($action, array $params);
 }

src/Strategies/UriDispatcherStrategy.php

Indentation +11 added lines, -11 removed lines

@@ -19,17 +19,17 @@
 class UriDispatcherStrategy implements DispatcherStrategyInterface
 {
 
-    /**
-     * @inheritDoc
-     */
+	/**
+	 * @inheritDoc
+	 */
 
-    public function dispatch($action, array $params)
-    {
-        if (is_array($action)) {
-            return call_user_func_array([new $action[0], $action[1]], $params);
-        } else {
-            return call_user_func_array($action, $params);
-        }
-    }
+	public function dispatch($action, array $params)
+	{
+		if (is_array($action)) {
+			return call_user_func_array([new $action[0], $action[1]], $params);
+		} else {
+			return call_user_func_array($action, $params);
+		}
+	}
 
 }