Passed
Branch dev (8b2306)
by Alex
02:48
created
src/Collector.php 3 patches
Spacing   +5 added lines, -5 removed lines patch added patch discarded remove patch
@@ -61,7 +61,7 @@  discard block
 block discarded – undo
61 61
      * @var array
62 62
      */
63 63
 
64
-    protected $statics  = [];
64
+    protected $statics = [];
65 65
 
66 66
     /**
67 67
      * The dynamic routes have parameters and are stored in a hashtable that every cell have
@@ -123,10 +123,10 @@  discard block
 block discarded – undo
123 123
         return new Group($group);
124 124
     }
125 125
 
126
-    public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
127
-    public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
128
-    public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
129
-    public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
126
+    public function get($pattern, $action) { return $this->set("get", $pattern, $action); }
127
+    public function post($pattern, $action) { return $this->set("post", $pattern, $action); }
128
+    public function put($pattern, $action) { return $this->set("put", $pattern, $action); }
129
+    public function patch($pattern, $action) { return $this->set("patch", $pattern, $action); }
130 130
     public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
131 131
 
132 132
     /**
Please login to merge, or discard this patch.
Braces   +18 added lines, -9 removed lines patch added patch discarded remove patch
@@ -117,7 +117,9 @@  discard block
 block discarded – undo
117 117
             if (strpos($pattern, "{") !== false) {
118 118
                    $index = $this->getDynamicIndex($method, $pattern);
119 119
                    $this->dynamics[$index][$pattern] = $route;
120
-            } else $this->statics[$method][$pattern] = $route;
120
+            } else {
121
+            	$this->statics[$method][$pattern] = $route;
122
+            }
121 123
         }
122 124
 
123 125
         return new Group($group);
@@ -142,8 +144,9 @@  discard block
 block discarded – undo
142 144
     public function match(array $methods, $pattern, $action)
143 145
     {
144 146
         $group = [];
145
-        foreach ($methods as $method)
146
-            $group[] = $this->set($method, $pattern, $action);
147
+        foreach ($methods as $method) {
148
+                    $group[] = $this->set($method, $pattern, $action);
149
+        }
147 150
         return new Group($group);
148 151
     }
149 152
 
@@ -186,8 +189,9 @@  discard block
 block discarded – undo
186 189
     public function group(array $routes)
187 190
     {
188 191
         $group = [];
189
-        foreach ($routes as $route)
190
-            $group[] = $route;
192
+        foreach ($routes as $route) {
193
+                    $group[] = $route;
194
+        }
191 195
         return new Group($group);
192 196
     }
193 197
 
@@ -202,7 +206,9 @@  discard block
 block discarded – undo
202 206
     {
203 207
         if (strpos($pattern, "{") === false) {
204 208
                unset($this->statics[$method][$pattern]);
205
-        } else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
209
+        } else {
210
+        	unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
211
+        }
206 212
     }
207 213
 
208 214
     /**
@@ -257,7 +263,9 @@  discard block
 block discarded – undo
257 263
         if ($closingNumber !== count($segments) - 1) {
258 264
             if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
259 265
                    throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
260
-            } else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
266
+            } else {
267
+            	throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
268
+            }
261 269
         }
262 270
     }
263 271
 
@@ -301,8 +309,9 @@  discard block
 block discarded – undo
301 309
     public function findStaticRoute($method, $pattern)
302 310
     {
303 311
         $method = strtolower($method);
304
-        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
305
-            return $this->statics[$method][$pattern];
312
+        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern])) {
313
+                    return $this->statics[$method][$pattern];
314
+        }
306 315
         return false;
307 316
     }
308 317
 
Please login to merge, or discard this patch.
Indentation   +316 added lines, -316 removed lines patch added patch discarded remove patch
@@ -33,321 +33,321 @@
 block discarded – undo
33 33
 class Collector
34 34
 {
35 35
 
36
-    use Collectors\ControllerCollectorTrait;
37
-    use Collectors\ResourceCollectorTrait;
38
-
39
-    /**
40
-     * These regex define the structure of a dynamic segment in a pattern.
41
-     *
42
-     * @var string
43
-     */
44
-
45
-    const DYNAMIC_REGEX = "{\s*(\w*)\s*(?::\s*([^{}]*(?:{(?-1)}*)*))?\s*}";
46
-
47
-
48
-    /**
49
-     * All the supported http methods separated by spaces.
50
-     *
51
-     * @var string
52
-     */
53
-
54
-    const HTTP_METHODS = "get post put patch delete";
55
-
56
-    /**
57
-     * The static routes are simple stored in a multidimensional array, the first
58
-     * dimension is indexed by an http method and hold an array indexed with the patterns
59
-     * and holding the route. ex. [METHOD => [PATTERN => ROUTE]]
60
-     *
61
-     * @var array
62
-     */
63
-
64
-    protected $statics  = [];
65
-
66
-    /**
67
-     * The dynamic routes have parameters and are stored in a hashtable that every cell have
68
-     * an array with route patterns as indexes and routes as values. ex. [INDEX => [PATTERN => ROUTE]]
69
-     *
70
-     * @var array
71
-     */
72
-
73
-    protected $dynamics = [];
74
-
75
-    /**
76
-     * Some regex wildcards for easily definition of dynamic routes.
77
-     *
78
-     * @var array
79
-     */
80
-
81
-    protected $wildcards = [
82
-        "uid"     => "uid-[a-zA-Z0-9]",
83
-        "slug"    => "[a-z0-9-]",
84
-        "string"  => "\w",
85
-        "int"     => "\d",
86
-        "integer" => "\d",
87
-        "float"   => "[-+]?\d*?[.]?\d",
88
-        "double"  => "[-+]?\d*?[.]?\d",
89
-        "hex"     => "0[xX][0-9a-fA-F]",
90
-        "octal"   => "0[1-7][0-7]",
91
-        "bool"    => "1|0|true|false|yes|no",
92
-        "boolean" => "1|0|true|false|yes|no",
93
-    ];
94
-
95
-    /**
96
-     * @param string $method
97
-     * @param string $pattern
98
-     * @param string|array|\Closure $action
99
-     *
100
-     * @throws BadRouteException 
101
-     * @throws MethodNotSupportedException
102
-     *
103
-     * @return Group
104
-     */
105
-
106
-    public function set($method, $pattern, $action)
107
-    {
108
-        $method   = $this->parseMethod($method);
109
-        $patterns = $this->parsePattern($pattern);
110
-        $group    = [];
111
-
112
-        foreach ($patterns as $pattern)
113
-        {
114
-            $route   = new Route($this, $method, $pattern, $action);
115
-            $group[] = $route;
116
-
117
-            if (strpos($pattern, "{") !== false) {
118
-                   $index = $this->getDynamicIndex($method, $pattern);
119
-                   $this->dynamics[$index][$pattern] = $route;
120
-            } else $this->statics[$method][$pattern] = $route;
121
-        }
122
-
123
-        return new Group($group);
124
-    }
125
-
126
-    public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
127
-    public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
128
-    public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
129
-    public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
130
-    public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
131
-
132
-    /**
133
-     * Insert a route into several http methods.
134
-     *
135
-     * @param string[] $methods
136
-     * @param string   $pattern
137
-     * @param Callable $action
138
-     *
139
-     * @return Group
140
-     */
141
-
142
-    public function match(array $methods, $pattern, $action)
143
-    {
144
-        $group = [];
145
-        foreach ($methods as $method)
146
-            $group[] = $this->set($method, $pattern, $action);
147
-        return new Group($group);
148
-    }
149
-
150
-    /**
151
-     * Insert a route into every http method supported.
152
-     *
153
-     * @param string   $pattern
154
-     * @param Callable $action
155
-     *
156
-     * @return Group
157
-     */
158
-
159
-    public function any($pattern, $action)
160
-    {
161
-        return $this->match(explode(" ", self::HTTP_METHODS), $pattern, $action);
162
-    }
163
-
164
-    /**
165
-     * Insert a route into every http method supported but the given ones.
166
-     *
167
-     * @param string[] $methods
168
-     * @param string   $pattern
169
-     * @param Callable $action
170
-     *
171
-     * @return Group
172
-     */
173
-
174
-    public function except(array $methods, $pattern, $action)
175
-    {
176
-        return $this->match(array_diff(explode(" ", self::HTTP_METHODS), $methods), $pattern, $action);
177
-    }
178
-
179
-    /**
180
-     * Group all given routes.
181
-     *
182
-     * @param Route[] $routes
183
-     * @return Group
184
-     */
185
-
186
-    public function group(array $routes)
187
-    {
188
-        $group = [];
189
-        foreach ($routes as $route)
190
-            $group[] = $route;
191
-        return new Group($group);
192
-    }
193
-
194
-    /**
195
-     * Remove a route from collector.
196
-     *
197
-     * @param string $method
198
-     * @param string $pattern
199
-     */
200
-
201
-    public function forget($method, $pattern)
202
-    {
203
-        if (strpos($pattern, "{") === false) {
204
-               unset($this->statics[$method][$pattern]);
205
-        } else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
206
-    }
207
-
208
-    /**
209
-     * Determine if the http method is valid.
210
-     *
211
-     * @param string $method
212
-     * @throws MethodNotSupportedException
213
-     * @return string
214
-     */
215
-
216
-    protected function parseMethod($method)
217
-    {
218
-        $method = strtolower($method);
219
-
220
-        if (strpos(self::HTTP_METHODS, $method) === false) {
221
-            throw new MethodNotSupportedException($method);
222
-        }
223
-
224
-        return $method;
225
-    }
226
-
227
-    /**
228
-     * Separate routes pattern with optional parts into n new patterns.
229
-     *
230
-     * @param  string $pattern
231
-     * @return array
232
-     */
233
-
234
-    protected function parsePattern($pattern)
235
-    {
236
-        $withoutClosing = rtrim($pattern, "]");
237
-        $closingNumber  = strlen($pattern) - strlen($withoutClosing);
238
-
239
-        $segments = preg_split("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\[~x", $withoutClosing);
240
-        $this->parseSegments($segments, $closingNumber, $withoutClosing);
241
-
242
-        return $this->buildSegments($segments);
243
-    }
244
-
245
-    /**
246
-     * Parse all the possible patterns seeking for an incorrect or incompatible pattern.
247
-     *
248
-     * @param string[] $segments       Segments are all the possible patterns made on top of a pattern with optional segments.
249
-     * @param int      $closingNumber  The count of optional segments.
250
-     * @param string   $withoutClosing The pattern without the closing token of an optional segment. aka: ]
251
-     *
252
-     * @throws BadRouteException
253
-     */
254
-
255
-    protected function parseSegments(array $segments, $closingNumber, $withoutClosing)
256
-    {
257
-        if ($closingNumber !== count($segments) - 1) {
258
-            if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
259
-                   throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
260
-            } else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
261
-        }
262
-    }
263
-
264
-    /**
265
-     * @param string[] $segments
266
-     *
267
-     * @throws BadRouteException
268
-     * @return array
269
-     */
270
-
271
-    protected function buildSegments(array $segments)
272
-    {
273
-        $pattern  = "";
274
-        $patterns = [];
275
-        $wildcardTokens = [];
276
-        $wildcardRegex  = [];
277
-
278
-        foreach ($this->wildcards as $token => $regex) {
279
-            $wildcardTokens[] = ":$token";
280
-            $wildcardRegex [] = ":$regex";
281
-        }
282
-
283
-        foreach ($segments as $n => $segment) {
284
-            if ($segment === "" && $n !== 0) {
285
-                throw new BadRouteException(BadRouteException::EMPTY_OPTIONAL_PARTS);
286
-            }
287
-
288
-            $patterns[] = $pattern .= str_replace($wildcardTokens, $wildcardRegex, $segment);
289
-        }
290
-
291
-        return $patterns;
292
-    }
293
-
294
-    /**
295
-     * @param string $method
296
-     * @param string $pattern
297
-     *
298
-     * @return Route|false
299
-     */
300
-
301
-    public function findStaticRoute($method, $pattern)
302
-    {
303
-        $method = strtolower($method);
304
-        if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
305
-            return $this->statics[$method][$pattern];
306
-        return false;
307
-    }
308
-
309
-    /**
310
-     * @param string $method
311
-     * @param string $pattern
312
-     *
313
-     * @return array|false
314
-     */
315
-
316
-    public function findDynamicRoutes($method, $pattern)
317
-    {
318
-        $index = $this->getDynamicIndex($method, $pattern);
319
-        return isset($this->dynamics[$index]) ? $this->dynamics[$index] : false;
320
-    }
321
-
322
-    /**
323
-     * @param string $method
324
-     * @param string $pattern
325
-     *
326
-     * @return int
327
-     */
328
-
329
-    protected function getDynamicIndex($method, $pattern)
330
-    {
331
-        return crc32(strtolower($method)) + substr_count($pattern, "/");
332
-    }
333
-
334
-    /**
335
-     * @return string[]
336
-     */
337
-
338
-    public function getWildcards()
339
-    {
340
-        return $this->wildcards;
341
-    }
342
-
343
-    /**
344
-     * @param string $pattern
345
-     * @param string $wildcard
346
-     */
347
-
348
-    public function setWildcard($pattern, $wildcard)
349
-    {
350
-        $this->wildcards[$pattern] = $wildcard;
351
-    }
36
+	use Collectors\ControllerCollectorTrait;
37
+	use Collectors\ResourceCollectorTrait;
38
+
39
+	/**
40
+	 * These regex define the structure of a dynamic segment in a pattern.
41
+	 *
42
+	 * @var string
43
+	 */
44
+
45
+	const DYNAMIC_REGEX = "{\s*(\w*)\s*(?::\s*([^{}]*(?:{(?-1)}*)*))?\s*}";
46
+
47
+
48
+	/**
49
+	 * All the supported http methods separated by spaces.
50
+	 *
51
+	 * @var string
52
+	 */
53
+
54
+	const HTTP_METHODS = "get post put patch delete";
55
+
56
+	/**
57
+	 * The static routes are simple stored in a multidimensional array, the first
58
+	 * dimension is indexed by an http method and hold an array indexed with the patterns
59
+	 * and holding the route. ex. [METHOD => [PATTERN => ROUTE]]
60
+	 *
61
+	 * @var array
62
+	 */
63
+
64
+	protected $statics  = [];
65
+
66
+	/**
67
+	 * The dynamic routes have parameters and are stored in a hashtable that every cell have
68
+	 * an array with route patterns as indexes and routes as values. ex. [INDEX => [PATTERN => ROUTE]]
69
+	 *
70
+	 * @var array
71
+	 */
72
+
73
+	protected $dynamics = [];
74
+
75
+	/**
76
+	 * Some regex wildcards for easily definition of dynamic routes.
77
+	 *
78
+	 * @var array
79
+	 */
80
+
81
+	protected $wildcards = [
82
+		"uid"     => "uid-[a-zA-Z0-9]",
83
+		"slug"    => "[a-z0-9-]",
84
+		"string"  => "\w",
85
+		"int"     => "\d",
86
+		"integer" => "\d",
87
+		"float"   => "[-+]?\d*?[.]?\d",
88
+		"double"  => "[-+]?\d*?[.]?\d",
89
+		"hex"     => "0[xX][0-9a-fA-F]",
90
+		"octal"   => "0[1-7][0-7]",
91
+		"bool"    => "1|0|true|false|yes|no",
92
+		"boolean" => "1|0|true|false|yes|no",
93
+	];
94
+
95
+	/**
96
+	 * @param string $method
97
+	 * @param string $pattern
98
+	 * @param string|array|\Closure $action
99
+	 *
100
+	 * @throws BadRouteException 
101
+	 * @throws MethodNotSupportedException
102
+	 *
103
+	 * @return Group
104
+	 */
105
+
106
+	public function set($method, $pattern, $action)
107
+	{
108
+		$method   = $this->parseMethod($method);
109
+		$patterns = $this->parsePattern($pattern);
110
+		$group    = [];
111
+
112
+		foreach ($patterns as $pattern)
113
+		{
114
+			$route   = new Route($this, $method, $pattern, $action);
115
+			$group[] = $route;
116
+
117
+			if (strpos($pattern, "{") !== false) {
118
+				   $index = $this->getDynamicIndex($method, $pattern);
119
+				   $this->dynamics[$index][$pattern] = $route;
120
+			} else $this->statics[$method][$pattern] = $route;
121
+		}
122
+
123
+		return new Group($group);
124
+	}
125
+
126
+	public function get   ($pattern, $action) { return $this->set("get"   , $pattern, $action); }
127
+	public function post  ($pattern, $action) { return $this->set("post"  , $pattern, $action); }
128
+	public function put   ($pattern, $action) { return $this->set("put"   , $pattern, $action); }
129
+	public function patch ($pattern, $action) { return $this->set("patch" , $pattern, $action); }
130
+	public function delete($pattern, $action) { return $this->set("delete", $pattern, $action); }
131
+
132
+	/**
133
+	 * Insert a route into several http methods.
134
+	 *
135
+	 * @param string[] $methods
136
+	 * @param string   $pattern
137
+	 * @param Callable $action
138
+	 *
139
+	 * @return Group
140
+	 */
141
+
142
+	public function match(array $methods, $pattern, $action)
143
+	{
144
+		$group = [];
145
+		foreach ($methods as $method)
146
+			$group[] = $this->set($method, $pattern, $action);
147
+		return new Group($group);
148
+	}
149
+
150
+	/**
151
+	 * Insert a route into every http method supported.
152
+	 *
153
+	 * @param string   $pattern
154
+	 * @param Callable $action
155
+	 *
156
+	 * @return Group
157
+	 */
158
+
159
+	public function any($pattern, $action)
160
+	{
161
+		return $this->match(explode(" ", self::HTTP_METHODS), $pattern, $action);
162
+	}
163
+
164
+	/**
165
+	 * Insert a route into every http method supported but the given ones.
166
+	 *
167
+	 * @param string[] $methods
168
+	 * @param string   $pattern
169
+	 * @param Callable $action
170
+	 *
171
+	 * @return Group
172
+	 */
173
+
174
+	public function except(array $methods, $pattern, $action)
175
+	{
176
+		return $this->match(array_diff(explode(" ", self::HTTP_METHODS), $methods), $pattern, $action);
177
+	}
178
+
179
+	/**
180
+	 * Group all given routes.
181
+	 *
182
+	 * @param Route[] $routes
183
+	 * @return Group
184
+	 */
185
+
186
+	public function group(array $routes)
187
+	{
188
+		$group = [];
189
+		foreach ($routes as $route)
190
+			$group[] = $route;
191
+		return new Group($group);
192
+	}
193
+
194
+	/**
195
+	 * Remove a route from collector.
196
+	 *
197
+	 * @param string $method
198
+	 * @param string $pattern
199
+	 */
200
+
201
+	public function forget($method, $pattern)
202
+	{
203
+		if (strpos($pattern, "{") === false) {
204
+			   unset($this->statics[$method][$pattern]);
205
+		} else unset($this->dynamics[$this->getDynamicIndex($method, $pattern)][$pattern]);
206
+	}
207
+
208
+	/**
209
+	 * Determine if the http method is valid.
210
+	 *
211
+	 * @param string $method
212
+	 * @throws MethodNotSupportedException
213
+	 * @return string
214
+	 */
215
+
216
+	protected function parseMethod($method)
217
+	{
218
+		$method = strtolower($method);
219
+
220
+		if (strpos(self::HTTP_METHODS, $method) === false) {
221
+			throw new MethodNotSupportedException($method);
222
+		}
223
+
224
+		return $method;
225
+	}
226
+
227
+	/**
228
+	 * Separate routes pattern with optional parts into n new patterns.
229
+	 *
230
+	 * @param  string $pattern
231
+	 * @return array
232
+	 */
233
+
234
+	protected function parsePattern($pattern)
235
+	{
236
+		$withoutClosing = rtrim($pattern, "]");
237
+		$closingNumber  = strlen($pattern) - strlen($withoutClosing);
238
+
239
+		$segments = preg_split("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\[~x", $withoutClosing);
240
+		$this->parseSegments($segments, $closingNumber, $withoutClosing);
241
+
242
+		return $this->buildSegments($segments);
243
+	}
244
+
245
+	/**
246
+	 * Parse all the possible patterns seeking for an incorrect or incompatible pattern.
247
+	 *
248
+	 * @param string[] $segments       Segments are all the possible patterns made on top of a pattern with optional segments.
249
+	 * @param int      $closingNumber  The count of optional segments.
250
+	 * @param string   $withoutClosing The pattern without the closing token of an optional segment. aka: ]
251
+	 *
252
+	 * @throws BadRouteException
253
+	 */
254
+
255
+	protected function parseSegments(array $segments, $closingNumber, $withoutClosing)
256
+	{
257
+		if ($closingNumber !== count($segments) - 1) {
258
+			if (preg_match("~" . self::DYNAMIC_REGEX . "(*SKIP)(*F)|\]~x", $withoutClosing)) {
259
+				   throw new BadRouteException(BadRouteException::OPTIONAL_SEGMENTS_ON_MIDDLE);
260
+			} else throw new BadRouteException(BadRouteException::UNCLOSED_OPTIONAL_SEGMENTS);
261
+		}
262
+	}
263
+
264
+	/**
265
+	 * @param string[] $segments
266
+	 *
267
+	 * @throws BadRouteException
268
+	 * @return array
269
+	 */
270
+
271
+	protected function buildSegments(array $segments)
272
+	{
273
+		$pattern  = "";
274
+		$patterns = [];
275
+		$wildcardTokens = [];
276
+		$wildcardRegex  = [];
277
+
278
+		foreach ($this->wildcards as $token => $regex) {
279
+			$wildcardTokens[] = ":$token";
280
+			$wildcardRegex [] = ":$regex";
281
+		}
282
+
283
+		foreach ($segments as $n => $segment) {
284
+			if ($segment === "" && $n !== 0) {
285
+				throw new BadRouteException(BadRouteException::EMPTY_OPTIONAL_PARTS);
286
+			}
287
+
288
+			$patterns[] = $pattern .= str_replace($wildcardTokens, $wildcardRegex, $segment);
289
+		}
290
+
291
+		return $patterns;
292
+	}
293
+
294
+	/**
295
+	 * @param string $method
296
+	 * @param string $pattern
297
+	 *
298
+	 * @return Route|false
299
+	 */
300
+
301
+	public function findStaticRoute($method, $pattern)
302
+	{
303
+		$method = strtolower($method);
304
+		if (isset($this->statics[$method]) && isset($this->statics[$method][$pattern]))
305
+			return $this->statics[$method][$pattern];
306
+		return false;
307
+	}
308
+
309
+	/**
310
+	 * @param string $method
311
+	 * @param string $pattern
312
+	 *
313
+	 * @return array|false
314
+	 */
315
+
316
+	public function findDynamicRoutes($method, $pattern)
317
+	{
318
+		$index = $this->getDynamicIndex($method, $pattern);
319
+		return isset($this->dynamics[$index]) ? $this->dynamics[$index] : false;
320
+	}
321
+
322
+	/**
323
+	 * @param string $method
324
+	 * @param string $pattern
325
+	 *
326
+	 * @return int
327
+	 */
328
+
329
+	protected function getDynamicIndex($method, $pattern)
330
+	{
331
+		return crc32(strtolower($method)) + substr_count($pattern, "/");
332
+	}
333
+
334
+	/**
335
+	 * @return string[]
336
+	 */
337
+
338
+	public function getWildcards()
339
+	{
340
+		return $this->wildcards;
341
+	}
342
+
343
+	/**
344
+	 * @param string $pattern
345
+	 * @param string $wildcard
346
+	 */
347
+
348
+	public function setWildcard($pattern, $wildcard)
349
+	{
350
+		$this->wildcards[$pattern] = $wildcard;
351
+	}
352 352
     
353 353
 }
Please login to merge, or discard this patch.
src/Collectors/ResourceCollectorTrait.php 3 patches
Indentation   +97 added lines, -97 removed lines patch added patch discarded remove patch
@@ -22,102 +22,102 @@
 block discarded – undo
22 22
 trait ResourceCollectorTrait
23 23
 {
24 24
 
25
-    abstract public function set($method, $pattern, $action);
26
-
27
-    /**
28
-     * A map of all routes of resources.
29
-     *
30
-     * @var array
31
-     */
32
-
33
-    protected $map = [
34
-        "index"  => ["get",    "/{name}"],
35
-        "make"   => ["get",    "/{name}/make"],
36
-        "create" => ["post",   "/{name}"],
37
-        "show"   => ["get",    "/{name}/{id:int+}"],
38
-        "edit"   => ["get",    "/{name}/{id:int+}/edit"],
39
-        "update" => ["put",    "/{name}/{id:int+}"],
40
-        "delete" => ["delete", "/{name}/{id:int+}"],
41
-    ];
42
-
43
-    /**
44
-     * Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. 
45
-     * Instead of declaring separate routes for your index, show, new, edit, create, update and destroy actions, 
46
-     * a resourceful route declares them in a single line of code.
47
-     *
48
-     * @param string $controller The controller name.
49
-     * @param array  $options    Some options like, "as" to name the route pattern, "only" to
50
-     *                           explicit say that only this routes will be registered, and
51
-     *                           "except" that register all the routes except the indicates.
52
-     * @return Resource
53
-     */
54
-
55
-    public function resource($controller, array $options = array())
56
-    {
57
-        $name       = isset($options["prefix"]) ? $options["prefix"] : "";
58
-        $name      .= $this->getResourceName($controller, $options);
59
-        $actions    = $this->getResourceActions($options);
60
-        $resource = new Resource;
61
-
62
-        foreach ($actions as $action => $map) {
63
-            $resource->set($this->set($map[0], $this->getResourcePath($action, $map[1], $name, $options), [$controller, $action]));
64
-        }
65
-
66
-        return $resource;
67
-    }
68
-
69
-    /**
70
-     * Collect several resources at same time.
71
-     *
72
-     * @param array $controllers Several controller names as parameters or an array with all controller names.
73
-     * @return Resource
74
-     */
75
-
76
-    public function resources(array $controllers)
77
-    {
78
-        $resource = new Resource;
79
-        foreach ($controllers as $controller)
80
-            $resource->set($this->resource($controller));
81
-        return $resource;
82
-    }
83
-
84
-    /**
85
-     * @param string $controller
86
-     * @param array $options
87
-     *
88
-     * @return mixed
89
-     */
90
-
91
-    protected function getResourceName($controller, array $options)
92
-    {
93
-        return isset($options["as"]) ? $options["as"] : str_replace("controller", "", strtolower($controller));
94
-    }
95
-
96
-    /**
97
-     * @param  array $options
98
-     * @return array
99
-     */
100
-
101
-    protected function getResourceActions(array $options)
102
-    {
103
-        return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
104
-              (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
105
-    }
106
-
107
-    /**
108
-     * @param string $action
109
-     * @param string $path
110
-     * @param string $name
111
-     * @param string[] $options
112
-     *
113
-     * @return string
114
-     */
115
-
116
-    protected function getResourcePath($action, $path, $name, array $options)
117
-    {
118
-        return str_replace("{name}", $name,
119
-            $action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
120
-           ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
121
-    }
25
+	abstract public function set($method, $pattern, $action);
26
+
27
+	/**
28
+	 * A map of all routes of resources.
29
+	 *
30
+	 * @var array
31
+	 */
32
+
33
+	protected $map = [
34
+		"index"  => ["get",    "/{name}"],
35
+		"make"   => ["get",    "/{name}/make"],
36
+		"create" => ["post",   "/{name}"],
37
+		"show"   => ["get",    "/{name}/{id:int+}"],
38
+		"edit"   => ["get",    "/{name}/{id:int+}/edit"],
39
+		"update" => ["put",    "/{name}/{id:int+}"],
40
+		"delete" => ["delete", "/{name}/{id:int+}"],
41
+	];
42
+
43
+	/**
44
+	 * Resource routing allows you to quickly declare all of the common routes for a given resourceful controller. 
45
+	 * Instead of declaring separate routes for your index, show, new, edit, create, update and destroy actions, 
46
+	 * a resourceful route declares them in a single line of code.
47
+	 *
48
+	 * @param string $controller The controller name.
49
+	 * @param array  $options    Some options like, "as" to name the route pattern, "only" to
50
+	 *                           explicit say that only this routes will be registered, and
51
+	 *                           "except" that register all the routes except the indicates.
52
+	 * @return Resource
53
+	 */
54
+
55
+	public function resource($controller, array $options = array())
56
+	{
57
+		$name       = isset($options["prefix"]) ? $options["prefix"] : "";
58
+		$name      .= $this->getResourceName($controller, $options);
59
+		$actions    = $this->getResourceActions($options);
60
+		$resource = new Resource;
61
+
62
+		foreach ($actions as $action => $map) {
63
+			$resource->set($this->set($map[0], $this->getResourcePath($action, $map[1], $name, $options), [$controller, $action]));
64
+		}
65
+
66
+		return $resource;
67
+	}
68
+
69
+	/**
70
+	 * Collect several resources at same time.
71
+	 *
72
+	 * @param array $controllers Several controller names as parameters or an array with all controller names.
73
+	 * @return Resource
74
+	 */
75
+
76
+	public function resources(array $controllers)
77
+	{
78
+		$resource = new Resource;
79
+		foreach ($controllers as $controller)
80
+			$resource->set($this->resource($controller));
81
+		return $resource;
82
+	}
83
+
84
+	/**
85
+	 * @param string $controller
86
+	 * @param array $options
87
+	 *
88
+	 * @return mixed
89
+	 */
90
+
91
+	protected function getResourceName($controller, array $options)
92
+	{
93
+		return isset($options["as"]) ? $options["as"] : str_replace("controller", "", strtolower($controller));
94
+	}
95
+
96
+	/**
97
+	 * @param  array $options
98
+	 * @return array
99
+	 */
100
+
101
+	protected function getResourceActions(array $options)
102
+	{
103
+		return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
104
+			  (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
105
+	}
106
+
107
+	/**
108
+	 * @param string $action
109
+	 * @param string $path
110
+	 * @param string $name
111
+	 * @param string[] $options
112
+	 *
113
+	 * @return string
114
+	 */
115
+
116
+	protected function getResourcePath($action, $path, $name, array $options)
117
+	{
118
+		return str_replace("{name}", $name,
119
+			$action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
120
+		   ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
121
+	}
122 122
 
123 123
 }
Please login to merge, or discard this patch.
Spacing   +8 added lines, -10 removed lines patch added patch discarded remove patch
@@ -31,12 +31,12 @@  discard block
 block discarded – undo
31 31
      */
32 32
 
33 33
     protected $map = [
34
-        "index"  => ["get",    "/{name}"],
35
-        "make"   => ["get",    "/{name}/make"],
36
-        "create" => ["post",   "/{name}"],
37
-        "show"   => ["get",    "/{name}/{id:int+}"],
38
-        "edit"   => ["get",    "/{name}/{id:int+}/edit"],
39
-        "update" => ["put",    "/{name}/{id:int+}"],
34
+        "index"  => ["get", "/{name}"],
35
+        "make"   => ["get", "/{name}/make"],
36
+        "create" => ["post", "/{name}"],
37
+        "show"   => ["get", "/{name}/{id:int+}"],
38
+        "edit"   => ["get", "/{name}/{id:int+}/edit"],
39
+        "update" => ["put", "/{name}/{id:int+}"],
40 40
         "delete" => ["delete", "/{name}/{id:int+}"],
41 41
     ];
42 42
 
@@ -100,8 +100,7 @@  discard block
 block discarded – undo
100 100
 
101 101
     protected function getResourceActions(array $options)
102 102
     {
103
-        return isset($options["only"])   ? array_intersect_key($this->map, array_flip((array) $options["only"])) :
104
-              (isset($options["except"]) ? array_diff_key($this->map, array_flip((array) $options["except"]))    : $this->map);
103
+        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);
105 104
     }
106 105
 
107 106
     /**
@@ -116,8 +115,7 @@  discard block
 block discarded – undo
116 115
     protected function getResourcePath($action, $path, $name, array $options)
117 116
     {
118 117
         return str_replace("{name}", $name,
119
-            $action === "make" && isset($options["translate"]["make"]) ? str_replace("make", $options["translate"]["make"], $path) :
120
-           ($action === "edit" && isset($options["translate"]["edit"]) ? str_replace("edit", $options["translate"]["edit"], $path) : $path));
118
+            $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));
121 119
     }
122 120
 
123 121
 }
Please login to merge, or discard this patch.
Braces   +3 added lines, -2 removed lines patch added patch discarded remove patch
@@ -76,8 +76,9 @@
 block discarded – undo
76 76
     public function resources(array $controllers)
77 77
     {
78 78
         $resource = new Resource;
79
-        foreach ($controllers as $controller)
80
-            $resource->set($this->resource($controller));
79
+        foreach ($controllers as $controller) {
80
+                    $resource->set($this->resource($controller));
81
+        }
81 82
         return $resource;
82 83
     }
83 84
 
Please login to merge, or discard this patch.
src/Exceptions/BadDispatchStrategyException.php 1 patch
Indentation   +3 added lines, -3 removed lines patch added patch discarded remove patch
@@ -20,8 +20,8 @@
 block discarded – undo
20 20
 class BadDispatchStrategyException extends BadRouteException
21 21
 {
22 22
 
23
-    public function __construct($strategy) {
24
-        parent::__construct("`$strategy` is not a valid route dispatch strategy, it must implement the `Codeburner\Router\DispatchStrategies\DispatchStrategyInterface` interface.");
25
-    }
23
+	public function __construct($strategy) {
24
+		parent::__construct("`$strategy` is not a valid route dispatch strategy, it must implement the `Codeburner\Router\DispatchStrategies\DispatchStrategyInterface` interface.");
25
+	}
26 26
     
27 27
 }
Please login to merge, or discard this patch.
src/Exceptions/MethodNotAllowedException.php 1 patch
Indentation   +55 added lines, -55 removed lines patch added patch discarded remove patch
@@ -20,71 +20,71 @@
 block discarded – undo
20 20
 class MethodNotAllowedException extends BadRouteException
21 21
 {
22 22
 
23
-    /**
24
-     * The HTTP method from request.
25
-     *
26
-     * @var string
27
-     */
23
+	/**
24
+	 * The HTTP method from request.
25
+	 *
26
+	 * @var string
27
+	 */
28 28
 
29
-    public $requestedMethod;
29
+	public $requestedMethod;
30 30
 
31
-    /**
32
-     * The requested URi.
33
-     *
34
-     * @var string
35
-     */
31
+	/**
32
+	 * The requested URi.
33
+	 *
34
+	 * @var string
35
+	 */
36 36
 
37
-    public $requestedUri;
37
+	public $requestedUri;
38 38
 
39
-    /**
40
-     * All the allowed HTTP methods and routes for the request.
41
-     *
42
-     * @var array
43
-     */
39
+	/**
40
+	 * All the allowed HTTP methods and routes for the request.
41
+	 *
42
+	 * @var array
43
+	 */
44 44
 
45
-    public $allowedMethods;
45
+	public $allowedMethods;
46 46
 	
47
-    /**
48
-     * Exception constructor.
49
-     *
50
-     * @param string  $requestedMethod The request HTTP method.
51
-     * @param string  $requestedUri    The request URi.
52
-     * @param array   $allowedMethods  All the allowed HTTP methods and routes for the request.
53
-     * @param string  $message         The exception error message.
54
-     * @param integer $code            The exception error code.
55
-     */
47
+	/**
48
+	 * Exception constructor.
49
+	 *
50
+	 * @param string  $requestedMethod The request HTTP method.
51
+	 * @param string  $requestedUri    The request URi.
52
+	 * @param array   $allowedMethods  All the allowed HTTP methods and routes for the request.
53
+	 * @param string  $message         The exception error message.
54
+	 * @param integer $code            The exception error code.
55
+	 */
56 56
 
57
-    public function __construct($requestedMethod, $requestedUri, array $allowedMethods, $message = null, $code = 405)
58
-    {
59
-        $this->requestedMethod = $requestedMethod;
60
-        $this->requestedUri    = $requestedUri;
61
-        $this->allowedMethods  = $allowedMethods;
62
-        parent::__construct($message, $code);
63
-    }
57
+	public function __construct($requestedMethod, $requestedUri, array $allowedMethods, $message = null, $code = 405)
58
+	{
59
+		$this->requestedMethod = $requestedMethod;
60
+		$this->requestedUri    = $requestedUri;
61
+		$this->allowedMethods  = $allowedMethods;
62
+		parent::__construct($message, $code);
63
+	}
64 64
 
65
-    /**
66
-     * Verify if the given HTTP method is allowed for the request.
67
-     *
68
-     * @param string An HTTP method
69
-     * @return bool
70
-     */
65
+	/**
66
+	 * Verify if the given HTTP method is allowed for the request.
67
+	 *
68
+	 * @param string An HTTP method
69
+	 * @return bool
70
+	 */
71 71
 
72
-    public function can($method)
73
-    {
74
-        return isset($this->allowedMethods[strtoupper($method)]);
75
-    }
72
+	public function can($method)
73
+	{
74
+		return isset($this->allowedMethods[strtoupper($method)]);
75
+	}
76 76
 
77
-    /**
78
-     * The HTTP specification requires that a 405 Method Not Allowed response include the 
79
-     * Allow: header to detail available methods for the requested resource.
80
-     *
81
-     * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html section 14.7
82
-     * @return string
83
-     */
77
+	/**
78
+	 * The HTTP specification requires that a 405 Method Not Allowed response include the 
79
+	 * Allow: header to detail available methods for the requested resource.
80
+	 *
81
+	 * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html section 14.7
82
+	 * @return string
83
+	 */
84 84
     
85
-    public function allowed()
86
-    {
87
-        return implode(', ', array_keys($this->allowedMethods));
88
-    }
85
+	public function allowed()
86
+	{
87
+		return implode(', ', array_keys($this->allowedMethods));
88
+	}
89 89
 
90 90
 }
Please login to merge, or discard this patch.
src/Exceptions/MethodNotSupportedException.php 1 patch
Indentation   +3 added lines, -3 removed lines patch added patch discarded remove patch
@@ -20,8 +20,8 @@
 block discarded – undo
20 20
 class MethodNotSupportedException extends BadRouteException
21 21
 {
22 22
 
23
-    public function __construct($method) {
24
-        parent::__construct("The HTTP method '$method' is not supported by the route collector.");
25
-    }
23
+	public function __construct($method) {
24
+		parent::__construct("The HTTP method '$method' is not supported by the route collector.");
25
+	}
26 26
 
27 27
 }
Please login to merge, or discard this patch.
src/Exceptions/NotFoundException.php 1 patch
Indentation   +27 added lines, -27 removed lines patch added patch discarded remove patch
@@ -19,36 +19,36 @@
 block discarded – undo
19 19
 class NotFoundException extends \Exception
20 20
 {
21 21
 
22
-    /**
23
-     * The HTTP method from request.
24
-     *
25
-     * @var string
26
-     */
22
+	/**
23
+	 * The HTTP method from request.
24
+	 *
25
+	 * @var string
26
+	 */
27 27
 
28
-    public $requestedMethod;
28
+	public $requestedMethod;
29 29
 
30
-    /**
31
-     * The requested Path.
32
-     *
33
-     * @var string
34
-     */
30
+	/**
31
+	 * The requested Path.
32
+	 *
33
+	 * @var string
34
+	 */
35 35
 
36
-    public $requestedPath;
36
+	public $requestedPath;
37 37
     
38
-    /**
39
-     * Exception constructor.
40
-     *
41
-     * @param string  $requestedMethod  The request HTTP method.
42
-     * @param string  $requestedPath    The request Path.
43
-     * @param string  $message          The exception error message.
44
-     * @param integer $code             The exception error code.
45
-     */
46
-
47
-    public function __construct($requestedMethod, $requestedPath, $message = null, $code = 405)
48
-    {
49
-        $this->requestedMethod = $requestedMethod;
50
-        $this->requestedPath = $requestedPath;
51
-        parent::__construct($message, $code);
52
-    }
38
+	/**
39
+	 * Exception constructor.
40
+	 *
41
+	 * @param string  $requestedMethod  The request HTTP method.
42
+	 * @param string  $requestedPath    The request Path.
43
+	 * @param string  $message          The exception error message.
44
+	 * @param integer $code             The exception error code.
45
+	 */
46
+
47
+	public function __construct($requestedMethod, $requestedPath, $message = null, $code = 405)
48
+	{
49
+		$this->requestedMethod = $requestedMethod;
50
+		$this->requestedPath = $requestedPath;
51
+		parent::__construct($message, $code);
52
+	}
53 53
 	
54 54
 }
Please login to merge, or discard this patch.
src/Group.php 2 patches
Indentation   +250 added lines, -250 removed lines patch added patch discarded remove patch
@@ -19,255 +19,255 @@
 block discarded – undo
19 19
 class Group
20 20
 {
21 21
 
22
-    /**
23
-     * All grouped route objects.
24
-     *
25
-     * @var Route[]
26
-     */
27
-
28
-    protected $routes;
29
-
30
-    /**
31
-     * Group constructor.
32
-     *
33
-     * @param Route[] $routes
34
-     */
35
-
36
-    public function __construct(array $routes = [])
37
-    {
38
-        $this->routes = $routes;
39
-    }
40
-
41
-    /**
42
-     * Set a new Route or merge an existing group of routes.
43
-     *
44
-     * @param Group|Route $route
45
-     * @return self
46
-     */
47
-
48
-    public function set($route)
49
-    {
50
-        if ($route instanceof Group) {
51
-            foreach ($route->all() as $r)
52
-                $this->routes[] = $r;
53
-        } else  $this->routes[] = $route;
54
-        return  $this;
55
-    }
56
-
57
-    /**
58
-     * Return all grouped routes objects.
59
-     *
60
-     * @return Route[]
61
-     */
62
-
63
-    public function all()
64
-    {
65
-        return $this->routes;
66
-    }
67
-
68
-    /**
69
-     * Get a specific route of the group, routes receive a key based on
70
-     * the order they are added to the group.
71
-     *
72
-     * @param int $number
73
-     * @return Route
74
-     */
75
-
76
-    public function nth($number)
77
-    {
78
-        return $this->routes[$number];
79
-    }
80
-
81
-    /**
82
-     * Forget the registration of all grouped routes on to collector.
83
-     * After the forget the route object will still exist but will not
84
-     * count for the matcher.
85
-     *
86
-     * @return self
87
-     */
88
-
89
-    public function forget()
90
-    {
91
-        foreach ($this->routes as $route)
92
-            $route->forget();
93
-        return $this;
94
-    }
95
-
96
-    /**
97
-     * Set one HTTP method to all grouped routes.
98
-     *
99
-     * @param string $method The HTTP Method
100
-     * @return self
101
-     */
102
-
103
-    public function setMethod($method)
104
-    {
105
-        foreach ($this->routes as $route)
106
-            $route->setMethod($method);
107
-        return $this;
108
-    }
109
-
110
-    /**
111
-     * Set one action to all grouped routes.
112
-     *
113
-     * @param string $action
114
-     * @return self
115
-     */
116
-
117
-    public function setAction($action)
118
-    {
119
-        foreach ($this->routes as $route)
120
-            $route->setAction($action);
121
-        return $this;
122
-    }
123
-
124
-    /**
125
-     * Set one namespace to all grouped routes.
126
-     *
127
-     * @param string $namespace
128
-     * @return self
129
-     */
130
-
131
-    public function setNamespace($namespace)
132
-    {
133
-        foreach ($this->routes as $route)
134
-            $route->setNamespace($namespace);
135
-        return $this;
136
-    }
137
-
138
-    /**
139
-     * Add a prefix to all grouped routes pattern.
140
-     *
141
-     * @param string $prefix
142
-     * @return self
143
-     */
144
-
145
-    public function setPrefix($prefix)
146
-    {
147
-        $prefix = "/" . ltrim($prefix, "/");
148
-        foreach ($this->routes as $route)
149
-            $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
150
-        return $this;
151
-    }
152
-
153
-    /**
154
-     * Set metadata to all grouped routes.
155
-     *
156
-     * @param string $key
157
-     * @param string $value
158
-     *
159
-     * @return $this
160
-     */
161
-
162
-    public function setMetadata($key, $value)
163
-    {
164
-        foreach ($this->routes as $route)
165
-            $route->setMetadata($key, $value);
166
-        return $this;
167
-    }
168
-
169
-    /**
170
-     * Set a bunch of metadata to all grouped routes.
171
-     *
172
-     * @param mixed[] $metadata
173
-     * @return $this
174
-     */
175
-
176
-    public function setMetadataArray(array $metadata)
177
-    {
178
-        foreach ($this->routes as $route)
179
-            $route->setMetadataArray($metadata);
180
-        return $this;
181
-    }
182
-
183
-    /**
184
-     * Set default parameters to all grouped routes.
185
-     *
186
-     * @param mixed[] $defaults
187
-     * @return $this
188
-     */
189
-
190
-    public function setDefaults(array $defaults)
191
-    {
192
-        foreach ($this->routes as $route)
193
-            $route->setDefaults($defaults);
194
-        return $this;
195
-    }
196
-
197
-    /**
198
-     * Set a default parameter to all grouped routes.
199
-     *
200
-     * @param string $key
201
-     * @param mixed $value
202
-     *
203
-     * @return $this
204
-     */
205
-
206
-    public function setDefault($key, $value)
207
-    {
208
-        foreach ($this->routes as $route)
209
-            $route->setDefault($key, $value);
210
-        return $this;
211
-    }
212
-
213
-    /**
214
-     * Set one dispatch strategy to all grouped routes.
215
-     *
216
-     * @param string|Strategies\StrategyInterface $strategy
217
-     * @return self
218
-     */
219
-
220
-    public function setStrategy($strategy)
221
-    {
222
-        foreach ($this->routes as $route)
223
-            $route->setStrategy($strategy);
224
-        return $this;
225
-    }
226
-
227
-    /**
228
-     * Replace or define a constraint for all dynamic segments named by $name.
229
-     *
230
-     * @param string $name
231
-     * @param string $regex
232
-     *
233
-     * @return self
234
-     */
235
-
236
-    public function setConstraint($name, $regex)
237
-    {
238
-        foreach ($this->routes as $route) {
239
-            $pattern = $route->getPattern();
240
-            $initPos = strpos($pattern, "{" . $name);
241
-
242
-            if ($initPos !== false) {
243
-                $endPos = strpos($pattern, "}", $initPos);
244
-                $newPattern = substr_replace($pattern, "{" . "$name:$regex" . "}", $initPos, $endPos - $initPos + 1);
245
-                $route->setPatternWithoutReset($newPattern);
246
-            }
247
-        }
248
-
249
-        return $this;
250
-    }
251
-
252
-    /**
253
-     * Define a constraint for a variable in all grouped routes pattern, but don't replace the
254
-     * delimiter if one already exists.
255
-     *
256
-     * @param string $name
257
-     * @param string $regex
258
-     *
259
-     * @return self
260
-     */
261
-
262
-    public function setConstraintPreservingQuantifiers($name, $regex)
263
-    {
264
-        $wildcards = $this->routes[0]->getCollector()->getWildcards();
265
-        $quantifierPos = strpos($regex, "{") + strpos($regex, "+") + strpos($regex, "*");
266
-        $quantifier = substr($regex, $quantifierPos);
267
-        $quantifierErased = $quantifierPos !== false ? substr($regex, 0, $quantifierPos) : null;
268
-        $regex = isset($wildcards[$quantifierErased]) ? $wildcards[$quantifierErased] . $quantifier : $regex;
269
-
270
-        return $this->setConstraint($name, $regex);
271
-    }
22
+	/**
23
+	 * All grouped route objects.
24
+	 *
25
+	 * @var Route[]
26
+	 */
27
+
28
+	protected $routes;
29
+
30
+	/**
31
+	 * Group constructor.
32
+	 *
33
+	 * @param Route[] $routes
34
+	 */
35
+
36
+	public function __construct(array $routes = [])
37
+	{
38
+		$this->routes = $routes;
39
+	}
40
+
41
+	/**
42
+	 * Set a new Route or merge an existing group of routes.
43
+	 *
44
+	 * @param Group|Route $route
45
+	 * @return self
46
+	 */
47
+
48
+	public function set($route)
49
+	{
50
+		if ($route instanceof Group) {
51
+			foreach ($route->all() as $r)
52
+				$this->routes[] = $r;
53
+		} else  $this->routes[] = $route;
54
+		return  $this;
55
+	}
56
+
57
+	/**
58
+	 * Return all grouped routes objects.
59
+	 *
60
+	 * @return Route[]
61
+	 */
62
+
63
+	public function all()
64
+	{
65
+		return $this->routes;
66
+	}
67
+
68
+	/**
69
+	 * Get a specific route of the group, routes receive a key based on
70
+	 * the order they are added to the group.
71
+	 *
72
+	 * @param int $number
73
+	 * @return Route
74
+	 */
75
+
76
+	public function nth($number)
77
+	{
78
+		return $this->routes[$number];
79
+	}
80
+
81
+	/**
82
+	 * Forget the registration of all grouped routes on to collector.
83
+	 * After the forget the route object will still exist but will not
84
+	 * count for the matcher.
85
+	 *
86
+	 * @return self
87
+	 */
88
+
89
+	public function forget()
90
+	{
91
+		foreach ($this->routes as $route)
92
+			$route->forget();
93
+		return $this;
94
+	}
95
+
96
+	/**
97
+	 * Set one HTTP method to all grouped routes.
98
+	 *
99
+	 * @param string $method The HTTP Method
100
+	 * @return self
101
+	 */
102
+
103
+	public function setMethod($method)
104
+	{
105
+		foreach ($this->routes as $route)
106
+			$route->setMethod($method);
107
+		return $this;
108
+	}
109
+
110
+	/**
111
+	 * Set one action to all grouped routes.
112
+	 *
113
+	 * @param string $action
114
+	 * @return self
115
+	 */
116
+
117
+	public function setAction($action)
118
+	{
119
+		foreach ($this->routes as $route)
120
+			$route->setAction($action);
121
+		return $this;
122
+	}
123
+
124
+	/**
125
+	 * Set one namespace to all grouped routes.
126
+	 *
127
+	 * @param string $namespace
128
+	 * @return self
129
+	 */
130
+
131
+	public function setNamespace($namespace)
132
+	{
133
+		foreach ($this->routes as $route)
134
+			$route->setNamespace($namespace);
135
+		return $this;
136
+	}
137
+
138
+	/**
139
+	 * Add a prefix to all grouped routes pattern.
140
+	 *
141
+	 * @param string $prefix
142
+	 * @return self
143
+	 */
144
+
145
+	public function setPrefix($prefix)
146
+	{
147
+		$prefix = "/" . ltrim($prefix, "/");
148
+		foreach ($this->routes as $route)
149
+			$route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
150
+		return $this;
151
+	}
152
+
153
+	/**
154
+	 * Set metadata to all grouped routes.
155
+	 *
156
+	 * @param string $key
157
+	 * @param string $value
158
+	 *
159
+	 * @return $this
160
+	 */
161
+
162
+	public function setMetadata($key, $value)
163
+	{
164
+		foreach ($this->routes as $route)
165
+			$route->setMetadata($key, $value);
166
+		return $this;
167
+	}
168
+
169
+	/**
170
+	 * Set a bunch of metadata to all grouped routes.
171
+	 *
172
+	 * @param mixed[] $metadata
173
+	 * @return $this
174
+	 */
175
+
176
+	public function setMetadataArray(array $metadata)
177
+	{
178
+		foreach ($this->routes as $route)
179
+			$route->setMetadataArray($metadata);
180
+		return $this;
181
+	}
182
+
183
+	/**
184
+	 * Set default parameters to all grouped routes.
185
+	 *
186
+	 * @param mixed[] $defaults
187
+	 * @return $this
188
+	 */
189
+
190
+	public function setDefaults(array $defaults)
191
+	{
192
+		foreach ($this->routes as $route)
193
+			$route->setDefaults($defaults);
194
+		return $this;
195
+	}
196
+
197
+	/**
198
+	 * Set a default parameter to all grouped routes.
199
+	 *
200
+	 * @param string $key
201
+	 * @param mixed $value
202
+	 *
203
+	 * @return $this
204
+	 */
205
+
206
+	public function setDefault($key, $value)
207
+	{
208
+		foreach ($this->routes as $route)
209
+			$route->setDefault($key, $value);
210
+		return $this;
211
+	}
212
+
213
+	/**
214
+	 * Set one dispatch strategy to all grouped routes.
215
+	 *
216
+	 * @param string|Strategies\StrategyInterface $strategy
217
+	 * @return self
218
+	 */
219
+
220
+	public function setStrategy($strategy)
221
+	{
222
+		foreach ($this->routes as $route)
223
+			$route->setStrategy($strategy);
224
+		return $this;
225
+	}
226
+
227
+	/**
228
+	 * Replace or define a constraint for all dynamic segments named by $name.
229
+	 *
230
+	 * @param string $name
231
+	 * @param string $regex
232
+	 *
233
+	 * @return self
234
+	 */
235
+
236
+	public function setConstraint($name, $regex)
237
+	{
238
+		foreach ($this->routes as $route) {
239
+			$pattern = $route->getPattern();
240
+			$initPos = strpos($pattern, "{" . $name);
241
+
242
+			if ($initPos !== false) {
243
+				$endPos = strpos($pattern, "}", $initPos);
244
+				$newPattern = substr_replace($pattern, "{" . "$name:$regex" . "}", $initPos, $endPos - $initPos + 1);
245
+				$route->setPatternWithoutReset($newPattern);
246
+			}
247
+		}
248
+
249
+		return $this;
250
+	}
251
+
252
+	/**
253
+	 * Define a constraint for a variable in all grouped routes pattern, but don't replace the
254
+	 * delimiter if one already exists.
255
+	 *
256
+	 * @param string $name
257
+	 * @param string $regex
258
+	 *
259
+	 * @return self
260
+	 */
261
+
262
+	public function setConstraintPreservingQuantifiers($name, $regex)
263
+	{
264
+		$wildcards = $this->routes[0]->getCollector()->getWildcards();
265
+		$quantifierPos = strpos($regex, "{") + strpos($regex, "+") + strpos($regex, "*");
266
+		$quantifier = substr($regex, $quantifierPos);
267
+		$quantifierErased = $quantifierPos !== false ? substr($regex, 0, $quantifierPos) : null;
268
+		$regex = isset($wildcards[$quantifierErased]) ? $wildcards[$quantifierErased] . $quantifier : $regex;
269
+
270
+		return $this->setConstraint($name, $regex);
271
+	}
272 272
 
273 273
 }
Please login to merge, or discard this patch.
Braces   +36 added lines, -23 removed lines patch added patch discarded remove patch
@@ -48,9 +48,12 @@  discard block
 block discarded – undo
48 48
     public function set($route)
49 49
     {
50 50
         if ($route instanceof Group) {
51
-            foreach ($route->all() as $r)
52
-                $this->routes[] = $r;
53
-        } else  $this->routes[] = $route;
51
+            foreach ($route->all() as $r) {
52
+                            $this->routes[] = $r;
53
+            }
54
+        } else {
55
+        	$this->routes[] = $route;
56
+        }
54 57
         return  $this;
55 58
     }
56 59
 
@@ -88,8 +91,9 @@  discard block
 block discarded – undo
88 91
 
89 92
     public function forget()
90 93
     {
91
-        foreach ($this->routes as $route)
92
-            $route->forget();
94
+        foreach ($this->routes as $route) {
95
+                    $route->forget();
96
+        }
93 97
         return $this;
94 98
     }
95 99
 
@@ -102,8 +106,9 @@  discard block
 block discarded – undo
102 106
 
103 107
     public function setMethod($method)
104 108
     {
105
-        foreach ($this->routes as $route)
106
-            $route->setMethod($method);
109
+        foreach ($this->routes as $route) {
110
+                    $route->setMethod($method);
111
+        }
107 112
         return $this;
108 113
     }
109 114
 
@@ -116,8 +121,9 @@  discard block
 block discarded – undo
116 121
 
117 122
     public function setAction($action)
118 123
     {
119
-        foreach ($this->routes as $route)
120
-            $route->setAction($action);
124
+        foreach ($this->routes as $route) {
125
+                    $route->setAction($action);
126
+        }
121 127
         return $this;
122 128
     }
123 129
 
@@ -130,8 +136,9 @@  discard block
 block discarded – undo
130 136
 
131 137
     public function setNamespace($namespace)
132 138
     {
133
-        foreach ($this->routes as $route)
134
-            $route->setNamespace($namespace);
139
+        foreach ($this->routes as $route) {
140
+                    $route->setNamespace($namespace);
141
+        }
135 142
         return $this;
136 143
     }
137 144
 
@@ -145,8 +152,9 @@  discard block
 block discarded – undo
145 152
     public function setPrefix($prefix)
146 153
     {
147 154
         $prefix = "/" . ltrim($prefix, "/");
148
-        foreach ($this->routes as $route)
149
-            $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
155
+        foreach ($this->routes as $route) {
156
+                    $route->setPattern(rtrim($prefix . $route->getPattern(), "/"));
157
+        }
150 158
         return $this;
151 159
     }
152 160
 
@@ -161,8 +169,9 @@  discard block
 block discarded – undo
161 169
 
162 170
     public function setMetadata($key, $value)
163 171
     {
164
-        foreach ($this->routes as $route)
165
-            $route->setMetadata($key, $value);
172
+        foreach ($this->routes as $route) {
173
+                    $route->setMetadata($key, $value);
174
+        }
166 175
         return $this;
167 176
     }
168 177
 
@@ -175,8 +184,9 @@  discard block
 block discarded – undo
175 184
 
176 185
     public function setMetadataArray(array $metadata)
177 186
     {
178
-        foreach ($this->routes as $route)
179
-            $route->setMetadataArray($metadata);
187
+        foreach ($this->routes as $route) {
188
+                    $route->setMetadataArray($metadata);
189
+        }
180 190
         return $this;
181 191
     }
182 192
 
@@ -189,8 +199,9 @@  discard block
 block discarded – undo
189 199
 
190 200
     public function setDefaults(array $defaults)
191 201
     {
192
-        foreach ($this->routes as $route)
193
-            $route->setDefaults($defaults);
202
+        foreach ($this->routes as $route) {
203
+                    $route->setDefaults($defaults);
204
+        }
194 205
         return $this;
195 206
     }
196 207
 
@@ -205,8 +216,9 @@  discard block
 block discarded – undo
205 216
 
206 217
     public function setDefault($key, $value)
207 218
     {
208
-        foreach ($this->routes as $route)
209
-            $route->setDefault($key, $value);
219
+        foreach ($this->routes as $route) {
220
+                    $route->setDefault($key, $value);
221
+        }
210 222
         return $this;
211 223
     }
212 224
 
@@ -219,8 +231,9 @@  discard block
 block discarded – undo
219 231
 
220 232
     public function setStrategy($strategy)
221 233
     {
222
-        foreach ($this->routes as $route)
223
-            $route->setStrategy($strategy);
234
+        foreach ($this->routes as $route) {
235
+                    $route->setStrategy($strategy);
236
+        }
224 237
         return $this;
225 238
     }
226 239
 
Please login to merge, or discard this patch.
src/Matcher.php 2 patches
Spacing   +2 added lines, -2 removed lines patch added patch discarded remove patch
@@ -235,7 +235,7 @@  discard block
 block discarded – undo
235 235
 
236 236
     protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
237 237
     {
238
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
238
+        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function($httpMethod) use ($path) {
239 239
             return (bool) $this->collector->findStaticRoute($httpMethod, $path);
240 240
         });
241 241
     }
@@ -251,7 +251,7 @@  discard block
 block discarded – undo
251 251
 
252 252
     protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
253 253
     {
254
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
254
+        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function($httpMethod) use ($path) {
255 255
             return (bool) $this->matchDynamicRoute($httpMethod, $path);
256 256
         });
257 257
     }
Please login to merge, or discard this patch.
Indentation   +272 added lines, -272 removed lines patch added patch discarded remove patch
@@ -23,279 +23,279 @@
 block discarded – undo
23 23
 class Matcher
24 24
 {
25 25
 
26
-    /**
27
-     * @var Collector
28
-     */
29
-
30
-    protected $collector;
31
-
32
-    /**
33
-     * Define a basepath to all routes.
34
-     *
35
-     * @var string
36
-     */
37
-
38
-    protected $basepath = "";
39
-
40
-    /**
41
-     * Construct the route dispatcher.
42
-     *
43
-     * @param Collector $collector
44
-     * @param string $basepath Define a Path prefix that must be excluded on matches.
45
-     */
46
-
47
-    public function __construct(Collector $collector, $basepath = "")
48
-    {
49
-        $this->collector = $collector;
50
-        $this->basepath  = $basepath;
51
-    }
52
-
53
-    /**
54
-     * Find a route that matches the given arguments.
55
-     * 
56
-     * @param string $httpMethod
57
-     * @param string $path
58
-     *
59
-     * @throws NotFoundException
60
-     * @throws MethodNotAllowedException
61
-     *
62
-     * @return Route
63
-     */
64
-
65
-    public function match($httpMethod, $path)
66
-    {
67
-        $path = $this->parsePath($path);
68
-
69
-        if ($route = $this->collector->findStaticRoute($httpMethod, $path)) {
70
-            return $route;
71
-        }
72
-
73
-        if ($route = $this->matchDynamicRoute($httpMethod, $path)) {
74
-            return $route;
75
-        }
76
-
77
-        $this->matchSimilarRoute($httpMethod, $path);
78
-    }
79
-
80
-    /**
81
-     * Find and return the request dynamic route based on the compiled data and Path.
82
-     *
83
-     * @param string $httpMethod
84
-     * @param string $path
85
-     *
86
-     * @return Route|false If the request match an array with the action and parameters will
87
-     *                     be returned otherwise a false will.
88
-     */
89
-
90
-    protected function matchDynamicRoute($httpMethod, $path)
91
-    {
92
-        $routes = $this->collector->findDynamicRoutes($httpMethod, $path);
93
-
94
-        if (!$routes) {
95
-            return false;
96
-        }
97
-
98
-        // chunk routes for smaller regex groups using the Sturges' Formula
99
-        foreach (array_chunk($routes, round(1 + 3.3 * log(count($routes))), true) as $chunk)
100
-        {
101
-            array_map([$this, "buildRoute"], $chunk);
102
-            list($pattern, $map) = $this->buildGroup($chunk);
103
-
104
-            if (!preg_match($pattern, $path, $matches)) {
105
-                continue;
106
-            }
107
-
108
-            /** @var Route $route */
109
-            $route = $map[count($matches)];
110
-            // removing the Path from array.
111
-            unset($matches[0]);
112
-            // sometimes null values come with the matches so the array_filter must be called first.
113
-            $route->setParams(array_combine($route->getParams(), array_filter($matches)));
114
-            // route must know who match them
115
-            $route->setMatcher($this);
116
-
117
-            return $route;
118
-        }
119
-
120
-        return false;
121
-    }
122
-
123
-    /**
124
-     * Parse the dynamic segments of the pattern and replace then for
125
-     * corresponding regex.
126
-     *
127
-     * @param Route $route
128
-     * @return Route
129
-     */
130
-
131
-    protected function buildRoute(Route $route)
132
-    {
133
-        if ($route->blocked()) {
134
-            return $route;
135
-        }
26
+	/**
27
+	 * @var Collector
28
+	 */
29
+
30
+	protected $collector;
31
+
32
+	/**
33
+	 * Define a basepath to all routes.
34
+	 *
35
+	 * @var string
36
+	 */
37
+
38
+	protected $basepath = "";
39
+
40
+	/**
41
+	 * Construct the route dispatcher.
42
+	 *
43
+	 * @param Collector $collector
44
+	 * @param string $basepath Define a Path prefix that must be excluded on matches.
45
+	 */
46
+
47
+	public function __construct(Collector $collector, $basepath = "")
48
+	{
49
+		$this->collector = $collector;
50
+		$this->basepath  = $basepath;
51
+	}
52
+
53
+	/**
54
+	 * Find a route that matches the given arguments.
55
+	 * 
56
+	 * @param string $httpMethod
57
+	 * @param string $path
58
+	 *
59
+	 * @throws NotFoundException
60
+	 * @throws MethodNotAllowedException
61
+	 *
62
+	 * @return Route
63
+	 */
64
+
65
+	public function match($httpMethod, $path)
66
+	{
67
+		$path = $this->parsePath($path);
68
+
69
+		if ($route = $this->collector->findStaticRoute($httpMethod, $path)) {
70
+			return $route;
71
+		}
72
+
73
+		if ($route = $this->matchDynamicRoute($httpMethod, $path)) {
74
+			return $route;
75
+		}
76
+
77
+		$this->matchSimilarRoute($httpMethod, $path);
78
+	}
79
+
80
+	/**
81
+	 * Find and return the request dynamic route based on the compiled data and Path.
82
+	 *
83
+	 * @param string $httpMethod
84
+	 * @param string $path
85
+	 *
86
+	 * @return Route|false If the request match an array with the action and parameters will
87
+	 *                     be returned otherwise a false will.
88
+	 */
89
+
90
+	protected function matchDynamicRoute($httpMethod, $path)
91
+	{
92
+		$routes = $this->collector->findDynamicRoutes($httpMethod, $path);
93
+
94
+		if (!$routes) {
95
+			return false;
96
+		}
97
+
98
+		// chunk routes for smaller regex groups using the Sturges' Formula
99
+		foreach (array_chunk($routes, round(1 + 3.3 * log(count($routes))), true) as $chunk)
100
+		{
101
+			array_map([$this, "buildRoute"], $chunk);
102
+			list($pattern, $map) = $this->buildGroup($chunk);
103
+
104
+			if (!preg_match($pattern, $path, $matches)) {
105
+				continue;
106
+			}
107
+
108
+			/** @var Route $route */
109
+			$route = $map[count($matches)];
110
+			// removing the Path from array.
111
+			unset($matches[0]);
112
+			// sometimes null values come with the matches so the array_filter must be called first.
113
+			$route->setParams(array_combine($route->getParams(), array_filter($matches)));
114
+			// route must know who match them
115
+			$route->setMatcher($this);
116
+
117
+			return $route;
118
+		}
119
+
120
+		return false;
121
+	}
122
+
123
+	/**
124
+	 * Parse the dynamic segments of the pattern and replace then for
125
+	 * corresponding regex.
126
+	 *
127
+	 * @param Route $route
128
+	 * @return Route
129
+	 */
130
+
131
+	protected function buildRoute(Route $route)
132
+	{
133
+		if ($route->blocked()) {
134
+			return $route;
135
+		}
136 136
         
137
-        list($pattern, $params) = $this->parsePlaceholders($route->getPattern());
138
-        return  $route->setPatternWithoutReset($pattern)->setParams($params)->block();
139
-    }
140
-
141
-    /**
142
-     * Group several dynamic routes patterns into one big regex and maps
143
-     * the routes to the pattern positions in the big regex.
144
-     *
145
-     * @param array $routes
146
-     * @return array
147
-     */
148
-
149
-    protected function buildGroup(array $routes)
150
-    {
151
-        $groupCount = (int) $map = $regex = [];
152
-
153
-        /** @var Route $route */
154
-        foreach ($routes as $route) {
155
-            $params           = $route->getParams();
156
-            $paramsCount      = count($params);
157
-            $groupCount       = max($groupCount, $paramsCount) + 1;
158
-            $regex[]          = $route->getPattern() . str_repeat("()", $groupCount - $paramsCount - 1);
159
-            $map[$groupCount] = $route;
160
-        }
161
-
162
-        return ["~^(?|" . implode("|", $regex) . ")$~", $map];
163
-    }
164
-
165
-    /**
166
-     * Parse an route pattern seeking for parameters and build the route regex.
167
-     *
168
-     * @param string $pattern
169
-     * @return array 0 => new route regex, 1 => map of parameter names
170
-     */
171
-
172
-    protected function parsePlaceholders($pattern)
173
-    {
174
-        $params = [];
175
-        preg_match_all("~" . Collector::DYNAMIC_REGEX . "~x", $pattern, $matches, PREG_SET_ORDER);
176
-
177
-        foreach ((array) $matches as $key => $match) {
178
-            $pattern = str_replace($match[0], isset($match[2]) ? "({$match[2]})" : "([^/]+)", $pattern);
179
-            $params[$key] = $match[1];
180
-        }
181
-
182
-        return [$pattern, $params];
183
-    }
184
-
185
-    /**
186
-     * Get only the path of a given url.
187
-     *
188
-     * @param string $path The given URL
189
-     *
190
-     * @throws Exception
191
-     * @return string
192
-     */
193
-
194
-    protected function parsePath($path)
195
-    {
196
-        $path = parse_url(substr(strstr(";" . $path, ";" . $this->basepath), strlen(";" . $this->basepath)), PHP_URL_PATH);
197
-
198
-        if ($path === false) {
199
-            throw new Exception("Seriously malformed URL passed to route dispatcher.");
200
-        }
201
-
202
-        return $path;
203
-    }
204
-
205
-    /**
206
-     * Generate an HTTP error request with method not allowed or not found.
207
-     *
208
-     * @param string $httpMethod
209
-     * @param string $path
210
-     *
211
-     * @throws NotFoundException
212
-     * @throws MethodNotAllowedException
213
-     */
214
-
215
-    protected function matchSimilarRoute($httpMethod, $path)
216
-    {
217
-        $dm = [];
218
-
219
-        if (($sm = $this->checkStaticRouteInOtherMethods($httpMethod, $path))
220
-                || ($dm = $this->checkDynamicRouteInOtherMethods($httpMethod, $path))) {
221
-            throw new MethodNotAllowedException($httpMethod, $path, array_merge((array) $sm, (array) $dm));
222
-        }
223
-
224
-        throw new NotFoundException($httpMethod, $path);
225
-    }
226
-
227
-    /**
228
-     * Verify if a static route match in another method than the requested.
229
-     *
230
-     * @param string $targetHttpMethod The HTTP method that must not be checked
231
-     * @param string $path              The Path that must be matched.
232
-     *
233
-     * @return array
234
-     */
235
-
236
-    protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
237
-    {
238
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
239
-            return (bool) $this->collector->findStaticRoute($httpMethod, $path);
240
-        });
241
-    }
242
-
243
-    /**
244
-     * Verify if a dynamic route match in another method than the requested.
245
-     *
246
-     * @param string $targetHttpMethod The HTTP method that must not be checked
247
-     * @param string $path             The Path that must be matched.
248
-     *
249
-     * @return array
250
-     */
251
-
252
-    protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
253
-    {
254
-        return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
255
-            return (bool) $this->matchDynamicRoute($httpMethod, $path);
256
-        });
257
-    }
258
-
259
-    /**
260
-     * Strip the given http methods and return all the others.
261
-     *
262
-     * @param  array|string
263
-     * @return array
264
-     */
265
-
266
-    protected function getHttpMethodsBut($targetHttpMethod)
267
-    {
268
-        return array_diff(explode(" ", Collector::HTTP_METHODS), (array) $targetHttpMethod);
269
-    }
270
-
271
-    /**
272
-     * @return Collector
273
-     */
274
-
275
-    public function getCollector()
276
-    {
277
-        return $this->collector;
278
-    }
279
-
280
-    /**
281
-     * @return string
282
-     */
283
-
284
-    public function getBasePath()
285
-    {
286
-        return $this->basepath;
287
-    }
288
-
289
-    /**
290
-     * Set a new basepath, this will be a prefix that must be excluded in
291
-     * every requested Path.
292
-     *
293
-     * @param string $basepath The new basepath
294
-     */
137
+		list($pattern, $params) = $this->parsePlaceholders($route->getPattern());
138
+		return  $route->setPatternWithoutReset($pattern)->setParams($params)->block();
139
+	}
140
+
141
+	/**
142
+	 * Group several dynamic routes patterns into one big regex and maps
143
+	 * the routes to the pattern positions in the big regex.
144
+	 *
145
+	 * @param array $routes
146
+	 * @return array
147
+	 */
148
+
149
+	protected function buildGroup(array $routes)
150
+	{
151
+		$groupCount = (int) $map = $regex = [];
152
+
153
+		/** @var Route $route */
154
+		foreach ($routes as $route) {
155
+			$params           = $route->getParams();
156
+			$paramsCount      = count($params);
157
+			$groupCount       = max($groupCount, $paramsCount) + 1;
158
+			$regex[]          = $route->getPattern() . str_repeat("()", $groupCount - $paramsCount - 1);
159
+			$map[$groupCount] = $route;
160
+		}
161
+
162
+		return ["~^(?|" . implode("|", $regex) . ")$~", $map];
163
+	}
164
+
165
+	/**
166
+	 * Parse an route pattern seeking for parameters and build the route regex.
167
+	 *
168
+	 * @param string $pattern
169
+	 * @return array 0 => new route regex, 1 => map of parameter names
170
+	 */
171
+
172
+	protected function parsePlaceholders($pattern)
173
+	{
174
+		$params = [];
175
+		preg_match_all("~" . Collector::DYNAMIC_REGEX . "~x", $pattern, $matches, PREG_SET_ORDER);
176
+
177
+		foreach ((array) $matches as $key => $match) {
178
+			$pattern = str_replace($match[0], isset($match[2]) ? "({$match[2]})" : "([^/]+)", $pattern);
179
+			$params[$key] = $match[1];
180
+		}
181
+
182
+		return [$pattern, $params];
183
+	}
184
+
185
+	/**
186
+	 * Get only the path of a given url.
187
+	 *
188
+	 * @param string $path The given URL
189
+	 *
190
+	 * @throws Exception
191
+	 * @return string
192
+	 */
193
+
194
+	protected function parsePath($path)
195
+	{
196
+		$path = parse_url(substr(strstr(";" . $path, ";" . $this->basepath), strlen(";" . $this->basepath)), PHP_URL_PATH);
197
+
198
+		if ($path === false) {
199
+			throw new Exception("Seriously malformed URL passed to route dispatcher.");
200
+		}
201
+
202
+		return $path;
203
+	}
204
+
205
+	/**
206
+	 * Generate an HTTP error request with method not allowed or not found.
207
+	 *
208
+	 * @param string $httpMethod
209
+	 * @param string $path
210
+	 *
211
+	 * @throws NotFoundException
212
+	 * @throws MethodNotAllowedException
213
+	 */
214
+
215
+	protected function matchSimilarRoute($httpMethod, $path)
216
+	{
217
+		$dm = [];
218
+
219
+		if (($sm = $this->checkStaticRouteInOtherMethods($httpMethod, $path))
220
+				|| ($dm = $this->checkDynamicRouteInOtherMethods($httpMethod, $path))) {
221
+			throw new MethodNotAllowedException($httpMethod, $path, array_merge((array) $sm, (array) $dm));
222
+		}
223
+
224
+		throw new NotFoundException($httpMethod, $path);
225
+	}
226
+
227
+	/**
228
+	 * Verify if a static route match in another method than the requested.
229
+	 *
230
+	 * @param string $targetHttpMethod The HTTP method that must not be checked
231
+	 * @param string $path              The Path that must be matched.
232
+	 *
233
+	 * @return array
234
+	 */
235
+
236
+	protected function checkStaticRouteInOtherMethods($targetHttpMethod, $path)
237
+	{
238
+		return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
239
+			return (bool) $this->collector->findStaticRoute($httpMethod, $path);
240
+		});
241
+	}
242
+
243
+	/**
244
+	 * Verify if a dynamic route match in another method than the requested.
245
+	 *
246
+	 * @param string $targetHttpMethod The HTTP method that must not be checked
247
+	 * @param string $path             The Path that must be matched.
248
+	 *
249
+	 * @return array
250
+	 */
251
+
252
+	protected function checkDynamicRouteInOtherMethods($targetHttpMethod, $path)
253
+	{
254
+		return array_filter($this->getHttpMethodsBut($targetHttpMethod), function ($httpMethod) use ($path) {
255
+			return (bool) $this->matchDynamicRoute($httpMethod, $path);
256
+		});
257
+	}
258
+
259
+	/**
260
+	 * Strip the given http methods and return all the others.
261
+	 *
262
+	 * @param  array|string
263
+	 * @return array
264
+	 */
265
+
266
+	protected function getHttpMethodsBut($targetHttpMethod)
267
+	{
268
+		return array_diff(explode(" ", Collector::HTTP_METHODS), (array) $targetHttpMethod);
269
+	}
270
+
271
+	/**
272
+	 * @return Collector
273
+	 */
274
+
275
+	public function getCollector()
276
+	{
277
+		return $this->collector;
278
+	}
279
+
280
+	/**
281
+	 * @return string
282
+	 */
283
+
284
+	public function getBasePath()
285
+	{
286
+		return $this->basepath;
287
+	}
288
+
289
+	/**
290
+	 * Set a new basepath, this will be a prefix that must be excluded in
291
+	 * every requested Path.
292
+	 *
293
+	 * @param string $basepath The new basepath
294
+	 */
295 295
     
296
-    public function setBasePath($basepath)
297
-    {
298
-        $this->basepath = $basepath;
299
-    }
296
+	public function setBasePath($basepath)
297
+	{
298
+		$this->basepath = $basepath;
299
+	}
300 300
 
301 301
 }
Please login to merge, or discard this patch.
src/Resource.php 2 patches
Braces   +3 added lines, -1 removed lines patch added patch discarded remove patch
@@ -173,7 +173,9 @@
 block discarded – undo
173 173
         foreach ($segments as $index => $segment) {
174 174
             if (strpos($segment, "{") === 0) {
175 175
                    $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
176
-            } else $pattern .= $segment;
176
+            } else {
177
+            	$pattern .= $segment;
178
+            }
177 179
         }
178 180
 
179 181
         return $pattern;
Please login to merge, or discard this patch.
Indentation   +158 added lines, -158 removed lines patch added patch discarded remove patch
@@ -20,163 +20,163 @@
 block discarded – undo
20 20
 class Resource extends Group
21 21
 {
22 22
 
23
-    /**
24
-     * @inheritdoc
25
-     * @throws \BadMethodCallException
26
-     */
27
-
28
-    public function setMethod($method)
29
-    {
30
-        throw new \BadMethodCallException("Resources can't chance they http method.");
31
-    }
32
-
33
-    /**
34
-     * Remove the routes without the passed methods.
35
-     *
36
-     * @param string|array $methods
37
-     * @return self
38
-     */
39
-
40
-    public function only($methods)
41
-    {
42
-        $this->filterByMethod((array) $methods, false);
43
-        return $this;
44
-    }
45
-
46
-    /**
47
-     * Remove the routes with the passed methods.
48
-     *
49
-     * @param string|array $methods
50
-     * @return self
51
-     */
52
-
53
-    public function except($methods)
54
-    {
55
-        $this->filterByMethod((array) $methods, true);
56
-        return $this;
57
-    }
58
-
59
-    /**
60
-     * Forget the grouped routes filtering by http methods.
61
-     *
62
-     * @param array $methods
63
-     * @param bool $alt Should remove?
64
-     */
65
-
66
-    private function filterByMethod(array $methods, $alt)
67
-    {
68
-        $methods = array_flip(array_map('strtolower', $methods));
69
-
70
-        foreach ($this->routes as $route) {
71
-            if (isset($methods[$route->getAction()[1]]) === $alt) {
72
-                $route->forget();
73
-            }
74
-        }
75
-    }
76
-
77
-    /**
78
-     * Translate the "make" or "edit" from resources path.
79
-     *
80
-     * @param string[] $translations
81
-     * @return self
82
-     */
83
-
84
-    public function translate(array $translations)
85
-    {
86
-        /** @var Route $route */
87
-        foreach ($this->routes as $route) {
88
-            $action = $route->getAction()[1];
89
-
90
-            if ($action === "make" && isset($translations["make"])) {
91
-                $route->setPatternWithoutReset(str_replace("make", $translations["make"], $route->getPattern()));
92
-            } else {
93
-                if ($action === "edit" && isset($translations["edit"])) {
94
-                    $route->setPatternWithoutReset(str_replace("edit", $translations["edit"], $route->getPattern()));
95
-                }
96
-            }
97
-        }
98
-
99
-        return $this;
100
-    }
101
-
102
-    /**
103
-     * Add a route or a group of routes to the resource, it means that
104
-     * every added route will now receive the parameters of the resource, like id.
105
-     *
106
-     * @param Route|Group $route
107
-     * @return self
108
-     */
109
-
110
-    public function member($route)
111
-    {
112
-        $resource = new Resource;
113
-        $resource->set($route);
114
-        $this->nest($resource);
115
-    }
116
-
117
-    /**
118
-     * Nested routes capture the relation between a resource and another resource.
119
-     *
120
-     * @param Resource $resource
121
-     * @return self
122
-     */
123
-
124
-    public function nest(Resource $resource)
125
-    {
126
-        /** @var self $resource */
127
-        foreach ($this->routes as $route) {
128
-            if ($route->getAction()[1] === "show") {
129
-                $this->set($resource->forget()->setPrefix($this->getNestedPrefix($route->getPattern()))); break;
130
-            }
131
-        }
132
-
133
-        return $this;
134
-    }
135
-
136
-    /**
137
-     * Nest resources but with only build routes with the minimal amount of information
138
-     * to uniquely identify the resource.
139
-     *
140
-     * @param Resource $resource
141
-     * @return self
142
-     */
143
-
144
-    public function shallow(Resource $resource)
145
-    {
146
-        /** @var self $resource */
147
-        $newResource = new Resource;
148
-        $resource->forget();
149
-        $routes = $resource->all();
150
-
151
-        foreach ($routes as $route) {
152
-            if (strpos("index make create", $route->getAction()[1]) !== false) {
153
-                $newResource->set($route);
154
-            }
155
-        }
156
-
157
-        return $this->nest($newResource);
158
-    }
159
-
160
-    /**
161
-     * Resolve the nesting pattern, setting the prefixes based on
162
-     * parent resources patterns.
163
-     *
164
-     * @param string $pattern
165
-     * @return string
166
-     */
167
-
168
-    protected function getNestedPrefix($pattern)
169
-    {
170
-        $segments = explode("/", $pattern);
171
-        $pattern = "";
172
-
173
-        foreach ($segments as $index => $segment) {
174
-            if (strpos($segment, "{") === 0) {
175
-                   $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
176
-            } else $pattern .= $segment;
177
-        }
178
-
179
-        return $pattern;
180
-    }
23
+	/**
24
+	 * @inheritdoc
25
+	 * @throws \BadMethodCallException
26
+	 */
27
+
28
+	public function setMethod($method)
29
+	{
30
+		throw new \BadMethodCallException("Resources can't chance they http method.");
31
+	}
32
+
33
+	/**
34
+	 * Remove the routes without the passed methods.
35
+	 *
36
+	 * @param string|array $methods
37
+	 * @return self
38
+	 */
39
+
40
+	public function only($methods)
41
+	{
42
+		$this->filterByMethod((array) $methods, false);
43
+		return $this;
44
+	}
45
+
46
+	/**
47
+	 * Remove the routes with the passed methods.
48
+	 *
49
+	 * @param string|array $methods
50
+	 * @return self
51
+	 */
52
+
53
+	public function except($methods)
54
+	{
55
+		$this->filterByMethod((array) $methods, true);
56
+		return $this;
57
+	}
58
+
59
+	/**
60
+	 * Forget the grouped routes filtering by http methods.
61
+	 *
62
+	 * @param array $methods
63
+	 * @param bool $alt Should remove?
64
+	 */
65
+
66
+	private function filterByMethod(array $methods, $alt)
67
+	{
68
+		$methods = array_flip(array_map('strtolower', $methods));
69
+
70
+		foreach ($this->routes as $route) {
71
+			if (isset($methods[$route->getAction()[1]]) === $alt) {
72
+				$route->forget();
73
+			}
74
+		}
75
+	}
76
+
77
+	/**
78
+	 * Translate the "make" or "edit" from resources path.
79
+	 *
80
+	 * @param string[] $translations
81
+	 * @return self
82
+	 */
83
+
84
+	public function translate(array $translations)
85
+	{
86
+		/** @var Route $route */
87
+		foreach ($this->routes as $route) {
88
+			$action = $route->getAction()[1];
89
+
90
+			if ($action === "make" && isset($translations["make"])) {
91
+				$route->setPatternWithoutReset(str_replace("make", $translations["make"], $route->getPattern()));
92
+			} else {
93
+				if ($action === "edit" && isset($translations["edit"])) {
94
+					$route->setPatternWithoutReset(str_replace("edit", $translations["edit"], $route->getPattern()));
95
+				}
96
+			}
97
+		}
98
+
99
+		return $this;
100
+	}
101
+
102
+	/**
103
+	 * Add a route or a group of routes to the resource, it means that
104
+	 * every added route will now receive the parameters of the resource, like id.
105
+	 *
106
+	 * @param Route|Group $route
107
+	 * @return self
108
+	 */
109
+
110
+	public function member($route)
111
+	{
112
+		$resource = new Resource;
113
+		$resource->set($route);
114
+		$this->nest($resource);
115
+	}
116
+
117
+	/**
118
+	 * Nested routes capture the relation between a resource and another resource.
119
+	 *
120
+	 * @param Resource $resource
121
+	 * @return self
122
+	 */
123
+
124
+	public function nest(Resource $resource)
125
+	{
126
+		/** @var self $resource */
127
+		foreach ($this->routes as $route) {
128
+			if ($route->getAction()[1] === "show") {
129
+				$this->set($resource->forget()->setPrefix($this->getNestedPrefix($route->getPattern()))); break;
130
+			}
131
+		}
132
+
133
+		return $this;
134
+	}
135
+
136
+	/**
137
+	 * Nest resources but with only build routes with the minimal amount of information
138
+	 * to uniquely identify the resource.
139
+	 *
140
+	 * @param Resource $resource
141
+	 * @return self
142
+	 */
143
+
144
+	public function shallow(Resource $resource)
145
+	{
146
+		/** @var self $resource */
147
+		$newResource = new Resource;
148
+		$resource->forget();
149
+		$routes = $resource->all();
150
+
151
+		foreach ($routes as $route) {
152
+			if (strpos("index make create", $route->getAction()[1]) !== false) {
153
+				$newResource->set($route);
154
+			}
155
+		}
156
+
157
+		return $this->nest($newResource);
158
+	}
159
+
160
+	/**
161
+	 * Resolve the nesting pattern, setting the prefixes based on
162
+	 * parent resources patterns.
163
+	 *
164
+	 * @param string $pattern
165
+	 * @return string
166
+	 */
167
+
168
+	protected function getNestedPrefix($pattern)
169
+	{
170
+		$segments = explode("/", $pattern);
171
+		$pattern = "";
172
+
173
+		foreach ($segments as $index => $segment) {
174
+			if (strpos($segment, "{") === 0) {
175
+				   $pattern .= "/{" . $segments[$index - 1] . "_" . ltrim($segment, "{");
176
+			} else $pattern .= $segment;
177
+		}
178
+
179
+		return $pattern;
180
+	}
181 181
 
182 182
 }
Please login to merge, or discard this patch.