codeburnerframework / routing

src/Collector.php

Spacing +5 added lines, -5 removed lines

@@ -61,7 +61,7 @@ 
      * @var array
      */
 
-    protected $statics  = [];
+    protected $statics = [];
 
     /**
      * The dynamic routes have parameters and are stored in a hashtable that every cell have
@@ -123,10 +123,10 @@ 
         return new Group($group);
     }
 
-    public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
-    public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
-    public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
-    public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
+    public function get($pattern, $action) { return $this->set("get", $pattern, $action); }
+    public function post($pattern, $action) { return $this->set("post", $pattern, $action); }
+    public function put($pattern, $action) { return $this->set("put", $pattern, $action); }
+    public function patch($pattern, $action) { return $this->set("patch", $pattern, $action); }
     public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
 
     /**

Braces +18 added lines, -9 removed lines

@@ -117,7 +117,9 @@ 
             if (strpos($pattern, "{") !== false) {
                    $index = $this->getDynamicIndex($method, $pattern);
                    $this->dynamics[$index][$pattern] = $route;
-            } else $this->statics[$method][$pattern] = $route;
+            } else {
+            	$this->statics[$method][$pattern] = $route;
+            }
         }
 
         return new Group($group);
@@ -142,8 +144,9 @@ 
     public function match(array $methods, $pattern, $action)
     {
         $group = [];
-        foreach ($methods as $method)
-            $group[] = $this->set($method, $pattern, $action);
+        foreach ($methods as $method) {
+                    $group[] = $this->set($method, $pattern, $action);
+        }
         return new Group($group);
     }
 
@@ -186,8 +189,9 @@ 
     public function group(array $routes)
     {
         $group = [];
-        foreach ($routes as $route)
-            $group[] = $route;
+        foreach ($routes as $route) {
+                    $group[] = $route;
+        }
         return new Group($group);
     }
 
@@ -202,7 +206,9 @@ 
     {
         if (strpos($pattern, "{") === false) {
                unset($this->statics[$method][$pattern]);
-        } else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
+        } else {
+        	unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
+        }
     }
 
     /**
@@ -257,7 +263,9 @@ 
         if ($closingNumber !== count($segments) - 1) {
             if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
                    throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
-            } else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+            } else {
+            	throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+            }
         }
     }
 
@@ -301,8 +309,9 @@ 
     public function findStaticRoute($method, $pattern)
     {
         $method = strtolower($method);
-        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
-            return $this->statics[$method][$pattern];
+        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern])) {
+                    return $this->statics[$method][$pattern];
+        }
         return false;
     }
 

Indentation +316 added lines, -316 removed lines

@@ -33,321 +33,321 @@
 class Collector
 {
 
-    use Collectors\ControllerCollectorTrait;
-    use Collectors\ResourceCollectorTrait;
-
-    /**
-     * These regex define the structure of a dynamic segment in a pattern.
-     *
-     * @var string
-     */
-
-    const DYNAMIC_REGEX = "{\s*(\w*)\s*(?::\s*([^{}]*(?:{(?-1)}*)*))?\s*}";
-
-
-    /**
-     * All the supported http methods separated by spaces.
-     *
-     * @var string
-     */
-
-    const HTTP_METHODS = "get post put patch delete";
-
-    /**
-     * The static routes are simple stored in a multidimensional array, the first
-     * dimension is indexed by an http method and hold an array indexed with the patterns
-     * and holding the route. ex. [METHOD => [PATTERN => ROUTE]]
-     *
-     * @var array
-     */
-
-    protected $statics  = [];
-
-    /**
-     * The dynamic routes have parameters and are stored in a hashtable that every cell have
-     * an array with route patterns as indexes and routes as values. ex. [INDEX => [PATTERN => ROUTE]]
-     *
-     * @var array
-     */
-
-    protected $dynamics = [];
-
-    /**
-     * Some regex wildcards for easily definition of dynamic routes.
-     *
-     * @var array
-     */
-
-    protected $wildcards = [
-        "uid"     => "uid-[a-zA-Z0-9]",
-        "slug"    => "[a-z0-9-]",
-        "string"  => "\w",
-        "int"     => "\d",
-        "integer" => "\d",
-        "float"   => "[-+]?\d*?[.]?\d",
-        "double"  => "[-+]?\d*?[.]?\d",
-        "hex"     => "0[xX][0-9a-fA-F]",
-        "octal"   => "0[1-7][0-7]",
-        "bool"    => "1|0|true|false|yes|no",
-        "boolean" => "1|0|true|false|yes|no",
-    ];
-
-    /**
-     * @param string $method
-     * @param string $pattern
-     * @param string|array|\Closure $action
-     *
-     * @throws BadRouteException 
-     * @throws MethodNotSupportedException
-     *
-     * @return Group
-     */
-
-    public function set($method, $pattern, $action)
-    {
-        $method   = $this->parseMethod($method);
-        $patterns = $this->parsePattern($pattern);
-        $group    = [];
-
-        foreach ($patterns as $pattern)
-        {
-            $route   = new Route($this, $method, $pattern, $action);
-            $group[] = $route;
-
-            if (strpos($pattern, "{") !== false) {
-                   $index = $this->getDynamicIndex($method, $pattern);
-                   $this->dynamics[$index][$pattern] = $route;
-            } else $this->statics[$method][$pattern] = $route;
-        }
-
-        return new Group($group);
-    }
-
-    public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
-    public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
-    public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
-    public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
-    public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
-
-    /**
-     * Insert a route into several http methods.
-     *
-     * @param string[] $methods
-     * @param string   $pattern
-     * @param Callable $action
-     *
-     * @return Group
-     */
-
-    public function match(array $methods, $pattern, $action)
-    {
-        $group = [];
-        foreach ($methods as $method)
-            $group[] = $this->set($method, $pattern, $action);
-        return new Group($group);
-    }
-
-    /**
-     * Insert a route into every http method supported.
-     *
-     * @param string   $pattern
-     * @param Callable $action
-     *
-     * @return Group
-     */
-
-    public function any($pattern, $action)
-    {
-        return $this->match(explode(" ", self::HTTP_METHODS), $pattern, $action);
-    }
-
-    /**
-     * Insert a route into every http method supported but the given ones.
-     *
-     * @param string[] $methods
-     * @param string   $pattern
-     * @param Callable $action
-     *
-     * @return Group
-     */
-
-    public function except(array $methods, $pattern, $action)
-    {
-        return $this->match(array_diff(explode(" ", self::HTTP_METHODS), $methods), $pattern, $action);
-    }
-
-    /**
-     * Group all given routes.
-     *
-     * @param Route[] $routes
-     * @return Group
-     */
-
-    public function group(array $routes)
-    {
-        $group = [];
-        foreach ($routes as $route)
-            $group[] = $route;
-        return new Group($group);
-    }
-
-    /**
-     * Remove a route from collector.
-     *
-     * @param string $method
-     * @param string $pattern
-     */
-
-    public function forget($method, $pattern)
-    {
-        if (strpos($pattern, "{") === false) {
-               unset($this->statics[$method][$pattern]);
-        } else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
-    }
-
-    /**
-     * Determine if the http method is valid.
-     *
-     * @param string $method
-     * @throws MethodNotSupportedException
-     * @return string
-     */
-
-    protected function parseMethod($method)
-    {
-        $method = strtolower($method);
-
-        if (strpos(self::HTTP_METHODS, $method) === false) {
-            throw new MethodNotSupportedException($method);
-        }
-
-        return $method;
-    }
-
-    /**
-     * Separate routes pattern with optional parts into n new patterns.
-     *
-     * @param  string $pattern
-     * @return array
-     */
-
-    protected function parsePattern($pattern)
-    {
-        $withoutClosing = rtrim($pattern, "]");
-        $closingNumber  = strlen($pattern) - strlen($withoutClosing);
-
-        $segments = preg_split("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\[~x", $withoutClosing);
-        $this->parseSegments($segments, $closingNumber, $withoutClosing);
-
-        return $this->buildSegments($segments);
-    }
-
-    /**
-     * Parse all the possible patterns seeking for an incorrect or incompatible pattern.
-     *
-     * @param string[] $segments       Segments are all the possible patterns made on top of a pattern with optional segments.
-     * @param int      $closingNumber  The count of optional segments.
-     * @param string   $withoutClosing The pattern without the closing token of an optional segment. aka: ]
-     *
-     * @throws BadRouteException
-     */
-
-    protected function parseSegments(array $segments, $closingNumber, $withoutClosing)
-    {
-        if ($closingNumber !== count($segments) - 1) {
-            if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
-                   throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
-            } else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
-        }
-    }
-
-    /**
-     * @param string[] $segments
-     *
-     * @throws BadRouteException
-     * @return array
-     */
-
-    protected function buildSegments(array $segments)
-    {
-        $pattern  = "";
-        $patterns = [];
-        $wildcardTokens = [];
-        $wildcardRegex  = [];
-
-        foreach ($this->wildcards as $token => $regex) {
-            $wildcardTokens[] = ":$token";
-            $wildcardRegex [] = ":$regex";
-        }
-
-        foreach ($segments as $n => $segment) {
-            if ($segment === "" && $n !== 0) {
-                throw new BadRouteException(BadRouteException::EMPTY_OPTIONAL_PARTS);
-            }
-
-            $patterns[] = $pattern .= str_replace($wildcardTokens, $wildcardRegex, $segment);
-        }
-
-        return $patterns;
-    }
-
-    /**
-     * @param string $method
-     * @param string $pattern
-     *
-     * @return Route|false
-     */
-
-    public function findStaticRoute($method, $pattern)
-    {
-        $method = strtolower($method);
-        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
-            return $this->statics[$method][$pattern];
-        return false;
-    }
-
-    /**
-     * @param string $method
-     * @param string $pattern
-     *
-     * @return array|false
-     */
-
-    public function findDynamicRoutes($method, $pattern)
-    {
-        $index = $this->getDynamicIndex($method, $pattern);
-        return isset($this->dynamics[$index]) ? $this->dynamics[$index] : false;
-    }
-
-    /**
-     * @param string $method
-     * @param string $pattern
-     *
-     * @return int
-     */
-
-    protected function getDynamicIndex($method, $pattern)
-    {
-        return crc32(strtolower($method)) + substr_count($pattern, "/");
-    }
-
-    /**
-     * @return string[]
-     */
-
-    public function getWildcards()
-    {
-        return $this->wildcards;
-    }
-
-    /**
-     * @param string $pattern
-     * @param string $wildcard
-     */
-
-    public function setWildcard($pattern, $wildcard)
-    {
-        $this->wildcards[$pattern] = $wildcard;
-    }
+	use Collectors\ControllerCollectorTrait;
+	use Collectors\ResourceCollectorTrait;
+
+	/**
+	 * These regex define the structure of a dynamic segment in a pattern.
+	 *
+	 * @var string
+	 */
+
+	const DYNAMIC_REGEX = "{\s*(\w*)\s*(?::\s*([^{}]*(?:{(?-1)}*)*))?\s*}";
+
+
+	/**
+	 * All the supported http methods separated by spaces.
+	 *
+	 * @var string
+	 */
+
+	const HTTP_METHODS = "get post put patch delete";
+
+	/**
+	 * The static routes are simple stored in a multidimensional array, the first
+	 * dimension is indexed by an http method and hold an array indexed with the patterns
+	 * and holding the route. ex. [METHOD => [PATTERN => ROUTE]]
+	 *
+	 * @var array
+	 */
+
+	protected $statics  = [];
+
+	/**
+	 * The dynamic routes have parameters and are stored in a hashtable that every cell have
+	 * an array with route patterns as indexes and routes as values. ex. [INDEX => [PATTERN => ROUTE]]
+	 *
+	 * @var array
+	 */
+
+	protected $dynamics = [];
+
+	/**
+	 * Some regex wildcards for easily definition of dynamic routes.
+	 *
+	 * @var array
+	 */
+
+	protected $wildcards = [
+		"uid"     => "uid-[a-zA-Z0-9]",
+		"slug"    => "[a-z0-9-]",
+		"string"  => "\w",
+		"int"     => "\d",
+		"integer" => "\d",
+		"float"   => "[-+]?\d*?[.]?\d",
+		"double"  => "[-+]?\d*?[.]?\d",
+		"hex"     => "0[xX][0-9a-fA-F]",
+		"octal"   => "0[1-7][0-7]",
+		"bool"    => "1|0|true|false|yes|no",
+		"boolean" => "1|0|true|false|yes|no",
+	];
+
+	/**
+	 * @param string $method
+	 * @param string $pattern
+	 * @param string|array|\Closure $action
+	 *
+	 * @throws BadRouteException 
+	 * @throws MethodNotSupportedException
+	 *
+	 * @return Group
+	 */
+
+	public function set($method, $pattern, $action)
+	{
+		$method   = $this->parseMethod($method);
+		$patterns = $this->parsePattern($pattern);
+		$group    = [];
+
+		foreach ($patterns as $pattern)
+		{
+			$route   = new Route($this, $method, $pattern, $action);
+			$group[] = $route;
+
+			if (strpos($pattern, "{") !== false) {
+				   $index = $this->getDynamicIndex($method, $pattern);
+				   $this->dynamics[$index][$pattern] = $route;
+			} else $this->statics[$method][$pattern] = $route;
+		}
+
+		return new Group($group);
+	}
+
+	public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
+	public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
+	public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
+	public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
+	public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
+
+	/**
+	 * Insert a route into several http methods.
+	 *
+	 * @param string[] $methods
+	 * @param string   $pattern
+	 * @param Callable $action
+	 *
+	 * @return Group
+	 */
+
+	public function match(array $methods, $pattern, $action)
+	{
+		$group = [];
+		foreach ($methods as $method)
+			$group[] = $this->set($method, $pattern, $action);
+		return new Group($group);
+	}
+
+	/**
+	 * Insert a route into every http method supported.
+	 *
+	 * @param string   $pattern
+	 * @param Callable $action
+	 *
+	 * @return Group
+	 */
+
+	public function any($pattern, $action)
+	{
+		return $this->match(explode(" ", self::HTTP_METHODS), $pattern, $action);
+	}
+
+	/**
+	 * Insert a route into every http method supported but the given ones.
+	 *
+	 * @param string[] $methods
+	 * @param string   $pattern
+	 * @param Callable $action
+	 *
+	 * @return Group
+	 */
+
+	public function except(array $methods, $pattern, $action)
+	{
+		return $this->match(array_diff(explode(" ", self::HTTP_METHODS), $methods), $pattern, $action);
+	}
+
+	/**
+	 * Group all given routes.
+	 *
+	 * @param Route[] $routes
+	 * @return Group
+	 */
+
+	public function group(array $routes)
+	{
+		$group = [];
+		foreach ($routes as $route)
+			$group[] = $route;
+		return new Group($group);
+	}
+
+	/**
+	 * Remove a route from collector.
+	 *
+	 * @param string $method
+	 * @param string $pattern
+	 */
+
+	public function forget($method, $pattern)
+	{
+		if (strpos($pattern, "{") === false) {
+			   unset($this->statics[$method][$pattern]);
+		} else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
+	}
+
+	/**
+	 * Determine if the http method is valid.
+	 *
+	 * @param string $method
+	 * @throws MethodNotSupportedException
+	 * @return string
+	 */
+
+	protected function parseMethod($method)
+	{
+		$method = strtolower($method);
+
+		if (strpos(self::HTTP_METHODS, $method) === false) {
+			throw new MethodNotSupportedException($method);
+		}
+
+		return $method;
+	}
+
+	/**
+	 * Separate routes pattern with optional parts into n new patterns.
+	 *
+	 * @param  string $pattern
+	 * @return array
+	 */
+
+	protected function parsePattern($pattern)
+	{
+		$withoutClosing = rtrim($pattern, "]");
+		$closingNumber  = strlen($pattern) - strlen($withoutClosing);
+
+		$segments = preg_split("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\[~x", $withoutClosing);
+		$this->parseSegments($segments, $closingNumber, $withoutClosing);
+
+		return $this->buildSegments($segments);
+	}
+
+	/**
+	 * Parse all the possible patterns seeking for an incorrect or incompatible pattern.
+	 *
+	 * @param string[] $segments       Segments are all the possible patterns made on top of a pattern with optional segments.
+	 * @param int      $closingNumber  The count of optional segments.
+	 * @param string   $withoutClosing The pattern without the closing token of an optional segment. aka: ]
+	 *
+	 * @throws BadRouteException
+	 */
+
+	protected function parseSegments(array $segments, $closingNumber, $withoutClosing)
+	{
+		if ($closingNumber !== count($segments) - 1) {
+			if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
+				   throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
+			} else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
+		}
+	}
+
+	/**
+	 * @param string[] $segments
+	 *
+	 * @throws BadRouteException
+	 * @return array
+	 */
+
+	protected function buildSegments(array $segments)
+	{
+		$pattern  = "";
+		$patterns = [];
+		$wildcardTokens = [];
+		$wildcardRegex  = [];
+
+		foreach ($this->wildcards as $token => $regex) {
+			$wildcardTokens[] = ":$token";
+			$wildcardRegex [] = ":$regex";
+		}
+
+		foreach ($segments as $n => $segment) {
+			if ($segment === "" && $n !== 0) {
+				throw new BadRouteException(BadRouteException::EMPTY_OPTIONAL_PARTS);
+			}
+
+			$patterns[] = $pattern .= str_replace($wildcardTokens, $wildcardRegex, $segment);
+		}
+
+		return $patterns;
+	}
+
+	/**
+	 * @param string $method
+	 * @param string $pattern
+	 *
+	 * @return Route|false
+	 */
+
+	public function findStaticRoute($method, $pattern)
+	{
+		$method = strtolower($method);
+		if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
+			return $this->statics[$method][$pattern];
+		return false;
+	}
+
+	/**
+	 * @param string $method
+	 * @param string $pattern
+	 *
+	 * @return array|false
+	 */
+
+	public function findDynamicRoutes($method, $pattern)
+	{
+		$index = $this->getDynamicIndex($method, $pattern);
+		return isset($this->dynamics[$index]) ? $this->dynamics[$index] : false;
+	}
+
+	/**
+	 * @param string $method
+	 * @param string $pattern
+	 *
+	 * @return int
+	 */
+
+	protected function getDynamicIndex($method, $pattern)
+	{
+		return crc32(strtolower($method)) + substr_count($pattern, "/");
+	}
+
+	/**
+	 * @return string[]
+	 */
+
+	public function getWildcards()
+	{
+		return $this->wildcards;
+	}
+
+	/**
+	 * @param string $pattern
+	 * @param string $wildcard
+	 */
+
+	public function setWildcard($pattern, $wildcard)
+	{
+		$this->wildcards[$pattern] = $wildcard;
+	}
     
 }

src/Collectors/ResourceCollectorTrait.php

Indentation +97 added lines, -97 removed lines

@@ -22,102 +22,102 @@
 trait ResourceCollectorTrait
 {
 
-    abstract public function set($method, $pattern, $action);
-
-    /**
-     * A map of all routes of resources.
-     *
-     * @var array
-     */
-
-    protected $map = [
-        "index"  => ["get",    "/{name}"],
-        "make"   => ["get",    "/{name}/make"],
-        "create" => ["post",   "/{name}"],
-        "show"   => ["get",    "/{name}/{id:int+}"],
-        "edit"   => ["get",    "/{name}/{id:int+}/edit"],
-        "update" => ["put",    "/{name}/{id:int+}"],
-        "delete" => ["delete", "/{name}/{id:int+}"],
-    ];
-
-    /**
-     * 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 $controller The controller name.
-     * @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.
-     * @return Resource
-     */
-
-    public function resource($controller, array $options = array())
-    {
-        $name       = isset($options["prefix"]) ? $options["prefix"] : "";
-        $name      .= $this->getResourceName($controller, $options);
-        $actions    = $this->getResourceActions($options);
-        $resource = new Resource;
-
-        foreach ($actions as $action => $map) {
-            $resource->set($this->set($map[0], $this->getResourcePath($action, $map[1], $name, $options), [$controller, $action]));
-        }
-
-        return $resource;
-    }
-
-    /**
-     * Collect several resources at same time.
-     *
-     * @param array $controllers Several controller names as parameters or an array with all controller names.
-     * @return Resource
-     */
-
-    public function resources(array $controllers)
-    {
-        $resource = new Resource;
-        foreach ($controllers as $controller)
-            $resource->set($this->resource($controller));
-        return $resource;
-    }
-
-    /**
-     * @param string $controller
-     * @param array $options
-     *
-     * @return mixed
-     */
-
-    protected function getResourceName($controller, array $options)
-    {
-        return isset($options["as"]) ? $options["as"] : str_replace("controller", "", strtolower($controller));
-    }
-
-    /**
-     * @param  array $options
-     * @return array
-     */
-
-    protected function getResourceActions(array $options)
-    {
-        return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
-              (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
-    }
-
-    /**
-     * @param string $action
-     * @param string $path
-     * @param string $name
-     * @param string[] $options
-     *
-     * @return string
-     */
-
-    protected function getResourcePath($action, $path, $name, array $options)
-    {
-        return str_replace("{name}", $name,
-            $action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
-           ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
-    }
+	abstract public function set($method, $pattern, $action);
+
+	/**
+	 * A map of all routes of resources.
+	 *
+	 * @var array
+	 */
+
+	protected $map = [
+		"index"  => ["get",    "/{name}"],
+		"make"   => ["get",    "/{name}/make"],
+		"create" => ["post",   "/{name}"],
+		"show"   => ["get",    "/{name}/{id:int+}"],
+		"edit"   => ["get",    "/{name}/{id:int+}/edit"],
+		"update" => ["put",    "/{name}/{id:int+}"],
+		"delete" => ["delete", "/{name}/{id:int+}"],
+	];
+
+	/**
+	 * 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 $controller The controller name.
+	 * @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.
+	 * @return Resource
+	 */
+
+	public function resource($controller, array $options = array())
+	{
+		$name       = isset($options["prefix"]) ? $options["prefix"] : "";
+		$name      .= $this->getResourceName($controller, $options);
+		$actions    = $this->getResourceActions($options);
+		$resource = new Resource;
+
+		foreach ($actions as $action => $map) {
+			$resource->set($this->set($map[0], $this->getResourcePath($action, $map[1], $name, $options), [$controller, $action]));
+		}
+
+		return $resource;
+	}
+
+	/**
+	 * Collect several resources at same time.
+	 *
+	 * @param array $controllers Several controller names as parameters or an array with all controller names.
+	 * @return Resource
+	 */
+
+	public function resources(array $controllers)
+	{
+		$resource = new Resource;
+		foreach ($controllers as $controller)
+			$resource->set($this->resource($controller));
+		return $resource;
+	}
+
+	/**
+	 * @param string $controller
+	 * @param array $options
+	 *
+	 * @return mixed
+	 */
+
+	protected function getResourceName($controller, array $options)
+	{
+		return isset($options["as"]) ? $options["as"] : str_replace("controller", "", strtolower($controller));
+	}
+
+	/**
+	 * @param  array $options
+	 * @return array
+	 */
+
+	protected function getResourceActions(array $options)
+	{
+		return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
+			  (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
+	}
+
+	/**
+	 * @param string $action
+	 * @param string $path
+	 * @param string $name
+	 * @param string[] $options
+	 *
+	 * @return string
+	 */
+
+	protected function getResourcePath($action, $path, $name, array $options)
+	{
+		return str_replace("{name}", $name,
+			$action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
+		   ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
+	}
 
 }

Spacing +8 added lines, -10 removed lines

@@ -31,12 +31,12 @@ 
      */
 
     protected $map = [
-        "index"  => ["get",    "/{name}"],
-        "make"   => ["get",    "/{name}/make"],
-        "create" => ["post",   "/{name}"],
-        "show"   => ["get",    "/{name}/{id:int+}"],
-        "edit"   => ["get",    "/{name}/{id:int+}/edit"],
-        "update" => ["put",    "/{name}/{id:int+}"],
+        "index"  => ["get", "/{name}"],
+        "make"   => ["get", "/{name}/make"],
+        "create" => ["post", "/{name}"],
+        "show"   => ["get", "/{name}/{id:int+}"],
+        "edit"   => ["get", "/{name}/{id:int+}/edit"],
+        "update" => ["put", "/{name}/{id:int+}"],
         "delete" => ["delete", "/{name}/{id:int+}"],
     ];
 
@@ -100,8 +100,7 @@ 
 
     protected function getResourceActions(array $options)
     {
-        return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
-              (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
+        return isset($options["only"]) ? array_intersect_key($this->map, array_flip((array) $options["only"])) : (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"])) : $this->map);
     }
 
     /**
@@ -116,8 +115,7 @@ 
     protected function getResourcePath($action, $path, $name, array $options)
     {
         return str_replace("{name}", $name,
-            $action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
-           ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
+            $action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) : ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
     }
 
 }

Braces +3 added lines, -2 removed lines

@@ -76,8 +76,9 @@
     public function resources(array $controllers)
     {
         $resource = new Resource;
-        foreach ($controllers as $controller)
-            $resource->set($this->resource($controller));
+        foreach ($controllers as $controller) {
+                    $resource->set($this->resource($controller));
+        }
         return $resource;
     }
 

src/Exceptions/BadDispatchStrategyException.php

Indentation +3 added lines, -3 removed lines

@@ -20,8 +20,8 @@
 class BadDispatchStrategyException extends BadRouteException
 {
 
-    public function __construct($strategy) {
-        parent::__construct("`$strategy` is not a valid route dispatch strategy, it must implement the `Codeburner\Router\DispatchStrategies\DispatchStrategyInterface` interface.");
-    }
+	public function __construct($strategy) {
+		parent::__construct("`$strategy` is not a valid route dispatch strategy, it must implement the `Codeburner\Router\DispatchStrategies\DispatchStrategyInterface` interface.");
+	}
     
 }

src/Exceptions/MethodNotAllowedException.php

Indentation +55 added lines, -55 removed lines

@@ -20,71 +20,71 @@
 class MethodNotAllowedException extends BadRouteException
 {
 
-    /**
-     * The HTTP method from request.
-     *
-     * @var string
-     */
+	/**
+	 * The HTTP method from request.
+	 *
+	 * @var string
+	 */
 
-    public $requestedMethod;
+	public $requestedMethod;
 
-    /**
-     * The requested URi.
-     *
-     * @var string
-     */
+	/**
+	 * The requested URi.
+	 *
+	 * @var string
+	 */
 
-    public $requestedUri;
+	public $requestedUri;
 
-    /**
-     * All the allowed HTTP methods and routes for the request.
-     *
-     * @var array
-     */
+	/**
+	 * All the allowed HTTP methods and routes for the request.
+	 *
+	 * @var array
+	 */
 
-    public $allowedMethods;
+	public $allowedMethods;
 	
-    /**
-     * Exception constructor.
-     *
-     * @param string  $requestedMethod The request HTTP method.
-     * @param string  $requestedUri    The request URi.
-     * @param array   $allowedMethods  All the allowed HTTP methods and routes for the request.
-     * @param string  $message         The exception error message.
-     * @param integer $code            The exception error code.
-     */
+	/**
+	 * Exception constructor.
+	 *
+	 * @param string  $requestedMethod The request HTTP method.
+	 * @param string  $requestedUri    The request URi.
+	 * @param array   $allowedMethods  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($requestedMethod, $requestedUri, array $allowedMethods, $message = null, $code = 405)
-    {
-        $this->requestedMethod = $requestedMethod;
-        $this->requestedUri    = $requestedUri;
-        $this->allowedMethods  = $allowedMethods;
-        parent::__construct($message, $code);
-    }
+	public function __construct($requestedMethod, $requestedUri, array $allowedMethods, $message = null, $code = 405)
+	{
+		$this->requestedMethod = $requestedMethod;
+		$this->requestedUri    = $requestedUri;
+		$this->allowedMethods  = $allowedMethods;
+		parent::__construct($message, $code);
+	}
 
-    /**
-     * Verify if the given HTTP method is allowed for the request.
-     *
-     * @param string An HTTP method
-     * @return bool
-     */
+	/**
+	 * 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->allowedMethods[strtoupper($method)]);
-    }
+	public function can($method)
+	{
+		return isset($this->allowedMethods[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
-     */
+	/**
+	 * 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->allowedMethods));
-    }
+	public function allowed()
+	{
+		return implode(', ', array_keys($this->allowedMethods));
+	}
 
 }

src/Exceptions/MethodNotSupportedException.php

Indentation +3 added lines, -3 removed lines

@@ -20,8 +20,8 @@
 class MethodNotSupportedException extends BadRouteException
 {
 
-    public function __construct($method) {
-        parent::__construct("The HTTP method '$method' is not supported by the route collector.");
-    }
+	public function __construct($method) {
+		parent::__construct("The HTTP method '$method' is not supported by the route collector.");
+	}
 
 }

src/Exceptions/NotFoundException.php

Indentation +27 added lines, -27 removed lines

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

src/Group.php

Indentation +250 added lines, -250 removed lines

@@ -19,255 +19,255 @@
 class Group
 {
 
-    /**
-     * All grouped route objects.
-     *
-     * @var Route[]
-     */
-
-    protected $routes;
-
-    /**
-     * Group constructor.
-     *
-     * @param Route[] $routes
-     */
-
-    public function __construct(array $routes = [])
-    {
-        $this->routes = $routes;
-    }
-
-    /**
-     * Set a new Route or merge an existing group of routes.
-     *
-     * @param Group|Route $route
-     * @return self
-     */
-
-    public function set($route)
-    {
-        if ($route instanceof Group) {
-            foreach ($route->all() as $r)
-                $this->routes[] = $r;
-        } else  $this->routes[] = $route;
-        return  $this;
-    }
-
-    /**
-     * Return all grouped routes objects.
-     *
-     * @return Route[]
-     */
-
-    public function all()
-    {
-        return $this->routes;
-    }
-
-    /**
-     * Get a specific route of the group, routes receive a key based on
-     * the order they are added to the group.
-     *
-     * @param int $number
-     * @return Route
-     */
-
-    public function nth($number)
-    {
-        return $this->routes[$number];
-    }
-
-    /**
-     * Forget the registration of all grouped routes on to collector.
-     * After the forget the route object will still exist but will not
-     * count for the matcher.
-     *
-     * @return self
-     */
-
-    public function forget()
-    {
-        foreach ($this->routes as $route)
-            $route->forget();
-        return $this;
-    }
-
-    /**
-     * Set one HTTP method to all grouped routes.
-     *
-     * @param string $method The HTTP Method
-     * @return self
-     */
-
-    public function setMethod($method)
-    {
-        foreach ($this->routes as $route)
-            $route->setMethod($method);
-        return $this;
-    }
-
-    /**
-     * Set one action to all grouped routes.
-     *
-     * @param string $action
-     * @return self
-     */
-
-    public function setAction($action)
-    {
-        foreach ($this->routes as $route)
-            $route->setAction($action);
-        return $this;
-    }
-
-    /**
-     * Set one namespace to all grouped routes.
-     *
-     * @param string $namespace
-     * @return self
-     */
-
-    public function setNamespace($namespace)
-    {
-        foreach ($this->routes as $route)
-            $route->setNamespace($namespace);
-        return $this;
-    }
-
-    /**
-     * Add a prefix to all grouped routes pattern.
-     *
-     * @param string $prefix
-     * @return self
-     */
-
-    public function setPrefix($prefix)
-    {
-        $prefix = "/" . ltrim($prefix, "/");
-        foreach ($this->routes as $route)
-            $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
-        return $this;
-    }
-
-    /**
-     * Set metadata to all grouped routes.
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return $this
-     */
-
-    public function setMetadata($key, $value)
-    {
-        foreach ($this->routes as $route)
-            $route->setMetadata($key, $value);
-        return $this;
-    }
-
-    /**
-     * Set a bunch of metadata to all grouped routes.
-     *
-     * @param mixed[] $metadata
-     * @return $this
-     */
-
-    public function setMetadataArray(array $metadata)
-    {
-        foreach ($this->routes as $route)
-            $route->setMetadataArray($metadata);
-        return $this;
-    }
-
-    /**
-     * Set default parameters to all grouped routes.
-     *
-     * @param mixed[] $defaults
-     * @return $this
-     */
-
-    public function setDefaults(array $defaults)
-    {
-        foreach ($this->routes as $route)
-            $route->setDefaults($defaults);
-        return $this;
-    }
-
-    /**
-     * Set a default parameter to all grouped routes.
-     *
-     * @param string $key
-     * @param mixed $value
-     *
-     * @return $this
-     */
-
-    public function setDefault($key, $value)
-    {
-        foreach ($this->routes as $route)
-            $route->setDefault($key, $value);
-        return $this;
-    }
-
-    /**
-     * Set one dispatch strategy to all grouped routes.
-     *
-     * @param string|Strategies\StrategyInterface $strategy
-     * @return self
-     */
-
-    public function setStrategy($strategy)
-    {
-        foreach ($this->routes as $route)
-            $route->setStrategy($strategy);
-        return $this;
-    }
-
-    /**
-     * Replace or define a constraint for all dynamic segments named by $name.
-     *
-     * @param string $name
-     * @param string $regex
-     *
-     * @return self
-     */
-
-    public function setConstraint($name, $regex)
-    {
-        foreach ($this->routes as $route) {
-            $pattern = $route->getPattern();
-            $initPos = strpos($pattern, "{" . $name);
-
-            if ($initPos !== false) {
-                $endPos = strpos($pattern, "}", $initPos);
-                $newPattern = substr_replace($pattern, "{" . "$name:$regex" . "}", $initPos, $endPos - $initPos + 1);
-                $route->setPatternWithoutReset($newPattern);
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Define a constraint for a variable in all grouped routes pattern, but don't replace the
-     * delimiter if one already exists.
-     *
-     * @param string $name
-     * @param string $regex
-     *
-     * @return self
-     */
-
-    public function setConstraintPreservingQuantifiers($name, $regex)
-    {
-        $wildcards = $this->routes[0]->getCollector()->getWildcards();
-        $quantifierPos = strpos($regex, "{") + strpos($regex, "+") + strpos($regex, "*");
-        $quantifier = substr($regex, $quantifierPos);
-        $quantifierErased = $quantifierPos !== false ? substr($regex, 0, $quantifierPos) : null;
-        $regex = isset($wildcards[$quantifierErased]) ? $wildcards[$quantifierErased] . $quantifier : $regex;
-
-        return $this->setConstraint($name, $regex);
-    }
+	/**
+	 * All grouped route objects.
+	 *
+	 * @var Route[]
+	 */
+
+	protected $routes;
+
+	/**
+	 * Group constructor.
+	 *
+	 * @param Route[] $routes
+	 */
+
+	public function __construct(array $routes = [])
+	{
+		$this->routes = $routes;
+	}
+
+	/**
+	 * Set a new Route or merge an existing group of routes.
+	 *
+	 * @param Group|Route $route
+	 * @return self
+	 */
+
+	public function set($route)
+	{
+		if ($route instanceof Group) {
+			foreach ($route->all() as $r)
+				$this->routes[] = $r;
+		} else  $this->routes[] = $route;
+		return  $this;
+	}
+
+	/**
+	 * Return all grouped routes objects.
+	 *
+	 * @return Route[]
+	 */
+
+	public function all()
+	{
+		return $this->routes;
+	}
+
+	/**
+	 * Get a specific route of the group, routes receive a key based on
+	 * the order they are added to the group.
+	 *
+	 * @param int $number
+	 * @return Route
+	 */
+
+	public function nth($number)
+	{
+		return $this->routes[$number];
+	}
+
+	/**
+	 * Forget the registration of all grouped routes on to collector.
+	 * After the forget the route object will still exist but will not
+	 * count for the matcher.
+	 *
+	 * @return self
+	 */
+
+	public function forget()
+	{
+		foreach ($this->routes as $route)
+			$route->forget();
+		return $this;
+	}
+
+	/**
+	 * Set one HTTP method to all grouped routes.
+	 *
+	 * @param string $method The HTTP Method
+	 * @return self
+	 */
+
+	public function setMethod($method)
+	{
+		foreach ($this->routes as $route)
+			$route->setMethod($method);
+		return $this;
+	}
+
+	/**
+	 * Set one action to all grouped routes.
+	 *
+	 * @param string $action
+	 * @return self
+	 */
+
+	public function setAction($action)
+	{
+		foreach ($this->routes as $route)
+			$route->setAction($action);
+		return $this;
+	}
+
+	/**
+	 * Set one namespace to all grouped routes.
+	 *
+	 * @param string $namespace
+	 * @return self
+	 */
+
+	public function setNamespace($namespace)
+	{
+		foreach ($this->routes as $route)
+			$route->setNamespace($namespace);
+		return $this;
+	}
+
+	/**
+	 * Add a prefix to all grouped routes pattern.
+	 *
+	 * @param string $prefix
+	 * @return self
+	 */
+
+	public function setPrefix($prefix)
+	{
+		$prefix = "/" . ltrim($prefix, "/");
+		foreach ($this->routes as $route)
+			$route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
+		return $this;
+	}
+
+	/**
+	 * Set metadata to all grouped routes.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return $this
+	 */
+
+	public function setMetadata($key, $value)
+	{
+		foreach ($this->routes as $route)
+			$route->setMetadata($key, $value);
+		return $this;
+	}
+
+	/**
+	 * Set a bunch of metadata to all grouped routes.
+	 *
+	 * @param mixed[] $metadata
+	 * @return $this
+	 */
+
+	public function setMetadataArray(array $metadata)
+	{
+		foreach ($this->routes as $route)
+			$route->setMetadataArray($metadata);
+		return $this;
+	}
+
+	/**
+	 * Set default parameters to all grouped routes.
+	 *
+	 * @param mixed[] $defaults
+	 * @return $this
+	 */
+
+	public function setDefaults(array $defaults)
+	{
+		foreach ($this->routes as $route)
+			$route->setDefaults($defaults);
+		return $this;
+	}
+
+	/**
+	 * Set a default parameter to all grouped routes.
+	 *
+	 * @param string $key
+	 * @param mixed $value
+	 *
+	 * @return $this
+	 */
+
+	public function setDefault($key, $value)
+	{
+		foreach ($this->routes as $route)
+			$route->setDefault($key, $value);
+		return $this;
+	}
+
+	/**
+	 * Set one dispatch strategy to all grouped routes.
+	 *
+	 * @param string|Strategies\StrategyInterface $strategy
+	 * @return self
+	 */
+
+	public function setStrategy($strategy)
+	{
+		foreach ($this->routes as $route)
+			$route->setStrategy($strategy);
+		return $this;
+	}
+
+	/**
+	 * Replace or define a constraint for all dynamic segments named by $name.
+	 *
+	 * @param string $name
+	 * @param string $regex
+	 *
+	 * @return self
+	 */
+
+	public function setConstraint($name, $regex)
+	{
+		foreach ($this->routes as $route) {
+			$pattern = $route->getPattern();
+			$initPos = strpos($pattern, "{" . $name);
+
+			if ($initPos !== false) {
+				$endPos = strpos($pattern, "}", $initPos);
+				$newPattern = substr_replace($pattern, "{" . "$name:$regex" . "}", $initPos, $endPos - $initPos + 1);
+				$route->setPatternWithoutReset($newPattern);
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Define a constraint for a variable in all grouped routes pattern, but don't replace the
+	 * delimiter if one already exists.
+	 *
+	 * @param string $name
+	 * @param string $regex
+	 *
+	 * @return self
+	 */
+
+	public function setConstraintPreservingQuantifiers($name, $regex)
+	{
+		$wildcards = $this->routes[0]->getCollector()->getWildcards();
+		$quantifierPos = strpos($regex, "{") + strpos($regex, "+") + strpos($regex, "*");
+		$quantifier = substr($regex, $quantifierPos);
+		$quantifierErased = $quantifierPos !== false ? substr($regex, 0, $quantifierPos) : null;
+		$regex = isset($wildcards[$quantifierErased]) ? $wildcards[$quantifierErased] . $quantifier : $regex;
+
+		return $this->setConstraint($name, $regex);
+	}
 
 }

Braces +36 added lines, -23 removed lines

@@ -48,9 +48,12 @@ 
     public function set($route)
     {
         if ($route instanceof Group) {
-            foreach ($route->all() as $r)
-                $this->routes[] = $r;
-        } else  $this->routes[] = $route;
+            foreach ($route->all() as $r) {
+                            $this->routes[] = $r;
+            }
+        } else {
+        	$this->routes[] = $route;
+        }
         return  $this;
     }
 
@@ -88,8 +91,9 @@ 
 
     public function forget()
     {
-        foreach ($this->routes as $route)
-            $route->forget();
+        foreach ($this->routes as $route) {
+                    $route->forget();
+        }
         return $this;
     }
 
@@ -102,8 +106,9 @@ 
 
     public function setMethod($method)
     {
-        foreach ($this->routes as $route)
-            $route->setMethod($method);
+        foreach ($this->routes as $route) {
+                    $route->setMethod($method);
+        }
         return $this;
     }
 
@@ -116,8 +121,9 @@ 
 
     public function setAction($action)
     {
-        foreach ($this->routes as $route)
-            $route->setAction($action);
+        foreach ($this->routes as $route) {
+                    $route->setAction($action);
+        }
         return $this;
     }
 
@@ -130,8 +136,9 @@ 
 
     public function setNamespace($namespace)
     {
-        foreach ($this->routes as $route)
-            $route->setNamespace($namespace);
+        foreach ($this->routes as $route) {
+                    $route->setNamespace($namespace);
+        }
         return $this;
     }
 
@@ -145,8 +152,9 @@ 
     public function setPrefix($prefix)
     {
         $prefix = "/" . ltrim($prefix, "/");
-        foreach ($this->routes as $route)
-            $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
+        foreach ($this->routes as $route) {
+                    $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
+        }
         return $this;
     }
 
@@ -161,8 +169,9 @@ 
 
     public function setMetadata($key, $value)
     {
-        foreach ($this->routes as $route)
-            $route->setMetadata($key, $value);
+        foreach ($this->routes as $route) {
+                    $route->setMetadata($key, $value);
+        }
         return $this;
     }
 
@@ -175,8 +184,9 @@ 
 
     public function setMetadataArray(array $metadata)
     {
-        foreach ($this->routes as $route)
-            $route->setMetadataArray($metadata);
+        foreach ($this->routes as $route) {
+                    $route->setMetadataArray($metadata);
+        }
         return $this;
     }
 
@@ -189,8 +199,9 @@ 
 
     public function setDefaults(array $defaults)
     {
-        foreach ($this->routes as $route)
-            $route->setDefaults($defaults);
+        foreach ($this->routes as $route) {
+                    $route->setDefaults($defaults);
+        }
         return $this;
     }
 
@@ -205,8 +216,9 @@ 
 
     public function setDefault($key, $value)
     {
-        foreach ($this->routes as $route)
-            $route->setDefault($key, $value);
+        foreach ($this->routes as $route) {
+                    $route->setDefault($key, $value);
+        }
         return $this;
     }
 
@@ -219,8 +231,9 @@ 
 
     public function setStrategy($strategy)
     {
-        foreach ($this->routes as $route)
-            $route->setStrategy($strategy);
+        foreach ($this->routes as $route) {
+                    $route->setStrategy($strategy);
+        }
         return $this;
     }
 

src/Matcher.php

Spacing +2 added lines, -2 removed lines

@@ -235,7 +235,7 @@ 
 
     protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
     {
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
+        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function($httpMethod) use ($path) {
             return (bool) $this->collector->findStaticRoute($httpMethod, $path);
         });
     }
@@ -251,7 +251,7 @@ 
 
     protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
     {
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
+        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function($httpMethod) use ($path) {
             return (bool) $this->matchDynamicRoute($httpMethod, $path);
         });
     }

Indentation +272 added lines, -272 removed lines

@@ -23,279 +23,279 @@
 class Matcher
 {
 
-    /**
-     * @var Collector
-     */
-
-    protected $collector;
-
-    /**
-     * Define a basepath to all routes.
-     *
-     * @var string
-     */
-
-    protected $basepath = "";
-
-    /**
-     * Construct the route dispatcher.
-     *
-     * @param Collector $collector
-     * @param string $basepath Define a Path prefix that must be excluded on matches.
-     */
-
-    public function __construct(Collector $collector, $basepath = "")
-    {
-        $this->collector = $collector;
-        $this->basepath  = $basepath;
-    }
-
-    /**
-     * Find a route that matches the given arguments.
-     * 
-     * @param string $httpMethod
-     * @param string $path
-     *
-     * @throws NotFoundException
-     * @throws MethodNotAllowedException
-     *
-     * @return Route
-     */
-
-    public function match($httpMethod, $path)
-    {
-        $path = $this->parsePath($path);
-
-        if ($route = $this->collector->findStaticRoute($httpMethod, $path)) {
-            return $route;
-        }
-
-        if ($route = $this->matchDynamicRoute($httpMethod, $path)) {
-            return $route;
-        }
-
-        $this->matchSimilarRoute($httpMethod, $path);
-    }
-
-    /**
-     * Find and return the request dynamic route based on the compiled data and Path.
-     *
-     * @param string $httpMethod
-     * @param string $path
-     *
-     * @return Route|false If the request match an array with the action and parameters will
-     *                     be returned otherwise a false will.
-     */
-
-    protected function matchDynamicRoute($httpMethod, $path)
-    {
-        $routes = $this->collector->findDynamicRoutes($httpMethod, $path);
-
-        if (!$routes) {
-            return false;
-        }
-
-        // chunk routes for smaller regex groups using the Sturges' Formula
-        foreach (array_chunk($routes, round(1 + 3.3 * log(count($routes))), true) as $chunk)
-        {
-            array_map([$this, "buildRoute"], $chunk);
-            list($pattern, $map) = $this->buildGroup($chunk);
-
-            if (!preg_match($pattern, $path, $matches)) {
-                continue;
-            }
-
-            /** @var Route $route */
-            $route = $map[count($matches)];
-            // removing the Path from array.
-            unset($matches[0]);
-            // sometimes null values come with the matches so the array_filter must be called first.
-            $route->setParams(array_combine($route->getParams(), array_filter($matches)));
-            // route must know who match them
-            $route->setMatcher($this);
-
-            return $route;
-        }
-
-        return false;
-    }
-
-    /**
-     * Parse the dynamic segments of the pattern and replace then for
-     * corresponding regex.
-     *
-     * @param Route $route
-     * @return Route
-     */
-
-    protected function buildRoute(Route $route)
-    {
-        if ($route->blocked()) {
-            return $route;
-        }
+	/**
+	 * @var Collector
+	 */
+
+	protected $collector;
+
+	/**
+	 * Define a basepath to all routes.
+	 *
+	 * @var string
+	 */
+
+	protected $basepath = "";
+
+	/**
+	 * Construct the route dispatcher.
+	 *
+	 * @param Collector $collector
+	 * @param string $basepath Define a Path prefix that must be excluded on matches.
+	 */
+
+	public function __construct(Collector $collector, $basepath = "")
+	{
+		$this->collector = $collector;
+		$this->basepath  = $basepath;
+	}
+
+	/**
+	 * Find a route that matches the given arguments.
+	 * 
+	 * @param string $httpMethod
+	 * @param string $path
+	 *
+	 * @throws NotFoundException
+	 * @throws MethodNotAllowedException
+	 *
+	 * @return Route
+	 */
+
+	public function match($httpMethod, $path)
+	{
+		$path = $this->parsePath($path);
+
+		if ($route = $this->collector->findStaticRoute($httpMethod, $path)) {
+			return $route;
+		}
+
+		if ($route = $this->matchDynamicRoute($httpMethod, $path)) {
+			return $route;
+		}
+
+		$this->matchSimilarRoute($httpMethod, $path);
+	}
+
+	/**
+	 * Find and return the request dynamic route based on the compiled data and Path.
+	 *
+	 * @param string $httpMethod
+	 * @param string $path
+	 *
+	 * @return Route|false If the request match an array with the action and parameters will
+	 *                     be returned otherwise a false will.
+	 */
+
+	protected function matchDynamicRoute($httpMethod, $path)
+	{
+		$routes = $this->collector->findDynamicRoutes($httpMethod, $path);
+
+		if (!$routes) {
+			return false;
+		}
+
+		// chunk routes for smaller regex groups using the Sturges' Formula
+		foreach (array_chunk($routes, round(1 + 3.3 * log(count($routes))), true) as $chunk)
+		{
+			array_map([$this, "buildRoute"], $chunk);
+			list($pattern, $map) = $this->buildGroup($chunk);
+
+			if (!preg_match($pattern, $path, $matches)) {
+				continue;
+			}
+
+			/** @var Route $route */
+			$route = $map[count($matches)];
+			// removing the Path from array.
+			unset($matches[0]);
+			// sometimes null values come with the matches so the array_filter must be called first.
+			$route->setParams(array_combine($route->getParams(), array_filter($matches)));
+			// route must know who match them
+			$route->setMatcher($this);
+
+			return $route;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Parse the dynamic segments of the pattern and replace then for
+	 * corresponding regex.
+	 *
+	 * @param Route $route
+	 * @return Route
+	 */
+
+	protected function buildRoute(Route $route)
+	{
+		if ($route->blocked()) {
+			return $route;
+		}
         
-        list($pattern, $params) = $this->parsePlaceholders($route->getPattern());
-        return  $route->setPatternWithoutReset($pattern)->setParams($params)->block();
-    }
-
-    /**
-     * Group several dynamic routes patterns into one big regex and maps
-     * the routes to the pattern positions in the big regex.
-     *
-     * @param array $routes
-     * @return array
-     */
-
-    protected function buildGroup(array $routes)
-    {
-        $groupCount = (int) $map = $regex = [];
-
-        /** @var Route $route */
-        foreach ($routes as $route) {
-            $params           = $route->getParams();
-            $paramsCount      = count($params);
-            $groupCount       = max($groupCount, $paramsCount) + 1;
-            $regex[]          = $route->getPattern() . str_repeat("()", $groupCount - $paramsCount - 1);
-            $map[$groupCount] = $route;
-        }
-
-        return ["~^(?|" . implode("|", $regex) . ")$~", $map];
-    }
-
-    /**
-     * Parse an route pattern seeking for parameters and build the route regex.
-     *
-     * @param string $pattern
-     * @return array 0 => new route regex, 1 => map of parameter names
-     */
-
-    protected function parsePlaceholders($pattern)
-    {
-        $params = [];
-        preg_match_all("~" . Collector::DYNAMIC_REGEX . "~x", $pattern, $matches, PREG_SET_ORDER);
-
-        foreach ((array) $matches as $key => $match) {
-            $pattern = str_replace($match[0], isset($match[2]) ? "({$match[2]})" : "([^/]+)", $pattern);
-            $params[$key] = $match[1];
-        }
-
-        return [$pattern, $params];
-    }
-
-    /**
-     * Get only the path of a given url.
-     *
-     * @param string $path The given URL
-     *
-     * @throws Exception
-     * @return string
-     */
-
-    protected function parsePath($path)
-    {
-        $path = parse_url(substr(strstr(";" . $path, ";" . $this->basepath), strlen(";" . $this->basepath)), PHP_URL_PATH);
-
-        if ($path === false) {
-            throw new Exception("Seriously malformed URL passed to route dispatcher.");
-        }
-
-        return $path;
-    }
-
-    /**
-     * Generate an HTTP error request with method not allowed or not found.
-     *
-     * @param string $httpMethod
-     * @param string $path
-     *
-     * @throws NotFoundException
-     * @throws MethodNotAllowedException
-     */
-
-    protected function matchSimilarRoute($httpMethod, $path)
-    {
-        $dm = [];
-
-        if (($sm = $this->checkStaticRouteInOtherMethods($httpMethod, $path))
-                || ($dm = $this->checkDynamicRouteInOtherMethods($httpMethod, $path))) {
-            throw new MethodNotAllowedException($httpMethod, $path, array_merge((array) $sm, (array) $dm));
-        }
-
-        throw new NotFoundException($httpMethod, $path);
-    }
-
-    /**
-     * Verify if a static route match in another method than the requested.
-     *
-     * @param string $targetHttpMethod The HTTP method that must not be checked
-     * @param string $path              The Path that must be matched.
-     *
-     * @return array
-     */
-
-    protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
-    {
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
-            return (bool) $this->collector->findStaticRoute($httpMethod, $path);
-        });
-    }
-
-    /**
-     * Verify if a dynamic route match in another method than the requested.
-     *
-     * @param string $targetHttpMethod The HTTP method that must not be checked
-     * @param string $path             The Path that must be matched.
-     *
-     * @return array
-     */
-
-    protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
-    {
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
-            return (bool) $this->matchDynamicRoute($httpMethod, $path);
-        });
-    }
-
-    /**
-     * Strip the given http methods and return all the others.
-     *
-     * @param  array|string
-     * @return array
-     */
-
-    protected function getHttpMethodsBut($targetHttpMethod)
-    {
-        return array_diff(explode(" ", Collector::HTTP_METHODS), (array) $targetHttpMethod);
-    }
-
-    /**
-     * @return Collector
-     */
-
-    public function getCollector()
-    {
-        return $this->collector;
-    }
-
-    /**
-     * @return string
-     */
-
-    public function getBasePath()
-    {
-        return $this->basepath;
-    }
-
-    /**
-     * Set a new basepath, this will be a prefix that must be excluded in
-     * every requested Path.
-     *
-     * @param string $basepath The new basepath
-     */
+		list($pattern, $params) = $this->parsePlaceholders($route->getPattern());
+		return  $route->setPatternWithoutReset($pattern)->setParams($params)->block();
+	}
+
+	/**
+	 * Group several dynamic routes patterns into one big regex and maps
+	 * the routes to the pattern positions in the big regex.
+	 *
+	 * @param array $routes
+	 * @return array
+	 */
+
+	protected function buildGroup(array $routes)
+	{
+		$groupCount = (int) $map = $regex = [];
+
+		/** @var Route $route */
+		foreach ($routes as $route) {
+			$params           = $route->getParams();
+			$paramsCount      = count($params);
+			$groupCount       = max($groupCount, $paramsCount) + 1;
+			$regex[]          = $route->getPattern() . str_repeat("()", $groupCount - $paramsCount - 1);
+			$map[$groupCount] = $route;
+		}
+
+		return ["~^(?|" . implode("|", $regex) . ")$~", $map];
+	}
+
+	/**
+	 * Parse an route pattern seeking for parameters and build the route regex.
+	 *
+	 * @param string $pattern
+	 * @return array 0 => new route regex, 1 => map of parameter names
+	 */
+
+	protected function parsePlaceholders($pattern)
+	{
+		$params = [];
+		preg_match_all("~" . Collector::DYNAMIC_REGEX . "~x", $pattern, $matches, PREG_SET_ORDER);
+
+		foreach ((array) $matches as $key => $match) {
+			$pattern = str_replace($match[0], isset($match[2]) ? "({$match[2]})" : "([^/]+)", $pattern);
+			$params[$key] = $match[1];
+		}
+
+		return [$pattern, $params];
+	}
+
+	/**
+	 * Get only the path of a given url.
+	 *
+	 * @param string $path The given URL
+	 *
+	 * @throws Exception
+	 * @return string
+	 */
+
+	protected function parsePath($path)
+	{
+		$path = parse_url(substr(strstr(";" . $path, ";" . $this->basepath), strlen(";" . $this->basepath)), PHP_URL_PATH);
+
+		if ($path === false) {
+			throw new Exception("Seriously malformed URL passed to route dispatcher.");
+		}
+
+		return $path;
+	}
+
+	/**
+	 * Generate an HTTP error request with method not allowed or not found.
+	 *
+	 * @param string $httpMethod
+	 * @param string $path
+	 *
+	 * @throws NotFoundException
+	 * @throws MethodNotAllowedException
+	 */
+
+	protected function matchSimilarRoute($httpMethod, $path)
+	{
+		$dm = [];
+
+		if (($sm = $this->checkStaticRouteInOtherMethods($httpMethod, $path))
+				|| ($dm = $this->checkDynamicRouteInOtherMethods($httpMethod, $path))) {
+			throw new MethodNotAllowedException($httpMethod, $path, array_merge((array) $sm, (array) $dm));
+		}
+
+		throw new NotFoundException($httpMethod, $path);
+	}
+
+	/**
+	 * Verify if a static route match in another method than the requested.
+	 *
+	 * @param string $targetHttpMethod The HTTP method that must not be checked
+	 * @param string $path              The Path that must be matched.
+	 *
+	 * @return array
+	 */
+
+	protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
+	{
+		return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
+			return (bool) $this->collector->findStaticRoute($httpMethod, $path);
+		});
+	}
+
+	/**
+	 * Verify if a dynamic route match in another method than the requested.
+	 *
+	 * @param string $targetHttpMethod The HTTP method that must not be checked
+	 * @param string $path             The Path that must be matched.
+	 *
+	 * @return array
+	 */
+
+	protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
+	{
+		return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
+			return (bool) $this->matchDynamicRoute($httpMethod, $path);
+		});
+	}
+
+	/**
+	 * Strip the given http methods and return all the others.
+	 *
+	 * @param  array|string
+	 * @return array
+	 */
+
+	protected function getHttpMethodsBut($targetHttpMethod)
+	{
+		return array_diff(explode(" ", Collector::HTTP_METHODS), (array) $targetHttpMethod);
+	}
+
+	/**
+	 * @return Collector
+	 */
+
+	public function getCollector()
+	{
+		return $this->collector;
+	}
+
+	/**
+	 * @return string
+	 */
+
+	public function getBasePath()
+	{
+		return $this->basepath;
+	}
+
+	/**
+	 * Set a new basepath, this will be a prefix that must be excluded in
+	 * every requested Path.
+	 *
+	 * @param string $basepath The new basepath
+	 */
     
-    public function setBasePath($basepath)
-    {
-        $this->basepath = $basepath;
-    }
+	public function setBasePath($basepath)
+	{
+		$this->basepath = $basepath;
+	}
 
 }

src/Resource.php

Braces +3 added lines, -1 removed lines

@@ -173,7 +173,9 @@
         foreach ($segments as $index => $segment) {
             if (strpos($segment, "{") === 0) {
                    $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
-            } else $pattern .= $segment;
+            } else {
+            	$pattern .= $segment;
+            }
         }
 
         return $pattern;

Indentation +158 added lines, -158 removed lines

@@ -20,163 +20,163 @@
 class Resource extends Group
 {
 
-    /**
-     * @inheritdoc
-     * @throws \BadMethodCallException
-     */
-
-    public function setMethod($method)
-    {
-        throw new \BadMethodCallException("Resources can't chance they http method.");
-    }
-
-    /**
-     * Remove the routes without the passed methods.
-     *
-     * @param string|array $methods
-     * @return self
-     */
-
-    public function only($methods)
-    {
-        $this->filterByMethod((array) $methods, false);
-        return $this;
-    }
-
-    /**
-     * Remove the routes with the passed methods.
-     *
-     * @param string|array $methods
-     * @return self
-     */
-
-    public function except($methods)
-    {
-        $this->filterByMethod((array) $methods, true);
-        return $this;
-    }
-
-    /**
-     * Forget the grouped routes filtering by http methods.
-     *
-     * @param array $methods
-     * @param bool $alt Should remove?
-     */
-
-    private function filterByMethod(array $methods, $alt)
-    {
-        $methods = array_flip(array_map('strtolower', $methods));
-
-        foreach ($this->routes as $route) {
-            if (isset($methods[$route->getAction()[1]]) === $alt) {
-                $route->forget();
-            }
-        }
-    }
-
-    /**
-     * Translate the "make" or "edit" from resources path.
-     *
-     * @param string[] $translations
-     * @return self
-     */
-
-    public function translate(array $translations)
-    {
-        /** @var Route $route */
-        foreach ($this->routes as $route) {
-            $action = $route->getAction()[1];
-
-            if ($action === "make" && isset($translations["make"])) {
-                $route->setPatternWithoutReset(str_replace("make", $translations["make"], $route->getPattern()));
-            } else {
-                if ($action === "edit" && isset($translations["edit"])) {
-                    $route->setPatternWithoutReset(str_replace("edit", $translations["edit"], $route->getPattern()));
-                }
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Add a route or a group of routes to the resource, it means that
-     * every added route will now receive the parameters of the resource, like id.
-     *
-     * @param Route|Group $route
-     * @return self
-     */
-
-    public function member($route)
-    {
-        $resource = new Resource;
-        $resource->set($route);
-        $this->nest($resource);
-    }
-
-    /**
-     * Nested routes capture the relation between a resource and another resource.
-     *
-     * @param Resource $resource
-     * @return self
-     */
-
-    public function nest(Resource $resource)
-    {
-        /** @var self $resource */
-        foreach ($this->routes as $route) {
-            if ($route->getAction()[1] === "show") {
-                $this->set($resource->forget()->setPrefix($this->getNestedPrefix($route->getPattern()))); break;
-            }
-        }
-
-        return $this;
-    }
-
-    /**
-     * Nest resources but with only build routes with the minimal amount of information
-     * to uniquely identify the resource.
-     *
-     * @param Resource $resource
-     * @return self
-     */
-
-    public function shallow(Resource $resource)
-    {
-        /** @var self $resource */
-        $newResource = new Resource;
-        $resource->forget();
-        $routes = $resource->all();
-
-        foreach ($routes as $route) {
-            if (strpos("index make create", $route->getAction()[1]) !== false) {
-                $newResource->set($route);
-            }
-        }
-
-        return $this->nest($newResource);
-    }
-
-    /**
-     * Resolve the nesting pattern, setting the prefixes based on
-     * parent resources patterns.
-     *
-     * @param string $pattern
-     * @return string
-     */
-
-    protected function getNestedPrefix($pattern)
-    {
-        $segments = explode("/", $pattern);
-        $pattern = "";
-
-        foreach ($segments as $index => $segment) {
-            if (strpos($segment, "{") === 0) {
-                   $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
-            } else $pattern .= $segment;
-        }
-
-        return $pattern;
-    }
+	/**
+	 * @inheritdoc
+	 * @throws \BadMethodCallException
+	 */
+
+	public function setMethod($method)
+	{
+		throw new \BadMethodCallException("Resources can't chance they http method.");
+	}
+
+	/**
+	 * Remove the routes without the passed methods.
+	 *
+	 * @param string|array $methods
+	 * @return self
+	 */
+
+	public function only($methods)
+	{
+		$this->filterByMethod((array) $methods, false);
+		return $this;
+	}
+
+	/**
+	 * Remove the routes with the passed methods.
+	 *
+	 * @param string|array $methods
+	 * @return self
+	 */
+
+	public function except($methods)
+	{
+		$this->filterByMethod((array) $methods, true);
+		return $this;
+	}
+
+	/**
+	 * Forget the grouped routes filtering by http methods.
+	 *
+	 * @param array $methods
+	 * @param bool $alt Should remove?
+	 */
+
+	private function filterByMethod(array $methods, $alt)
+	{
+		$methods = array_flip(array_map('strtolower', $methods));
+
+		foreach ($this->routes as $route) {
+			if (isset($methods[$route->getAction()[1]]) === $alt) {
+				$route->forget();
+			}
+		}
+	}
+
+	/**
+	 * Translate the "make" or "edit" from resources path.
+	 *
+	 * @param string[] $translations
+	 * @return self
+	 */
+
+	public function translate(array $translations)
+	{
+		/** @var Route $route */
+		foreach ($this->routes as $route) {
+			$action = $route->getAction()[1];
+
+			if ($action === "make" && isset($translations["make"])) {
+				$route->setPatternWithoutReset(str_replace("make", $translations["make"], $route->getPattern()));
+			} else {
+				if ($action === "edit" && isset($translations["edit"])) {
+					$route->setPatternWithoutReset(str_replace("edit", $translations["edit"], $route->getPattern()));
+				}
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Add a route or a group of routes to the resource, it means that
+	 * every added route will now receive the parameters of the resource, like id.
+	 *
+	 * @param Route|Group $route
+	 * @return self
+	 */
+
+	public function member($route)
+	{
+		$resource = new Resource;
+		$resource->set($route);
+		$this->nest($resource);
+	}
+
+	/**
+	 * Nested routes capture the relation between a resource and another resource.
+	 *
+	 * @param Resource $resource
+	 * @return self
+	 */
+
+	public function nest(Resource $resource)
+	{
+		/** @var self $resource */
+		foreach ($this->routes as $route) {
+			if ($route->getAction()[1] === "show") {
+				$this->set($resource->forget()->setPrefix($this->getNestedPrefix($route->getPattern()))); break;
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Nest resources but with only build routes with the minimal amount of information
+	 * to uniquely identify the resource.
+	 *
+	 * @param Resource $resource
+	 * @return self
+	 */
+
+	public function shallow(Resource $resource)
+	{
+		/** @var self $resource */
+		$newResource = new Resource;
+		$resource->forget();
+		$routes = $resource->all();
+
+		foreach ($routes as $route) {
+			if (strpos("index make create", $route->getAction()[1]) !== false) {
+				$newResource->set($route);
+			}
+		}
+
+		return $this->nest($newResource);
+	}
+
+	/**
+	 * Resolve the nesting pattern, setting the prefixes based on
+	 * parent resources patterns.
+	 *
+	 * @param string $pattern
+	 * @return string
+	 */
+
+	protected function getNestedPrefix($pattern)
+	{
+		$segments = explode("/", $pattern);
+		$pattern = "";
+
+		foreach ($segments as $index => $segment) {
+			if (strpos($segment, "{") === 0) {
+				   $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
+			} else $pattern .= $segment;
+		}
+
+		return $pattern;
+	}
 
 }