Passed
Branch 0.7.0 (ff60e1)
by Alexander
15:29 queued 12:11
created
src/components/Filesystem/Filesystem.php 1 patch
Indentation   +804 added lines, -804 removed lines patch added patch discarded remove patch
@@ -35,819 +35,819 @@
 block discarded – undo
35 35
  */
36 36
 class Filesystem 
37 37
 {
38
-	/**
39
-	 * Enable locking for file reading and writing.
40
-	 *
41
-	 * @var null|bool $lock
42
-	 */
43
-	public $lock = null;
44
-
45
-	/**
46
-	 * Holds the file handler resource if the file is opened.
47
-	 *
48
-	 * @var resource $handler
49
-	 */
50
-	protected $handler;
51
-
52
-	/**
53
-	 * The files size in bytes.
54
-	 *
55
-	 * @var float $size
56
-	 */
57
-	protected $size;
58
-
59
-	/**
60
-	 * Append given data string to this file.
61
-	 *
62
-	 * @param  string  $path
63
-	 * @param  string  $data
64
-	 *
65
-	 * @return bool
66
-	 */
67
-	public function append($path, $data)
68
-	{
69
-		return file_put_contents($path, $data, FILE_APPEND);
70
-	}
71
-
72
-	/**
73
-	 * Copy a file to a new location.
74
-	 *
75
-	 * @param  string  $path
76
-	 * @param  string  $target
77
-	 * 
78
-	 * @return bool
79
-	 */
80
-	public function copy($path, $target)
81
-	{
82
-		return copy($path, $target);
83
-	}
84
-
85
-	/**
86
-	 * Get the contents of a file.
87
-	 *
88
-	 * @param  string  $path
89
-	 * @param  bool  $lock  (false by default)
90
-	 * @param  bool  $force  (false by default)
91
-	 *
92
-	 * @return string
93
-	 *
94
-	 * @throws FileNotFoundException
95
-	 */
96
-	public function get($path, $lock = false, $force = false)
97
-	{
98
-		if ($this->isFile($path)) {
99
-			return $lock ? $this->read($path, $force) : file_get_contents($path);
100
-		}
101
-
102
-		throw new FileNotFoundException($path);
103
-	}
104
-
105
-	/**
106
-	 * Get contents of a file with shared access.
107
-	 *
108
-	 * @param  string  $path
109
-	 * @param  bool  $force  
110
-	 *
111
-	 * @return string
112
-	 */
113
-	protected function read($path, $force = false)
114
-	{
115
-		$contents = '';
116
-
117
-		$this->open($path, 'rb', $force);
38
+    /**
39
+     * Enable locking for file reading and writing.
40
+     *
41
+     * @var null|bool $lock
42
+     */
43
+    public $lock = null;
44
+
45
+    /**
46
+     * Holds the file handler resource if the file is opened.
47
+     *
48
+     * @var resource $handler
49
+     */
50
+    protected $handler;
51
+
52
+    /**
53
+     * The files size in bytes.
54
+     *
55
+     * @var float $size
56
+     */
57
+    protected $size;
58
+
59
+    /**
60
+     * Append given data string to this file.
61
+     *
62
+     * @param  string  $path
63
+     * @param  string  $data
64
+     *
65
+     * @return bool
66
+     */
67
+    public function append($path, $data)
68
+    {
69
+        return file_put_contents($path, $data, FILE_APPEND);
70
+    }
71
+
72
+    /**
73
+     * Copy a file to a new location.
74
+     *
75
+     * @param  string  $path
76
+     * @param  string  $target
77
+     * 
78
+     * @return bool
79
+     */
80
+    public function copy($path, $target)
81
+    {
82
+        return copy($path, $target);
83
+    }
84
+
85
+    /**
86
+     * Get the contents of a file.
87
+     *
88
+     * @param  string  $path
89
+     * @param  bool  $lock  (false by default)
90
+     * @param  bool  $force  (false by default)
91
+     *
92
+     * @return string
93
+     *
94
+     * @throws FileNotFoundException
95
+     */
96
+    public function get($path, $lock = false, $force = false)
97
+    {
98
+        if ($this->isFile($path)) {
99
+            return $lock ? $this->read($path, $force) : file_get_contents($path);
100
+        }
101
+
102
+        throw new FileNotFoundException($path);
103
+    }
104
+
105
+    /**
106
+     * Get contents of a file with shared access.
107
+     *
108
+     * @param  string  $path
109
+     * @param  bool  $force  
110
+     *
111
+     * @return string
112
+     */
113
+    protected function read($path, $force = false)
114
+    {
115
+        $contents = '';
116
+
117
+        $this->open($path, 'rb', $force);
118 118
 		
119
-		if ($this->handler) {
120
-			try {
121
-				if (flock($this->handler, LOCK_SH)) {
122
-					$this->clearStatCache($path);
119
+        if ($this->handler) {
120
+            try {
121
+                if (flock($this->handler, LOCK_SH)) {
122
+                    $this->clearStatCache($path);
123 123
 
124
-					$contents = fread($this->handler, $this->getSize($path) ?: 1);
124
+                    $contents = fread($this->handler, $this->getSize($path) ?: 1);
125 125
 					
126
-					while ( ! feof($this->handler)) {
127
-						$contents .= fgets($this->handler, 4096);
128
-					}
129
-
130
-					flock($this->handler, LOCK_UN);
131
-				}
132
-			} finally {
133
-				$this->close();
134
-			}
135
-		}
136
-
137
-		return trim($contents);
138
-	}
139
-
140
-	/**
141
-	 * Opens the current file with a given $mode.
142
-	 *
143
-	 * @param  string  $path
144
-	 * @param  string  $mode  A valid 'fopen' mode string (r|w|a ...)
145
-	 * @param  bool  $force  
146
-	 *
147
-	 * @return bool
148
-	 */
149
-	public function open($path, $mode, $force = false)
150
-	{
151
-		if ( ! $force && is_resource($this->handler)) {
152
-			return true;
153
-		}
154
-
155
-		if ($this->exists($path) === false) {
156
-			if ($this->create($path) === false) {
157
-				return false;
158
-			}
159
-		}
160
-
161
-		$this->handler = fopen($path, $mode);
162
-
163
-		return is_resource($this->handler);
164
-	}
165
-
166
-	/**
167
-	 * Creates the file.
168
-	 * 
169
-	 * @param  string  $path
170
-	 * 
171
-	 * @return bool
172
-	 */
173
-	public function create($path)
174
-	{
175
-		if (($this->isDirectory($path)) && ($this->isWritable($path)) || ( ! $this->exists($path))) {
176
-			if (touch($path)) {
177
-				return true;
178
-			}
179
-		}
180
-
181
-		return false;
182
-	}
183
-
184
-	/**
185
-	 * Determine if a file exists.
186
-	 *
187
-	 * @param  string  $path
188
-	 *
189
-	 * @return bool
190
-	 */
191
-	public function exists($path)
192
-	{
193
-		$this->clearStatCache($path);
194
-
195
-		return file_exists($path);
196
-	}
197
-
198
-	/**
199
-	 * Clear PHP's internal stat cache.
200
-	 *
201
-	 * @param  string  $path
202
-	 * @param  bool  $all  Clear all cache or not
203
-	 *
204
-	 * @return void
205
-	 */
206
-	public function clearStatCache($path, $all = false)
207
-	{
208
-		if ($all === false) {
209
-			clearstatcache(true, $path);
210
-		}
211
-
212
-		clearstatcache();
213
-	}
214
-
215
-	/**
216
-	 * Get the returned value of a file.
217
-	 * 
218
-	 * @param  string  $path
219
-	 * @param  array  $data
220
-	 * 
221
-	 * @return mixed
222
-	 * 
223
-	 * @throws \Syscodes\Filesystem\Exceptions\FileNotFoundException
224
-	 */
225
-	public function getRequire($path, array $data = [])
226
-	{
227
-		if ($this->isFile($path)) {
228
-			$__path = $path;
229
-			$__data = $data;
230
-
231
-			return (static function () use ($__path, $__data) {
232
-				extract($__data, EXTR_SKIP);
233
-
234
-				return require $__path;
235
-			})();
236
-		}
237
-
238
-		throw new FileNotFoundException($path);
239
-	}
240
-
241
-	/**
242
-	 * Require the given file once.
243
-	 * 
244
-	 * @param  string  $path
245
-	 * @param  array  $data
246
-	 * 
247
-	 * @return mixed
248
-	 * 
249
-	 * @throws \Syscodes\Filesystem\Exceptions\FileNotFoundException
250
-	 */
251
-	public function getRequireOnce($path, array $data = [])
252
-	{
253
-		if ($this->isFile($path)) {
254
-			$__path = $path;
255
-			$__data = $data;
256
-
257
-			return (static function () use ($__path, $__data) {
258
-				extract($__data, EXTR_SKIP);
259
-
260
-				return require_once $__path;
261
-			})();
262
-		}
263
-
264
-		throw new FileNotFoundException($path);
265
-	}
266
-
267
-	/**
268
-	 * Retrieve the file size.
269
-	 *
270
-	 * Implementations SHOULD return the value stored in the "size" key of
271
-	 * the file in the $_FILES array if available, as PHP calculates this
272
-	 * based on the actual size transmitted.
273
-	 *
274
-	 * @param  string  $path
275
-	 * @param  string  $unit  ('b' by default)
276
-	 * 
277
-	 * @return int|null  The file size in bytes or null if unknown
278
-	 */
279
-	public function getSize($path, $unit = 'b')
280
-	{
281
-		if ($this->exists($path)) {
282
-			if (is_null($this->size)) {
283
-				$this->size = filesize($path);
284
-			}
285
-
286
-			switch (strtolower($unit)) {
287
-				case 'kb':
288
-					return number_format($this->size / 1024, 3);
289
-					break;
290
-				case 'mb':
291
-					return number_format(($this->size / 1024) / 1024, 3);     
292
-					break;
293
-			}
294
-
295
-			return $this->size;
296
-		}
297
-	}
126
+                    while ( ! feof($this->handler)) {
127
+                        $contents .= fgets($this->handler, 4096);
128
+                    }
129
+
130
+                    flock($this->handler, LOCK_UN);
131
+                }
132
+            } finally {
133
+                $this->close();
134
+            }
135
+        }
136
+
137
+        return trim($contents);
138
+    }
139
+
140
+    /**
141
+     * Opens the current file with a given $mode.
142
+     *
143
+     * @param  string  $path
144
+     * @param  string  $mode  A valid 'fopen' mode string (r|w|a ...)
145
+     * @param  bool  $force  
146
+     *
147
+     * @return bool
148
+     */
149
+    public function open($path, $mode, $force = false)
150
+    {
151
+        if ( ! $force && is_resource($this->handler)) {
152
+            return true;
153
+        }
154
+
155
+        if ($this->exists($path) === false) {
156
+            if ($this->create($path) === false) {
157
+                return false;
158
+            }
159
+        }
160
+
161
+        $this->handler = fopen($path, $mode);
162
+
163
+        return is_resource($this->handler);
164
+    }
165
+
166
+    /**
167
+     * Creates the file.
168
+     * 
169
+     * @param  string  $path
170
+     * 
171
+     * @return bool
172
+     */
173
+    public function create($path)
174
+    {
175
+        if (($this->isDirectory($path)) && ($this->isWritable($path)) || ( ! $this->exists($path))) {
176
+            if (touch($path)) {
177
+                return true;
178
+            }
179
+        }
180
+
181
+        return false;
182
+    }
183
+
184
+    /**
185
+     * Determine if a file exists.
186
+     *
187
+     * @param  string  $path
188
+     *
189
+     * @return bool
190
+     */
191
+    public function exists($path)
192
+    {
193
+        $this->clearStatCache($path);
194
+
195
+        return file_exists($path);
196
+    }
197
+
198
+    /**
199
+     * Clear PHP's internal stat cache.
200
+     *
201
+     * @param  string  $path
202
+     * @param  bool  $all  Clear all cache or not
203
+     *
204
+     * @return void
205
+     */
206
+    public function clearStatCache($path, $all = false)
207
+    {
208
+        if ($all === false) {
209
+            clearstatcache(true, $path);
210
+        }
211
+
212
+        clearstatcache();
213
+    }
214
+
215
+    /**
216
+     * Get the returned value of a file.
217
+     * 
218
+     * @param  string  $path
219
+     * @param  array  $data
220
+     * 
221
+     * @return mixed
222
+     * 
223
+     * @throws \Syscodes\Filesystem\Exceptions\FileNotFoundException
224
+     */
225
+    public function getRequire($path, array $data = [])
226
+    {
227
+        if ($this->isFile($path)) {
228
+            $__path = $path;
229
+            $__data = $data;
230
+
231
+            return (static function () use ($__path, $__data) {
232
+                extract($__data, EXTR_SKIP);
233
+
234
+                return require $__path;
235
+            })();
236
+        }
237
+
238
+        throw new FileNotFoundException($path);
239
+    }
240
+
241
+    /**
242
+     * Require the given file once.
243
+     * 
244
+     * @param  string  $path
245
+     * @param  array  $data
246
+     * 
247
+     * @return mixed
248
+     * 
249
+     * @throws \Syscodes\Filesystem\Exceptions\FileNotFoundException
250
+     */
251
+    public function getRequireOnce($path, array $data = [])
252
+    {
253
+        if ($this->isFile($path)) {
254
+            $__path = $path;
255
+            $__data = $data;
256
+
257
+            return (static function () use ($__path, $__data) {
258
+                extract($__data, EXTR_SKIP);
259
+
260
+                return require_once $__path;
261
+            })();
262
+        }
263
+
264
+        throw new FileNotFoundException($path);
265
+    }
266
+
267
+    /**
268
+     * Retrieve the file size.
269
+     *
270
+     * Implementations SHOULD return the value stored in the "size" key of
271
+     * the file in the $_FILES array if available, as PHP calculates this
272
+     * based on the actual size transmitted.
273
+     *
274
+     * @param  string  $path
275
+     * @param  string  $unit  ('b' by default)
276
+     * 
277
+     * @return int|null  The file size in bytes or null if unknown
278
+     */
279
+    public function getSize($path, $unit = 'b')
280
+    {
281
+        if ($this->exists($path)) {
282
+            if (is_null($this->size)) {
283
+                $this->size = filesize($path);
284
+            }
285
+
286
+            switch (strtolower($unit)) {
287
+                case 'kb':
288
+                    return number_format($this->size / 1024, 3);
289
+                    break;
290
+                case 'mb':
291
+                    return number_format(($this->size / 1024) / 1024, 3);     
292
+                    break;
293
+            }
294
+
295
+            return $this->size;
296
+        }
297
+    }
298 298
 	
299
-	/**
300
-	 * Returns the file's group.
301
-	 *
302
-	 * @param  string  $path
303
-	 * 
304
-	 * @return int|bool  The file group, or false in case of an error
305
-	 */
306
-	public function group($path)
307
-	{
308
-		if ($this->exists($path)) {
309
-			return filegroup($path);
310
-		}
311
-
312
-		return false;
313
-	}
299
+    /**
300
+     * Returns the file's group.
301
+     *
302
+     * @param  string  $path
303
+     * 
304
+     * @return int|bool  The file group, or false in case of an error
305
+     */
306
+    public function group($path)
307
+    {
308
+        if ($this->exists($path)) {
309
+            return filegroup($path);
310
+        }
311
+
312
+        return false;
313
+    }
314 314
 	
315
-	/**
316
-	 * Returns true if the file is executable.
317
-	 *
318
-	 * @param  string  $path
319
-	 * 
320
-	 * @return bool  True if file is executable, false otherwise
321
-	 */
322
-	public function exec($path)
323
-	{
324
-		return is_executable($path);
325
-	}
326
-
327
-	/**
328
-	 * Determine if the given path is a directory.
329
-	 *
330
-	 * @param  string  $directory
331
-	 *
332
-	 * @return bool
333
-	 */
334
-	public function isDirectory($directory)
335
-	{
336
-		return is_dir($directory);
337
-	}
338
-
339
-	/**
340
-	 * Determine if the given path is a file.
341
-	 *
342
-	 * @param  string  $file
343
-	 *
344
-	 * @return bool
345
-	 */
346
-	public function isFile($file)
347
-	{
348
-		return is_file($file);
349
-	}
350
-
351
-	/**
352
-	 * Determine if the given path is writable.
353
-	 * 
354
-	 * @param  string  $path
355
-	 * 
356
-	 * @return bool
357
-	 */
358
-	public function isWritable($path)
359
-	{
360
-		return is_writable($path);
361
-	}
362
-
363
-	/**
364
-	 * Returns if true the file is readable.
365
-	 *
366
-	 * @param  string  $path
367
-	 * 
368
-	 * @return bool  True if file is readable, false otherwise
369
-	 */
370
-	public function isReadable($path)
371
-	{
372
-		return is_readable($path);
373
-	}
374
-
375
-	/**
376
-	 * Returns last access time.
377
-	 *
378
-	 * @param  string  $path
379
-	 * 
380
-	 * @return int|bool  Timestamp of last access time, or false in case of an error
381
-	 */
382
-	public function lastAccess($path)
383
-	{
384
-		if ($this->exists($path)) {
385
-			return fileatime($path);
386
-		}
387
-
388
-		return false;
389
-	}
390
-
391
-	/**
392
-	 * Returns last modified time.
393
-	 *
394
-	 * @param  string  $path
395
-	 * 
396
-	 * @return int|bool  Timestamp of last modified time, or false in case of an error
397
-	 */
398
-	public function lastModified($path)
399
-	{
400
-		if ($this->exists($path)) {
401
-			return filemtime($path);
402
-		}
403
-
404
-		return false;
405
-	}
406
-
407
-	/**
408
-	 * Get all of the directories within a given directory.
409
-	 * 
410
-	 * @param  string  $directory
411
-	 * 
412
-	 * @return array
413
-	 */
414
-	public function directories($directory)
415
-	{
416
-		$directories = [];
417
-
418
-		$iterators = new FilesystemIterator($directory);
419
-
420
-		foreach ($iterators as $iterator) {
421
-			$directories[] = trim($iterator->getPathname(), '/').'/';
422
-		}
423
-
424
-		return $directories;
425
-	}
426
-
427
-	/**
428
-	 * Delete the file at a given path.
429
-	 * 
430
-	 * @param  string  $paths
431
-	 * 
432
-	 * @return bool
433
-	 */
434
-	public function delete($paths)
435
-	{
436
-		if (is_resource($this->handler)) {
437
-			fclose($this->handler);
438
-			$this->handler = null;
439
-		}
440
-
441
-		$paths = is_array($paths) ? $paths : func_get_args();
442
-
443
-		$success = true;
444
-
445
-		foreach ($paths as $path) {
446
-			try {
447
-				if ( ! @unlink($path)) {
448
-					return $success = false;
449
-				}
450
-			} catch (ErrorException $e) {
451
-				return $success = false;
452
-			}
453
-		}
454
-
455
-		return $success;
456
-	}
457
-
458
-	/**
459
-	 * Create a directory.
460
-	 *
461
-	 * @param  string  $path
462
-	 * @param  int  $mode
463
-	 * @param  bool  $recursive
464
-	 * @param  bool  $force
465
-	 *
466
-	 * @return bool
467
-	 * 
468
-	 * @throws FileException
469
-	 */
470
-	public function makeDirectory($path, $mode = 0755, $recursive = false, $force = false)
471
-	{
472
-		if ($force) {
473
-			return @mkdir($path, $mode, $recursive);
474
-		}
475
-
476
-		mkdir($path, $mode, $recursive);
477
-	}
478
-
479
-	/**
480
-	 * Copy a directory from one location to another.
481
-	 * 
482
-	 * @param  string  $directory
483
-	 * @param  string  $destination
484
-	 * @param  int  $options  (null by default)
485
-	 * 
486
-	 * @return bool
487
-	 */
488
-	public function copyDirectory($directory, $destination, $options = null)
489
-	{
490
-		if ( ! $this->isDirectory($directory)) return false;
491
-
492
-		$options = $options ?: FilesystemIterator::SKIP_DOTS;
315
+    /**
316
+     * Returns true if the file is executable.
317
+     *
318
+     * @param  string  $path
319
+     * 
320
+     * @return bool  True if file is executable, false otherwise
321
+     */
322
+    public function exec($path)
323
+    {
324
+        return is_executable($path);
325
+    }
326
+
327
+    /**
328
+     * Determine if the given path is a directory.
329
+     *
330
+     * @param  string  $directory
331
+     *
332
+     * @return bool
333
+     */
334
+    public function isDirectory($directory)
335
+    {
336
+        return is_dir($directory);
337
+    }
338
+
339
+    /**
340
+     * Determine if the given path is a file.
341
+     *
342
+     * @param  string  $file
343
+     *
344
+     * @return bool
345
+     */
346
+    public function isFile($file)
347
+    {
348
+        return is_file($file);
349
+    }
350
+
351
+    /**
352
+     * Determine if the given path is writable.
353
+     * 
354
+     * @param  string  $path
355
+     * 
356
+     * @return bool
357
+     */
358
+    public function isWritable($path)
359
+    {
360
+        return is_writable($path);
361
+    }
362
+
363
+    /**
364
+     * Returns if true the file is readable.
365
+     *
366
+     * @param  string  $path
367
+     * 
368
+     * @return bool  True if file is readable, false otherwise
369
+     */
370
+    public function isReadable($path)
371
+    {
372
+        return is_readable($path);
373
+    }
374
+
375
+    /**
376
+     * Returns last access time.
377
+     *
378
+     * @param  string  $path
379
+     * 
380
+     * @return int|bool  Timestamp of last access time, or false in case of an error
381
+     */
382
+    public function lastAccess($path)
383
+    {
384
+        if ($this->exists($path)) {
385
+            return fileatime($path);
386
+        }
387
+
388
+        return false;
389
+    }
390
+
391
+    /**
392
+     * Returns last modified time.
393
+     *
394
+     * @param  string  $path
395
+     * 
396
+     * @return int|bool  Timestamp of last modified time, or false in case of an error
397
+     */
398
+    public function lastModified($path)
399
+    {
400
+        if ($this->exists($path)) {
401
+            return filemtime($path);
402
+        }
403
+
404
+        return false;
405
+    }
406
+
407
+    /**
408
+     * Get all of the directories within a given directory.
409
+     * 
410
+     * @param  string  $directory
411
+     * 
412
+     * @return array
413
+     */
414
+    public function directories($directory)
415
+    {
416
+        $directories = [];
417
+
418
+        $iterators = new FilesystemIterator($directory);
419
+
420
+        foreach ($iterators as $iterator) {
421
+            $directories[] = trim($iterator->getPathname(), '/').'/';
422
+        }
423
+
424
+        return $directories;
425
+    }
426
+
427
+    /**
428
+     * Delete the file at a given path.
429
+     * 
430
+     * @param  string  $paths
431
+     * 
432
+     * @return bool
433
+     */
434
+    public function delete($paths)
435
+    {
436
+        if (is_resource($this->handler)) {
437
+            fclose($this->handler);
438
+            $this->handler = null;
439
+        }
440
+
441
+        $paths = is_array($paths) ? $paths : func_get_args();
442
+
443
+        $success = true;
444
+
445
+        foreach ($paths as $path) {
446
+            try {
447
+                if ( ! @unlink($path)) {
448
+                    return $success = false;
449
+                }
450
+            } catch (ErrorException $e) {
451
+                return $success = false;
452
+            }
453
+        }
454
+
455
+        return $success;
456
+    }
457
+
458
+    /**
459
+     * Create a directory.
460
+     *
461
+     * @param  string  $path
462
+     * @param  int  $mode
463
+     * @param  bool  $recursive
464
+     * @param  bool  $force
465
+     *
466
+     * @return bool
467
+     * 
468
+     * @throws FileException
469
+     */
470
+    public function makeDirectory($path, $mode = 0755, $recursive = false, $force = false)
471
+    {
472
+        if ($force) {
473
+            return @mkdir($path, $mode, $recursive);
474
+        }
475
+
476
+        mkdir($path, $mode, $recursive);
477
+    }
478
+
479
+    /**
480
+     * Copy a directory from one location to another.
481
+     * 
482
+     * @param  string  $directory
483
+     * @param  string  $destination
484
+     * @param  int  $options  (null by default)
485
+     * 
486
+     * @return bool
487
+     */
488
+    public function copyDirectory($directory, $destination, $options = null)
489
+    {
490
+        if ( ! $this->isDirectory($directory)) return false;
491
+
492
+        $options = $options ?: FilesystemIterator::SKIP_DOTS;
493 493
 		
494
-		// If the destination directory does not actually exist, we will go ahead and
495
-		// create it recursively, which just gets the destination prepared to copy
496
-		// the files over. Once we make the directory we'll proceed the copying.
497
-		if ( ! $this->isdirectory($destination)) {
498
-			$this->makeDirectory($destination, 0777, true);
499
-		}
494
+        // If the destination directory does not actually exist, we will go ahead and
495
+        // create it recursively, which just gets the destination prepared to copy
496
+        // the files over. Once we make the directory we'll proceed the copying.
497
+        if ( ! $this->isdirectory($destination)) {
498
+            $this->makeDirectory($destination, 0777, true);
499
+        }
500 500
 
501
-		$iterators = new FilesystemIterator($directory, $options);
501
+        $iterators = new FilesystemIterator($directory, $options);
502 502
 
503
-		foreach ($iterators as $iterator) {
504
-			$target = $destination.DIRECTORY_SEPARATOR.$iterator->getBasename();
503
+        foreach ($iterators as $iterator) {
504
+            $target = $destination.DIRECTORY_SEPARATOR.$iterator->getBasename();
505 505
 			
506
-			// As we spin through items, we will check to see if the current file is actually
506
+            // As we spin through items, we will check to see if the current file is actually
507 507
             // a directory or a file. When it is actually a directory we will need to call
508 508
             // back into this function recursively to keep copying these nested folders.
509
-			if ($iterator->isDir()) {
510
-				if ( ! $this->copyDirectory($iterator->getPathname(), $target, $options)) return false;
511
-			}
512
-			// If the current items is just a regular file, we will just copy this to the new
513
-			// location and keep looping. If for some reason the copy fails we'll bail out
514
-			// and return false, so the developer is aware that the copy process failed.
515
-			else {
516
-				if ( ! $this->copy($iterator->getPathname(), $target)) return false;
517
-			}
518
-		}
519
-
520
-		return true;
521
-	}
522
-
523
-	/**
524
-	 * Recursively delete a directory and optionally you can keep 
525
-	 * the directory if you wish.
526
-	 * 
527
-	 * @param  string  $directory
528
-	 * @param  bool  $keep
529
-	 * 
530
-	 * @return bool
531
-	 */
532
-	public function deleteDirectory($directory, $keep = false)
533
-	{
534
-		if ( ! $this->isDirectory($directory)) return false;
535
-
536
-		$iterators = new filesystemIterator($directory);
537
-
538
-		foreach ($iterators as $iterator) {
539
-			// If the item is a directory, we can just recurse into the function and delete 
540
-			// that sub-directory otherwise we'll just delete the file and keep iterating 
541
-			// through each file until the directory is cleaned.
542
-			if ($iterator->isDir() && ! $iterator->isLink()) {
543
-				$this->deleteDirectory($iterator->getPathname());
544
-			}
545
-			// If the item is just a file, we can go ahead and delete it since we're
546
-			// just looping through and waxing all of the files in this directory
547
-			// and calling directories recursively, so we delete the real path.
548
-			else {
549
-				$this->delete($iterator->getPathname());
550
-			}
551
-		}
552
-
553
-		if ( ! $keep) @rmdir($directory);
554
-
555
-		return true;
556
-	}
557
-
558
-	/**
559
-	 * Empty the specified directory of all files and folders.
560
-	 * 
561
-	 * 
562
-	 * @param  string  $directory
563
-	 * 
564
-	 * @return bool
565
-	 */
566
-	public function cleanDirectory($directory)
567
-	{
568
-		return $this->deleteDirectory($directory, true);
569
-	}
570
-
571
-	/**
572
-	 * Moves a file to a new location.
573
-	 * 
574
-	 * @param  string  $from
575
-	 * @param  string  $to
576
-	 * @param  bool  $overwrite  (false by default)
577
-	 * 
578
-	 * @return bool
579
-	 */
580
-	public function moveDirectory($from, $to, $overwrite = false)
581
-	{
582
-		if ($overwrite && $this->isDirectory($to) && ! $this->deleteDirectory($to)) return false;
583
-
584
-		if (false === @rename($from, $to)) {
585
-			$error = error_get_last();
586
-
587
-			throw new FileUnableToMoveException($from, $to, strip_tags($error['message']));
588
-		}
589
-
590
-		$this->perms($to, 0777 & ~umask());
591
-	}
592
-
593
-	/**
594
-	 * Attempts to determine the file extension based on the trusted
595
-	 * getType() method. If the mime type is unknown, will return null.
596
-	 * 
597
-	 * @param  string  $path
598
-	 * 
599
-	 * @return string|null
600
-	 */
601
-	public function guessExtension($path)
602
-	{
603
-		return FileMimeType::guessExtensionFromType($this->getMimeType($path));
604
-	}
605
-
606
-	/**
607
-	 * Retrieve the media type of the file. 
608
-	 * 
609
-	 * @param  string  $path
610
-	 * 
611
-	 * @return string|null
612
-	 */
613
-	public function getMimeType($path)
614
-	{
615
-		$finfo    = finfo_open(FILEINFO_MIME_TYPE);
616
-		$mimeType = finfo_file($finfo, $path);
617
-
618
-		finfo_close($finfo);
619
-
620
-		return $mimeType;
621
-	}
622
-
623
-	/**
624
-	 * Move a file to a new location.
625
-	 *
626
-	 * @param  string  $path
627
-	 * @param  string  $target
628
-	 *
629
-	 * @return bool
630
-	 */
631
-	public function move($path, $target)
632
-	{
633
-		if ($this->exists($path)) {
634
-			return rename($path, $target);
635
-		}
636
-	}
637
-
638
-	/**
639
-	 * Extract the file name from a file path.
640
-	 * 
641
-	 * @param  string  $path
642
-	 * 
643
-	 * @return string
644
-	 */
645
-	public function name($path)
646
-	{
647
-		return pathinfo($path, PATHINFO_FILENAME);
648
-	}
649
-
650
-	/**
651
-	 * Extract the trailing name component from a file path.
652
-	 * 
653
-	 * @param  string  $path
654
-	 * 
655
-	 * @return string
656
-	 */
657
-	public function basename($path)
658
-	{
659
-		return pathinfo($path, PATHINFO_BASENAME);
660
-	}
661
-
662
-	/**
663
-	 * Extract the parent directory from a file path.
664
-	 * 
665
-	 * @param  string  $path
666
-	 * 
667
-	 * @return string
668
-	 */
669
-	public function dirname($path)
670
-	{
671
-		return pathinfo($path, PATHINFO_DIRNAME);
672
-	}
673
-
674
-	/**
675
-	 * Extract the file extension from a file path.
676
-	 * 
677
-	 * @param  string  $path
678
-	 * 
679
-	 * @return string
680
-	 */
681
-	public function extension($path)
682
-	{
683
-		return pathinfo($path, PATHINFO_EXTENSION);
684
-	}
685
-
686
-	/**
687
-	 *  Find path names matching a given pattern.
688
-	 * 
689
-	 * @param  string  $pattern
690
-	 * @param  int  $flags  (0 by default)
691
-	 * 
692
-	 * @return array
693
-	 */
694
-	public function glob($pattern, $flags = 0)
695
-	{
696
-		return glob($pattern, $flags);
697
-	}
698
-
699
-	/**
700
-	 * Returns the file's owner.
701
-	 *
702
-	 * @param  string  $path
703
-	 * 
704
-	 * @return int|bool  The file owner, or false in case of an error
705
-	 */
706
-	public function owner($path)
707
-	{
708
-		if ($this->exists($path)) {
709
-			return fileowner($path);
710
-		}
711
-
712
-		return false;
713
-	}
714
-
715
-	/**
716
-	 * Returns the "chmod" (permissions) of the file.
717
-	 *
718
-	 * @param  string  $path
719
-	 * @param  int|null  $mode  (null by default)
720
-	 * 
721
-	 * @return mixed  Permissions for the file, or false in case of an error
722
-	 */
723
-	public function perms($path, $mode = null)
724
-	{
725
-		if ($mode) {
726
-			chmod($path, $mode);
727
-		}
728
-
729
-		return substr(sprintf('%o', fileperms($path)), -4);
730
-	}
731
-
732
-	/**
733
-	 * Prepend to a file.
734
-	 * 
735
-	 * @param  string  $path
736
-	 * @param  string  $data
737
-	 * 
738
-	 * @return int
739
-	 */
740
-	public function prepend($path, $data)
741
-	{
742
-		if ($this->exists($path)) {
743
-			$this->put($path, $data.$this->get($path));
744
-		}
745
-
746
-		return $this->put($path, $data);
747
-	}
748
-
749
-	/**
750
-	 * Write the content of a file.
751
-	 *
752
-	 * @param  string  $path
753
-	 * @param  string  $contents
754
-	 * @param  bool  $lock  (false by default)
755
-	 *
756
-	 * @return int
757
-	 */
758
-	public function put($path, $contents, $lock = false)
759
-	{
760
-		return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
761
-	}
762
-
763
-	/**
764
-	 * Get the file type of a given file.
765
-	 * 
766
-	 * @param  string  $path
767
-	 * 
768
-	 * @return string
769
-	 */
770
-	public function type($path)
771
-	{
772
-		return filetype($path);
773
-	}
774
-
775
-	/**
776
-	 * Searches for a given text and replaces the text if found.
777
-	 *
778
-	 * @param  string  $path
779
-	 * @param  string  $search
780
-	 * @param  string  $replace
781
-	 *
782
-	 * @return bool
783
-	 */
784
-	public function replaceText($path, $search, $replace)
785
-	{
786
-		if ( ! $this->open($path, 'r+')) {
787
-			return false;
788
-		}
789
-
790
-		if ($this->lock !== null) {
791
-			if (flock($this->handler, LOCK_EX) === false)
792
-			{
793
-				return false;
794
-			}
795
-		}
796
-
797
-		$replaced = $this->write($path, str_replace($search, $replace, $this->get($path)), true);
798
-
799
-		if ($this->lock !== null) {
800
-			flock($this->handler, LOCK_UN);
801
-		}
802
-
803
-		$this->close();
804
-
805
-		return $replaced;
806
-	}	
807
-
808
-	/**
809
-	 * Closes the current file if it is opened.
810
-	 *
811
-	 * @return bool
812
-	 */
813
-	public function close()
814
-	{
815
-		if ( ! is_resource($this->handler)) {
816
-			return true;
817
-		}
818
-
819
-		return fclose($this->handler);
820
-	}
821
-
822
-	/**
823
-	 * Write given data to this file.
824
-	 *
825
-	 * @param  string  $path
826
-	 * @param  string  $data  Data to write to this File
827
-	 * @param  bool  $force  The file to open
828
-	 *
829
-	 * @return bool
830
-	 */
831
-	public function write($path, $data, $force = false)
832
-	{
833
-		$success = false;
834
-
835
-		if ($this->open($path, 'w', $force) === true) {
836
-			if ($this->lock !== null) {
837
-				if (flock($this->handler, LOCK_EX) === false) {
838
-					return false;
839
-				}
840
-			}
841
-
842
-			if (fwrite($this->handler, $data) !== false) {
843
-				$success = true;
844
-			}
845
-
846
-			if ($this->lock !== null) {
847
-				flock($this->handler, LOCK_UN);
848
-			}
849
-		}
850
-
851
-		return $success;
852
-	}
509
+            if ($iterator->isDir()) {
510
+                if ( ! $this->copyDirectory($iterator->getPathname(), $target, $options)) return false;
511
+            }
512
+            // If the current items is just a regular file, we will just copy this to the new
513
+            // location and keep looping. If for some reason the copy fails we'll bail out
514
+            // and return false, so the developer is aware that the copy process failed.
515
+            else {
516
+                if ( ! $this->copy($iterator->getPathname(), $target)) return false;
517
+            }
518
+        }
519
+
520
+        return true;
521
+    }
522
+
523
+    /**
524
+     * Recursively delete a directory and optionally you can keep 
525
+     * the directory if you wish.
526
+     * 
527
+     * @param  string  $directory
528
+     * @param  bool  $keep
529
+     * 
530
+     * @return bool
531
+     */
532
+    public function deleteDirectory($directory, $keep = false)
533
+    {
534
+        if ( ! $this->isDirectory($directory)) return false;
535
+
536
+        $iterators = new filesystemIterator($directory);
537
+
538
+        foreach ($iterators as $iterator) {
539
+            // If the item is a directory, we can just recurse into the function and delete 
540
+            // that sub-directory otherwise we'll just delete the file and keep iterating 
541
+            // through each file until the directory is cleaned.
542
+            if ($iterator->isDir() && ! $iterator->isLink()) {
543
+                $this->deleteDirectory($iterator->getPathname());
544
+            }
545
+            // If the item is just a file, we can go ahead and delete it since we're
546
+            // just looping through and waxing all of the files in this directory
547
+            // and calling directories recursively, so we delete the real path.
548
+            else {
549
+                $this->delete($iterator->getPathname());
550
+            }
551
+        }
552
+
553
+        if ( ! $keep) @rmdir($directory);
554
+
555
+        return true;
556
+    }
557
+
558
+    /**
559
+     * Empty the specified directory of all files and folders.
560
+     * 
561
+     * 
562
+     * @param  string  $directory
563
+     * 
564
+     * @return bool
565
+     */
566
+    public function cleanDirectory($directory)
567
+    {
568
+        return $this->deleteDirectory($directory, true);
569
+    }
570
+
571
+    /**
572
+     * Moves a file to a new location.
573
+     * 
574
+     * @param  string  $from
575
+     * @param  string  $to
576
+     * @param  bool  $overwrite  (false by default)
577
+     * 
578
+     * @return bool
579
+     */
580
+    public function moveDirectory($from, $to, $overwrite = false)
581
+    {
582
+        if ($overwrite && $this->isDirectory($to) && ! $this->deleteDirectory($to)) return false;
583
+
584
+        if (false === @rename($from, $to)) {
585
+            $error = error_get_last();
586
+
587
+            throw new FileUnableToMoveException($from, $to, strip_tags($error['message']));
588
+        }
589
+
590
+        $this->perms($to, 0777 & ~umask());
591
+    }
592
+
593
+    /**
594
+     * Attempts to determine the file extension based on the trusted
595
+     * getType() method. If the mime type is unknown, will return null.
596
+     * 
597
+     * @param  string  $path
598
+     * 
599
+     * @return string|null
600
+     */
601
+    public function guessExtension($path)
602
+    {
603
+        return FileMimeType::guessExtensionFromType($this->getMimeType($path));
604
+    }
605
+
606
+    /**
607
+     * Retrieve the media type of the file. 
608
+     * 
609
+     * @param  string  $path
610
+     * 
611
+     * @return string|null
612
+     */
613
+    public function getMimeType($path)
614
+    {
615
+        $finfo    = finfo_open(FILEINFO_MIME_TYPE);
616
+        $mimeType = finfo_file($finfo, $path);
617
+
618
+        finfo_close($finfo);
619
+
620
+        return $mimeType;
621
+    }
622
+
623
+    /**
624
+     * Move a file to a new location.
625
+     *
626
+     * @param  string  $path
627
+     * @param  string  $target
628
+     *
629
+     * @return bool
630
+     */
631
+    public function move($path, $target)
632
+    {
633
+        if ($this->exists($path)) {
634
+            return rename($path, $target);
635
+        }
636
+    }
637
+
638
+    /**
639
+     * Extract the file name from a file path.
640
+     * 
641
+     * @param  string  $path
642
+     * 
643
+     * @return string
644
+     */
645
+    public function name($path)
646
+    {
647
+        return pathinfo($path, PATHINFO_FILENAME);
648
+    }
649
+
650
+    /**
651
+     * Extract the trailing name component from a file path.
652
+     * 
653
+     * @param  string  $path
654
+     * 
655
+     * @return string
656
+     */
657
+    public function basename($path)
658
+    {
659
+        return pathinfo($path, PATHINFO_BASENAME);
660
+    }
661
+
662
+    /**
663
+     * Extract the parent directory from a file path.
664
+     * 
665
+     * @param  string  $path
666
+     * 
667
+     * @return string
668
+     */
669
+    public function dirname($path)
670
+    {
671
+        return pathinfo($path, PATHINFO_DIRNAME);
672
+    }
673
+
674
+    /**
675
+     * Extract the file extension from a file path.
676
+     * 
677
+     * @param  string  $path
678
+     * 
679
+     * @return string
680
+     */
681
+    public function extension($path)
682
+    {
683
+        return pathinfo($path, PATHINFO_EXTENSION);
684
+    }
685
+
686
+    /**
687
+     *  Find path names matching a given pattern.
688
+     * 
689
+     * @param  string  $pattern
690
+     * @param  int  $flags  (0 by default)
691
+     * 
692
+     * @return array
693
+     */
694
+    public function glob($pattern, $flags = 0)
695
+    {
696
+        return glob($pattern, $flags);
697
+    }
698
+
699
+    /**
700
+     * Returns the file's owner.
701
+     *
702
+     * @param  string  $path
703
+     * 
704
+     * @return int|bool  The file owner, or false in case of an error
705
+     */
706
+    public function owner($path)
707
+    {
708
+        if ($this->exists($path)) {
709
+            return fileowner($path);
710
+        }
711
+
712
+        return false;
713
+    }
714
+
715
+    /**
716
+     * Returns the "chmod" (permissions) of the file.
717
+     *
718
+     * @param  string  $path
719
+     * @param  int|null  $mode  (null by default)
720
+     * 
721
+     * @return mixed  Permissions for the file, or false in case of an error
722
+     */
723
+    public function perms($path, $mode = null)
724
+    {
725
+        if ($mode) {
726
+            chmod($path, $mode);
727
+        }
728
+
729
+        return substr(sprintf('%o', fileperms($path)), -4);
730
+    }
731
+
732
+    /**
733
+     * Prepend to a file.
734
+     * 
735
+     * @param  string  $path
736
+     * @param  string  $data
737
+     * 
738
+     * @return int
739
+     */
740
+    public function prepend($path, $data)
741
+    {
742
+        if ($this->exists($path)) {
743
+            $this->put($path, $data.$this->get($path));
744
+        }
745
+
746
+        return $this->put($path, $data);
747
+    }
748
+
749
+    /**
750
+     * Write the content of a file.
751
+     *
752
+     * @param  string  $path
753
+     * @param  string  $contents
754
+     * @param  bool  $lock  (false by default)
755
+     *
756
+     * @return int
757
+     */
758
+    public function put($path, $contents, $lock = false)
759
+    {
760
+        return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
761
+    }
762
+
763
+    /**
764
+     * Get the file type of a given file.
765
+     * 
766
+     * @param  string  $path
767
+     * 
768
+     * @return string
769
+     */
770
+    public function type($path)
771
+    {
772
+        return filetype($path);
773
+    }
774
+
775
+    /**
776
+     * Searches for a given text and replaces the text if found.
777
+     *
778
+     * @param  string  $path
779
+     * @param  string  $search
780
+     * @param  string  $replace
781
+     *
782
+     * @return bool
783
+     */
784
+    public function replaceText($path, $search, $replace)
785
+    {
786
+        if ( ! $this->open($path, 'r+')) {
787
+            return false;
788
+        }
789
+
790
+        if ($this->lock !== null) {
791
+            if (flock($this->handler, LOCK_EX) === false)
792
+            {
793
+                return false;
794
+            }
795
+        }
796
+
797
+        $replaced = $this->write($path, str_replace($search, $replace, $this->get($path)), true);
798
+
799
+        if ($this->lock !== null) {
800
+            flock($this->handler, LOCK_UN);
801
+        }
802
+
803
+        $this->close();
804
+
805
+        return $replaced;
806
+    }	
807
+
808
+    /**
809
+     * Closes the current file if it is opened.
810
+     *
811
+     * @return bool
812
+     */
813
+    public function close()
814
+    {
815
+        if ( ! is_resource($this->handler)) {
816
+            return true;
817
+        }
818
+
819
+        return fclose($this->handler);
820
+    }
821
+
822
+    /**
823
+     * Write given data to this file.
824
+     *
825
+     * @param  string  $path
826
+     * @param  string  $data  Data to write to this File
827
+     * @param  bool  $force  The file to open
828
+     *
829
+     * @return bool
830
+     */
831
+    public function write($path, $data, $force = false)
832
+    {
833
+        $success = false;
834
+
835
+        if ($this->open($path, 'w', $force) === true) {
836
+            if ($this->lock !== null) {
837
+                if (flock($this->handler, LOCK_EX) === false) {
838
+                    return false;
839
+                }
840
+            }
841
+
842
+            if (fwrite($this->handler, $data) !== false) {
843
+                $success = true;
844
+            }
845
+
846
+            if ($this->lock !== null) {
847
+                flock($this->handler, LOCK_UN);
848
+            }
849
+        }
850
+
851
+        return $success;
852
+    }
853 853
 }
854 854
\ No newline at end of file
Please login to merge, or discard this patch.
src/components/Routing/Route.php 1 patch
Indentation   +645 added lines, -645 removed lines patch added patch discarded remove patch
@@ -40,663 +40,663 @@
 block discarded – undo
40 40
  */
41 41
 class Route 
42 42
 {
43
-	use Concerns\RouteCondition,
44
-	    Concerns\RouteDependencyResolver;
43
+    use Concerns\RouteCondition,
44
+        Concerns\RouteDependencyResolver;
45 45
 	
46
-	/**
47
-	 * Action that the route will use when called.
48
-	 *
49
-	 * @var \Closure|string|array $action
50
-	 */
51
-	public $action;
52
-
53
-	/**
54
-	 * The container instance used by the route.
55
-	 * 
56
-	 * @var \Syscodes\Container\Container $container
57
-	 */
58
-	protected $container;
59
-
60
-	/**
61
-	 * The controller instance.
62
-	 * 
63
-	 * @var string $controller
64
-	 */
65
-	public $controller;
66
-
67
-	/**
68
-	 * The default values for the route.
69
-	 * 
70
-	 * @var array $defaults
71
-	 */
72
-	public $defaults = [];
73
-
74
-	/**
75
-	 * Variable of HTTP method.
76
-	 *  
77
-	 * @var array|string $method
78
-	 */
79
-	public $method;
80
-
81
-	/**
82
-	 * The array of matched parameters.
83
-	 * 
84
-	 * @var array $parameters
85
-	 */
86
-	public $parameters = [];
87
-
88
-	/**
89
-	 * The parameter names for the route.
90
-	 * 
91
-	 * @var string|null $parameterNames
92
-	 */
93
-	public $parameterNames;
94
-
95
-	/**
96
-	* Patterns that should be replaced.
97
-	*
98
-	* @var array $patterns 
99
-	*/
100
-	public $patterns = [
101
-		'~/~'                    =>  '\/',               // Slash
102
-		'~{an:[^\/{}]+}~'        => '([0-9a-zA-Z]++)',   // Placeholder accepts alphabetic and numeric chars
103
-		'~{n:[^\/{}]+}~'         => '([0-9]++)',         // Placeholder accepts only numeric
104
-		'~{a:[^\/{}]+}~'         => '([a-zA-Z]++)',      // Placeholder accepts only alphabetic chars
105
-		'~{w:[^\/{}]+}~'         => '([0-9a-zA-Z-_]++)', // Placeholder accepts alphanumeric and underscore
106
-		'~{\*:[^\/{}]+}~'        => '(.++)',             // Placeholder match rest of url
107
-		'~(\\\/)?{\?:[^\/{}]+}~' => '\/?([^\/]*)',		 // Optional placeholder
108
-		'~{[^\/{}]+}~'           => '([^\/]++)'			 // Normal placeholder
109
-	];
110
-
111
-	/**
112
-	 * The URI pattern the route responds to.
113
-	 *
114
-	 * @var array $uri
115
-	 */
116
-	public $uri = [];
117
-
118
-	/**
119
-	 * Contains the arguments of the current route.
120
-	 *
121
-	 * @var array $where
122
-	 */
123
-	public $wheres = [];
124
-
125
-	/**
126
-	 * Constructor. Initialize route.
127
-	 *
128
-	 * @param  array|string|null  $method  (null by default)
129
-	 * @param  string|null  $uri  (null by default)
130
-	 * @param  \Closure|string|null  $action  (null by default)
131
-	 *
132
-	 * @return void
133
-	 */
134
-	public function __construct($method = null, $uri = null, $action = null)
135
-	{
136
-		$this->uri = $uri;
137
-
138
-		// Set the method
139
-		$this->parseMethod($method);
140
-
141
-		// Set the action
142
-		$this->parseAction($action);
143
-
144
-		if (is_null($prefix = Arr::get($this->action, 'prefix'))) {
145
-			$this->prefix($prefix);
146
-		}
147
-	}
148
-
149
-	// Getters
150
-
151
-	/**
152
-	 * Get the action of the current route.
153
-	 *
154
-	 * @return \Closure|string|array
155
-	 */
156
-	public function getAction()
157
-	{
158
-		return $this->action;
159
-	}
160
-
161
-	/**
162
-	 * Get the arguments of the current route.
163
-	 *
164
-	 * @return array
165
-	 */
166
-	public function getArguments()
167
-	{
168
-		return $this->wheres;
169
-	}
170
-
171
-	/**
172
-	 * Get the controller instance for the route.
173
-	 * 
174
-	 * @return mixed
175
-	 */
176
-	public function getController()
177
-	{
178
-		if ( ! $this->controller) {
179
-			$class = $this->parseControllerCallback()[0];
46
+    /**
47
+     * Action that the route will use when called.
48
+     *
49
+     * @var \Closure|string|array $action
50
+     */
51
+    public $action;
52
+
53
+    /**
54
+     * The container instance used by the route.
55
+     * 
56
+     * @var \Syscodes\Container\Container $container
57
+     */
58
+    protected $container;
59
+
60
+    /**
61
+     * The controller instance.
62
+     * 
63
+     * @var string $controller
64
+     */
65
+    public $controller;
66
+
67
+    /**
68
+     * The default values for the route.
69
+     * 
70
+     * @var array $defaults
71
+     */
72
+    public $defaults = [];
73
+
74
+    /**
75
+     * Variable of HTTP method.
76
+     *  
77
+     * @var array|string $method
78
+     */
79
+    public $method;
80
+
81
+    /**
82
+     * The array of matched parameters.
83
+     * 
84
+     * @var array $parameters
85
+     */
86
+    public $parameters = [];
87
+
88
+    /**
89
+     * The parameter names for the route.
90
+     * 
91
+     * @var string|null $parameterNames
92
+     */
93
+    public $parameterNames;
94
+
95
+    /**
96
+     * Patterns that should be replaced.
97
+     *
98
+     * @var array $patterns 
99
+     */
100
+    public $patterns = [
101
+        '~/~'                    =>  '\/',               // Slash
102
+        '~{an:[^\/{}]+}~'        => '([0-9a-zA-Z]++)',   // Placeholder accepts alphabetic and numeric chars
103
+        '~{n:[^\/{}]+}~'         => '([0-9]++)',         // Placeholder accepts only numeric
104
+        '~{a:[^\/{}]+}~'         => '([a-zA-Z]++)',      // Placeholder accepts only alphabetic chars
105
+        '~{w:[^\/{}]+}~'         => '([0-9a-zA-Z-_]++)', // Placeholder accepts alphanumeric and underscore
106
+        '~{\*:[^\/{}]+}~'        => '(.++)',             // Placeholder match rest of url
107
+        '~(\\\/)?{\?:[^\/{}]+}~' => '\/?([^\/]*)',		 // Optional placeholder
108
+        '~{[^\/{}]+}~'           => '([^\/]++)'			 // Normal placeholder
109
+    ];
110
+
111
+    /**
112
+     * The URI pattern the route responds to.
113
+     *
114
+     * @var array $uri
115
+     */
116
+    public $uri = [];
117
+
118
+    /**
119
+     * Contains the arguments of the current route.
120
+     *
121
+     * @var array $where
122
+     */
123
+    public $wheres = [];
124
+
125
+    /**
126
+     * Constructor. Initialize route.
127
+     *
128
+     * @param  array|string|null  $method  (null by default)
129
+     * @param  string|null  $uri  (null by default)
130
+     * @param  \Closure|string|null  $action  (null by default)
131
+     *
132
+     * @return void
133
+     */
134
+    public function __construct($method = null, $uri = null, $action = null)
135
+    {
136
+        $this->uri = $uri;
137
+
138
+        // Set the method
139
+        $this->parseMethod($method);
140
+
141
+        // Set the action
142
+        $this->parseAction($action);
143
+
144
+        if (is_null($prefix = Arr::get($this->action, 'prefix'))) {
145
+            $this->prefix($prefix);
146
+        }
147
+    }
148
+
149
+    // Getters
150
+
151
+    /**
152
+     * Get the action of the current route.
153
+     *
154
+     * @return \Closure|string|array
155
+     */
156
+    public function getAction()
157
+    {
158
+        return $this->action;
159
+    }
160
+
161
+    /**
162
+     * Get the arguments of the current route.
163
+     *
164
+     * @return array
165
+     */
166
+    public function getArguments()
167
+    {
168
+        return $this->wheres;
169
+    }
170
+
171
+    /**
172
+     * Get the controller instance for the route.
173
+     * 
174
+     * @return mixed
175
+     */
176
+    public function getController()
177
+    {
178
+        if ( ! $this->controller) {
179
+            $class = $this->parseControllerCallback()[0];
180 180
  
181
-			$this->controller = $this->container->make(ltrim($class, '\\'));
182
-		}
183
-
184
-		return $this->controller;
185
-	}
186
-
187
-	/**
188
-	 * Get the controller method used for the route.
189
-	 * 
190
-	 * @return string
191
-	 */
192
-	public function getControllerMethod()
193
-	{
194
-		return $this->parseControllerCallback()[1];
195
-	}
196
-
197
-	/**
198
-	 * Get the request method of the current route.
199
-	 *
200
-	 * @return array|string
201
-	 */
202
-	public function getMethod()
203
-	{
204
-		return $this->method;
205
-	}
206
-
207
-	/**
208
-	 * Get the url of the current route.
209
-	 *
210
-	 * @return string
211
-	 */
212
-	public function getName()
213
-	{
214
-		return $this->action['as'] ?? null;
215
-	}
216
-
217
-	/**
218
-	 * Get the url of the current route.
219
-	 *
220
-	 * @return array
221
-	 */
222
-	public function getRoute()
223
-	{
224
-		return $this->uri;
225
-	}
226
-
227
-	/**
228
-	 * Get or set the domain for the route.
229
-	 * 
230
-	 * @param  string|null  $domain  (null by default)
231
-	 * 
232
-	 * @return $this
233
-	 */
234
-	public function domain($domain = null)
235
-	{
236
-		if (is_null($domain)) {
237
-			return $this->getDomain();
238
-		}
239
-
240
-		$this->action['domain'] = $this->parseRoute($domain);
241
-
242
-		return $this;
243
-	}
244
-
245
-	/**
246
-	 * Get the domain defined for the route.
247
-	 * 
248
-	 * @return string|null
249
-	 */
250
-	public function getDomain()
251
-	{
252
-		return isset($this->action['domain'])
253
-				? str_replace(['http://', 'https://'], '', $this->action['domain'])
254
-				: null;
255
-	}
256
-
257
-	/**
258
-	 * Parse the controller.
259
-	 * 
260
-	 * @return array
261
-	 */
262
-	public function parseControllerCallback()
263
-	{
264
-		return Str::parseCallback($this->action['uses']);
265
-	}
181
+            $this->controller = $this->container->make(ltrim($class, '\\'));
182
+        }
183
+
184
+        return $this->controller;
185
+    }
186
+
187
+    /**
188
+     * Get the controller method used for the route.
189
+     * 
190
+     * @return string
191
+     */
192
+    public function getControllerMethod()
193
+    {
194
+        return $this->parseControllerCallback()[1];
195
+    }
196
+
197
+    /**
198
+     * Get the request method of the current route.
199
+     *
200
+     * @return array|string
201
+     */
202
+    public function getMethod()
203
+    {
204
+        return $this->method;
205
+    }
206
+
207
+    /**
208
+     * Get the url of the current route.
209
+     *
210
+     * @return string
211
+     */
212
+    public function getName()
213
+    {
214
+        return $this->action['as'] ?? null;
215
+    }
216
+
217
+    /**
218
+     * Get the url of the current route.
219
+     *
220
+     * @return array
221
+     */
222
+    public function getRoute()
223
+    {
224
+        return $this->uri;
225
+    }
226
+
227
+    /**
228
+     * Get or set the domain for the route.
229
+     * 
230
+     * @param  string|null  $domain  (null by default)
231
+     * 
232
+     * @return $this
233
+     */
234
+    public function domain($domain = null)
235
+    {
236
+        if (is_null($domain)) {
237
+            return $this->getDomain();
238
+        }
239
+
240
+        $this->action['domain'] = $this->parseRoute($domain);
241
+
242
+        return $this;
243
+    }
244
+
245
+    /**
246
+     * Get the domain defined for the route.
247
+     * 
248
+     * @return string|null
249
+     */
250
+    public function getDomain()
251
+    {
252
+        return isset($this->action['domain'])
253
+                ? str_replace(['http://', 'https://'], '', $this->action['domain'])
254
+                : null;
255
+    }
256
+
257
+    /**
258
+     * Parse the controller.
259
+     * 
260
+     * @return array
261
+     */
262
+    public function parseControllerCallback()
263
+    {
264
+        return Str::parseCallback($this->action['uses']);
265
+    }
266 266
 	
267
-	/**
268
-	 * Checks whether the route's action is a controller.
269
-	 * 
270
-	 * @return bool
271
-	 */
272
-	public function isControllerAction()
273
-	{
274
-		return is_string($this->action['uses']);
275
-	}
276
-
277
-	/**
278
-	 * Get the dispatcher for the route's controller.
279
-	 * 
280
-	 * @return \Syscodes\Controller\ControllerDispatcher
281
-	 */
282
-	private function controllerDispatcher()
283
-	{
284
-		return new ControllerDispatcher($this->container);
285
-	}
286
-
287
-	// Setters
267
+    /**
268
+     * Checks whether the route's action is a controller.
269
+     * 
270
+     * @return bool
271
+     */
272
+    public function isControllerAction()
273
+    {
274
+        return is_string($this->action['uses']);
275
+    }
276
+
277
+    /**
278
+     * Get the dispatcher for the route's controller.
279
+     * 
280
+     * @return \Syscodes\Controller\ControllerDispatcher
281
+     */
282
+    private function controllerDispatcher()
283
+    {
284
+        return new ControllerDispatcher($this->container);
285
+    }
286
+
287
+    // Setters
288 288
 	
289
-	/**
290
-	 * Run the route action and return the response.
291
-	 * 
292
-	 * @return mixed
293
-	 */
294
-	public function runResolver()
295
-	{
296
-		$this->container = $this->container ?: new Container;
297
-
298
-		try {
299
-			if ($this->isControllerAction()) {
300
-				return $this->runResolverController();
301
-			}
302
-
303
-			return $this->runResolverCallable();
304
-		} catch (HttpResponseException $e) {
305
-			return $e->getResponse();
306
-		}
307
-	}
308
-
309
-	/**
310
-	 * Run the route action and return the response.
311
-	 *  
312
-	 * @return mixed
313
-	 */
314
-	protected function runResolverCallable()
315
-	{
316
-		$callable = $this->action['uses'];
317
-
318
-		return $callable(...array_values($this->resolveMethodDependencies(
319
-			$this->parametersWithouNulls(), new ReflectionFunction($this->action['uses'])
320
-		)));
321
-	}
322
-
323
-	/**
324
-	 * Run the route action and return the response.
325
-	 * 
326
-	 * @return mixed
327
-	 */
328
-	protected function runResolverController()
329
-	{
330
-		return $this->controllerDispatcher()->dispatch($this, $this->getController(), $this->getControllerMethod());
331
-	}
332
-
333
-	/**
334
-	 * Set the action.
335
-	 *
336
-	 * @param  \Closure|string  $action
337
-	 *
338
-	 * @return $this
339
-	 *
340
-	 * @throws \InvalidArgumentException
341
-	 */
342
-	public function parseAction($action)
343
-	{
344
-		if ( ! (is_object($action) && ($action instanceof Closure)) && ($action === null || $action === '')) {
345
-			throw new InvalidArgumentException(__('route.actionClosureOrFunction'));
346
-		}
347
-
348
-		$this->action = RouteAction::parse($this->uri, $action);
349
-
350
-		return $this;
351
-	}
352
-
353
-	/**
354
-	 * Set the method of the current route.
355
-	 *
356
-	 * @param  array  $method
357
-	 *
358
-	 * @return string $this
359
-	 * 
360
-	 * @throws \InvalidArgumentException
361
-	 */
362
-	public function parseMethod($method)
363
-	{
364
-		if ($method === null || empty($method)) {
365
-			throw new InvalidArgumentException(__('route.methodNotProvided'));
289
+    /**
290
+     * Run the route action and return the response.
291
+     * 
292
+     * @return mixed
293
+     */
294
+    public function runResolver()
295
+    {
296
+        $this->container = $this->container ?: new Container;
297
+
298
+        try {
299
+            if ($this->isControllerAction()) {
300
+                return $this->runResolverController();
301
+            }
302
+
303
+            return $this->runResolverCallable();
304
+        } catch (HttpResponseException $e) {
305
+            return $e->getResponse();
306
+        }
307
+    }
308
+
309
+    /**
310
+     * Run the route action and return the response.
311
+     *  
312
+     * @return mixed
313
+     */
314
+    protected function runResolverCallable()
315
+    {
316
+        $callable = $this->action['uses'];
317
+
318
+        return $callable(...array_values($this->resolveMethodDependencies(
319
+            $this->parametersWithouNulls(), new ReflectionFunction($this->action['uses'])
320
+        )));
321
+    }
322
+
323
+    /**
324
+     * Run the route action and return the response.
325
+     * 
326
+     * @return mixed
327
+     */
328
+    protected function runResolverController()
329
+    {
330
+        return $this->controllerDispatcher()->dispatch($this, $this->getController(), $this->getControllerMethod());
331
+    }
332
+
333
+    /**
334
+     * Set the action.
335
+     *
336
+     * @param  \Closure|string  $action
337
+     *
338
+     * @return $this
339
+     *
340
+     * @throws \InvalidArgumentException
341
+     */
342
+    public function parseAction($action)
343
+    {
344
+        if ( ! (is_object($action) && ($action instanceof Closure)) && ($action === null || $action === '')) {
345
+            throw new InvalidArgumentException(__('route.actionClosureOrFunction'));
346
+        }
347
+
348
+        $this->action = RouteAction::parse($this->uri, $action);
349
+
350
+        return $this;
351
+    }
352
+
353
+    /**
354
+     * Set the method of the current route.
355
+     *
356
+     * @param  array  $method
357
+     *
358
+     * @return string $this
359
+     * 
360
+     * @throws \InvalidArgumentException
361
+     */
362
+    public function parseMethod($method)
363
+    {
364
+        if ($method === null || empty($method)) {
365
+            throw new InvalidArgumentException(__('route.methodNotProvided'));
366 366
 			
367
-		}
368
-
369
-		foreach ($method as $httpMethod) {
370
-			if ( ! in_array($httpMethod, ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'ANY'])) {
371
-				throw new InvalidArgumentException(__('route.methodNotAllowed'));				
372
-			}
373
-		}
374
-
375
-	    $this->method = $method;
376
-
377
-	    return $this;
378
-	}
379
-
380
-	/**
381
-	 * Set the route.
382
-	 *
383
-	 * @param  string|array|null  $uri
384
-	 *
385
-	 * @return string
386
-	 *
387
-	 * @throws  \InvalidArgumentException
388
-	 */
389
-	public function parseRoute($uri)
390
-	{
391
-		if ($uri === null) {
392
-			throw new InvalidArgumentException(__('route.uriNotProvided'));
393
-		}	
394
-
395
-		$this->uri = $this->parseRoutePath($uri);
396
-
397
-		return $this;
398
-	}
399
-
400
-	/**
401
-	 * Replace word patterns with regex in route uri.
402
-	 * 
403
-	 * @param  string  $uri
404
-	 * 
405
-	 * @return string
406
-	 */
407
-	protected function parseRoutePath($uri)
408
-	{
409
-		$uri = trim($uri, '\/?');
410
-		$uri = trim($uri, '\/');
367
+        }
368
+
369
+        foreach ($method as $httpMethod) {
370
+            if ( ! in_array($httpMethod, ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'ANY'])) {
371
+                throw new InvalidArgumentException(__('route.methodNotAllowed'));				
372
+            }
373
+        }
374
+
375
+        $this->method = $method;
376
+
377
+        return $this;
378
+    }
379
+
380
+    /**
381
+     * Set the route.
382
+     *
383
+     * @param  string|array|null  $uri
384
+     *
385
+     * @return string
386
+     *
387
+     * @throws  \InvalidArgumentException
388
+     */
389
+    public function parseRoute($uri)
390
+    {
391
+        if ($uri === null) {
392
+            throw new InvalidArgumentException(__('route.uriNotProvided'));
393
+        }	
394
+
395
+        $this->uri = $this->parseRoutePath($uri);
396
+
397
+        return $this;
398
+    }
399
+
400
+    /**
401
+     * Replace word patterns with regex in route uri.
402
+     * 
403
+     * @param  string  $uri
404
+     * 
405
+     * @return string
406
+     */
407
+    protected function parseRoutePath($uri)
408
+    {
409
+        $uri = trim($uri, '\/?');
410
+        $uri = trim($uri, '\/');
411 411
 		
412
-		preg_match_all('/\{([\w\:]+?)\??\}/', $uri, $matches);
412
+        preg_match_all('/\{([\w\:]+?)\??\}/', $uri, $matches);
413 413
 		
414
-		foreach ($matches[1] as $match) {
415
-			if (strpos($match, ':') === false) {
416
-				continue;
417
-			}
414
+        foreach ($matches[1] as $match) {
415
+            if (strpos($match, ':') === false) {
416
+                continue;
417
+            }
418 418
 			
419
-			$pattern  = array_keys($this->patterns);
420
-			$replace  = array_values($this->patterns);
421
-			$segments = explode(':', trim($match, '{}?'));
419
+            $pattern  = array_keys($this->patterns);
420
+            $replace  = array_values($this->patterns);
421
+            $segments = explode(':', trim($match, '{}?'));
422 422
 			
423
-			$uri = strpos($match, ':') !== false
424
-					? preg_replace($pattern, $replace, $uri)
425
-					: str_replace($match, '{'.$segments[0].'}', $uri);
426
-		}
423
+            $uri = strpos($match, ':') !== false
424
+                    ? preg_replace($pattern, $replace, $uri)
425
+                    : str_replace($match, '{'.$segments[0].'}', $uri);
426
+        }
427 427
 		
428
-		return $uri;
429
-	}
430
-
431
-	/**
432
-	 * Add a prefix to the route URI.
433
-	 * 
434
-	 * @param  string  $prefix
435
-	 * 
436
-	 * @return $this
437
-	 */
438
-	public function prefix($prefix)
439
-	{
440
-		if ( ! empty($newPrefix = trim(rtrim($prefix, '/').'/'.ltrim($this->action['prefix'] ?? '', '/'), '/'))) {
441
-			$this->action['prefix'] = $newPrefix;
442
-		}
428
+        return $uri;
429
+    }
430
+
431
+    /**
432
+     * Add a prefix to the route URI.
433
+     * 
434
+     * @param  string  $prefix
435
+     * 
436
+     * @return $this
437
+     */
438
+    public function prefix($prefix)
439
+    {
440
+        if ( ! empty($newPrefix = trim(rtrim($prefix, '/').'/'.ltrim($this->action['prefix'] ?? '', '/'), '/'))) {
441
+            $this->action['prefix'] = $newPrefix;
442
+        }
443 443
 		
444
-		$uri = rtrim($prefix, '/').'/'.ltrim($this->uri, '/');
444
+        $uri = rtrim($prefix, '/').'/'.ltrim($this->uri, '/');
445 445
 		
446
-		return $this->parseRoute($uri !== '/' ? trim($uri, '/') : $uri);
447
-	}
448
-
449
-	/**
450
-	 * Set the action array for the route.
451
-	 * 
452
-	 * @param  array  $action
453
-	 * 
454
-	 * @return $this
455
-	 */
456
-	public function setAction(array $action)
457
-	{
458
-		$this->action = $action;
459
-
460
-		if (isset($this->action['domain'])) {
461
-			$this->domain($this->action['domain']);
462
-		}
446
+        return $this->parseRoute($uri !== '/' ? trim($uri, '/') : $uri);
447
+    }
448
+
449
+    /**
450
+     * Set the action array for the route.
451
+     * 
452
+     * @param  array  $action
453
+     * 
454
+     * @return $this
455
+     */
456
+    public function setAction(array $action)
457
+    {
458
+        $this->action = $action;
459
+
460
+        if (isset($this->action['domain'])) {
461
+            $this->domain($this->action['domain']);
462
+        }
463 463
 		
464
-		return $this;
465
-	}
466
-
467
-	/**
468
-	 * Set the name.
469
-	 *
470
-	 * @param  string  $name
471
-	 *
472
-	 * @return $this
473
-	 */
474
-	public function name($name)
475
-	{
476
-		$this->action['as'] = isset($this->action['as']) ? $this->action['as'].$name : $name;
477
-
478
-		return $this;
479
-	}
480
-
481
-	/**
482
-	 * Determine whether the route's name matches the given patterns.
483
-	 * 
484
-	 * @param  mixed  ...$patterns
485
-	 * 
486
-	 * @return bool
487
-	 */
488
-	public function named(...$patterns)
489
-	{
490
-		if (is_null($routeName = $this->getName())) {
491
-			return false;
492
-		}
493
-
494
-		foreach ($patterns as $pattern) {
495
-			if (Str::is($pattern, $routeName)) {
496
-				return true;
497
-			}
498
-		}
499
-
500
-		return false;
501
-	}
502
-
503
-	/**
504
-	 * Set a default value for the route.
505
-	 * 
506
-	 * @param  string  $key
507
-	 * @param  mixed   $value
508
-	 * 
509
-	 * @return $this
510
-	 */
511
-	public function defaults($key, $value)
512
-	{
513
-		$this->defaults[$key] = $value;
514
-
515
-		return $this;
516
-	}
517
-
518
-	/**
519
-	 * Set a default values for the route.
520
-	 * 
521
-	 * @param  string  $defaults
522
-	 * 
523
-	 * @return $this
524
-	 */
525
-	public function setDefaults(array $defaults)
526
-	{
527
-		$this->defaults = $defaults;
528
-
529
-		return $this;
530
-	}
531
-
532
-	/**
533
-	 * Set the where.
534
-	 *
535
-	 * @param  array|string  $name
536
-	 * @param  string|null  $expression  (null by default)
537
-	 *
538
-	 * @return $this
539
-	 */
540
-	public function where($name, string $expression = null)
541
-	{
542
-		$wheres = is_array($name) ? $name : [$name => $expression];
464
+        return $this;
465
+    }
466
+
467
+    /**
468
+     * Set the name.
469
+     *
470
+     * @param  string  $name
471
+     *
472
+     * @return $this
473
+     */
474
+    public function name($name)
475
+    {
476
+        $this->action['as'] = isset($this->action['as']) ? $this->action['as'].$name : $name;
477
+
478
+        return $this;
479
+    }
480
+
481
+    /**
482
+     * Determine whether the route's name matches the given patterns.
483
+     * 
484
+     * @param  mixed  ...$patterns
485
+     * 
486
+     * @return bool
487
+     */
488
+    public function named(...$patterns)
489
+    {
490
+        if (is_null($routeName = $this->getName())) {
491
+            return false;
492
+        }
493
+
494
+        foreach ($patterns as $pattern) {
495
+            if (Str::is($pattern, $routeName)) {
496
+                return true;
497
+            }
498
+        }
499
+
500
+        return false;
501
+    }
502
+
503
+    /**
504
+     * Set a default value for the route.
505
+     * 
506
+     * @param  string  $key
507
+     * @param  mixed   $value
508
+     * 
509
+     * @return $this
510
+     */
511
+    public function defaults($key, $value)
512
+    {
513
+        $this->defaults[$key] = $value;
514
+
515
+        return $this;
516
+    }
517
+
518
+    /**
519
+     * Set a default values for the route.
520
+     * 
521
+     * @param  string  $defaults
522
+     * 
523
+     * @return $this
524
+     */
525
+    public function setDefaults(array $defaults)
526
+    {
527
+        $this->defaults = $defaults;
528
+
529
+        return $this;
530
+    }
531
+
532
+    /**
533
+     * Set the where.
534
+     *
535
+     * @param  array|string  $name
536
+     * @param  string|null  $expression  (null by default)
537
+     *
538
+     * @return $this
539
+     */
540
+    public function where($name, string $expression = null)
541
+    {
542
+        $wheres = is_array($name) ? $name : [$name => $expression];
543 543
 		
544
-		foreach ($wheres as $name => $expression) {
545
-			$this->wheres[$name] = $expression;
546
-		}
547
-
548
-		return $this;
549
-	}
550
-
551
-	/**
552
-	 * Bind the route to a given request for execution.
553
-	 * 
554
-	 * @param  \Syscodes\Http\Request  $request
555
-	 * 
556
-	 * @return $this
557
-	 */
558
-	public function bind(Request $request)
559
-	{
560
-		$this->parameters = (new RouteParamBinding($this))->parameters($request);
561
-
562
-		return $this;
563
-	}
564
-
565
-	/**
566
-	 * Get all of the parameter names for the route.
567
-	 * 
568
-	 * @return array
569
-	 */
570
-	public function parameterNames()
571
-	{
572
-		if (isset($this->parameterNames)) {
573
-			return $this->parameterNames;
574
-		}
575
-
576
-		return $this->parameterNames = $this->compileParamNames();
577
-	}
578
-
579
-	/**
580
-	 * Get the parameter names for the route.
581
-	 * 
582
-	 * @return array
583
-	 */
584
-	protected function compileParamNames()
585
-	{
586
-		preg_match_all('~[^\/\{(.*?)\}]~', $this->domain().$this->uri, $matches);
587
-
588
-		return array_map(function ($match) {
589
-			return trim($match, '?');
590
-		}, $matches[0]);
591
-	}
592
-
593
-	/**
594
-	 * Get a given parameter from the route.
595
-	 * 
596
-	 * @param  string  $name
597
-	 * @param  mixed  $default  (null by default)
598
-	 * 
599
-	 * @return array
600
-	 */
601
-	public function parameter($name, $default = null)
602
-	{
603
-		return Arr::get($this->parameters(), $name, $default);
604
-	}
605
-
606
-	/**
607
-	 * Set a parameter to the given value.
608
-	 * 
609
-	 * @param  string  $name
610
-	 * @param  mixed  $value
611
-	 * 
612
-	 * @return array
613
-	 */
614
-	public function setParameter($name, $value)
615
-	{
616
-		$this->parameters();
617
-
618
-		$this->parameters[$name] = $value;
619
-	}
620
-
621
-	/**
622
-	 * Get the key / value list of parameters without null values.
623
-	 * 
624
-	 * @return array
625
-	 */
626
-	public function parametersWithouNulls()
627
-	{
628
-		return array_filter($this->parameters(), function ($parameter) {
629
-			return ! is_null($parameter);
630
-		});
631
-	}
632
-
633
-	/**
634
-	 * Get the key / value list of parameters for the route.
635
-	 * 
636
-	 * @return array
637
-	 */
638
-	public function parameters()
639
-	{
640
-		if (isset($this->parameters)) {
641
-			return $this->parameters;
642
-		}
643
-
644
-		throw new LogicException('The route is not bound.');
645
-	}
646
-
647
-	/**
648
-	 * Determine if the route only responds to HTTP requests.
649
-	 * 
650
-	 * @return bool
651
-	 */
652
-	public function httpOnly()
653
-	{
654
-		return in_array('http', $this->action, true);
655
-	}
656
-
657
-	/**
658
-	 * Determine if the route only responds to HTTPS requests.
659
-	 * 
660
-	 * @return bool
661
-	 */
662
-	public function httpsOnly()
663
-	{
664
-		return $this->secure();
665
-	}
666
-
667
-	/**
668
-	 * Determine if the route only responds to HTTPS requests.
669
-	 * 
670
-	 * @return bool
671
-	 */
672
-	public function secure()
673
-	{
674
-		return in_array('https', $this->action, true);
675
-	}
676
-
677
-	/**
678
-	 * Set the container instance on the route.
679
-	 * 
680
-	 * @param  \Syscodes\Container\Container  $container
681
-	 * 
682
-	 * @return $this
683
-	 */
684
-	public function setContainer(Container $container)
685
-	{
686
-		$this->container = $container;
687
-
688
-		return $this;
689
-	}
690
-
691
-	/**
692
-	 * Dynamically access route parameters.
693
-	 * 
694
-	 * @param  string  $key
695
-	 * 
696
-	 * @return mixed
697
-	 */
698
-	public function __get($key)
699
-	{
700
-		return $this->parameter($key);
701
-	}
544
+        foreach ($wheres as $name => $expression) {
545
+            $this->wheres[$name] = $expression;
546
+        }
547
+
548
+        return $this;
549
+    }
550
+
551
+    /**
552
+     * Bind the route to a given request for execution.
553
+     * 
554
+     * @param  \Syscodes\Http\Request  $request
555
+     * 
556
+     * @return $this
557
+     */
558
+    public function bind(Request $request)
559
+    {
560
+        $this->parameters = (new RouteParamBinding($this))->parameters($request);
561
+
562
+        return $this;
563
+    }
564
+
565
+    /**
566
+     * Get all of the parameter names for the route.
567
+     * 
568
+     * @return array
569
+     */
570
+    public function parameterNames()
571
+    {
572
+        if (isset($this->parameterNames)) {
573
+            return $this->parameterNames;
574
+        }
575
+
576
+        return $this->parameterNames = $this->compileParamNames();
577
+    }
578
+
579
+    /**
580
+     * Get the parameter names for the route.
581
+     * 
582
+     * @return array
583
+     */
584
+    protected function compileParamNames()
585
+    {
586
+        preg_match_all('~[^\/\{(.*?)\}]~', $this->domain().$this->uri, $matches);
587
+
588
+        return array_map(function ($match) {
589
+            return trim($match, '?');
590
+        }, $matches[0]);
591
+    }
592
+
593
+    /**
594
+     * Get a given parameter from the route.
595
+     * 
596
+     * @param  string  $name
597
+     * @param  mixed  $default  (null by default)
598
+     * 
599
+     * @return array
600
+     */
601
+    public function parameter($name, $default = null)
602
+    {
603
+        return Arr::get($this->parameters(), $name, $default);
604
+    }
605
+
606
+    /**
607
+     * Set a parameter to the given value.
608
+     * 
609
+     * @param  string  $name
610
+     * @param  mixed  $value
611
+     * 
612
+     * @return array
613
+     */
614
+    public function setParameter($name, $value)
615
+    {
616
+        $this->parameters();
617
+
618
+        $this->parameters[$name] = $value;
619
+    }
620
+
621
+    /**
622
+     * Get the key / value list of parameters without null values.
623
+     * 
624
+     * @return array
625
+     */
626
+    public function parametersWithouNulls()
627
+    {
628
+        return array_filter($this->parameters(), function ($parameter) {
629
+            return ! is_null($parameter);
630
+        });
631
+    }
632
+
633
+    /**
634
+     * Get the key / value list of parameters for the route.
635
+     * 
636
+     * @return array
637
+     */
638
+    public function parameters()
639
+    {
640
+        if (isset($this->parameters)) {
641
+            return $this->parameters;
642
+        }
643
+
644
+        throw new LogicException('The route is not bound.');
645
+    }
646
+
647
+    /**
648
+     * Determine if the route only responds to HTTP requests.
649
+     * 
650
+     * @return bool
651
+     */
652
+    public function httpOnly()
653
+    {
654
+        return in_array('http', $this->action, true);
655
+    }
656
+
657
+    /**
658
+     * Determine if the route only responds to HTTPS requests.
659
+     * 
660
+     * @return bool
661
+     */
662
+    public function httpsOnly()
663
+    {
664
+        return $this->secure();
665
+    }
666
+
667
+    /**
668
+     * Determine if the route only responds to HTTPS requests.
669
+     * 
670
+     * @return bool
671
+     */
672
+    public function secure()
673
+    {
674
+        return in_array('https', $this->action, true);
675
+    }
676
+
677
+    /**
678
+     * Set the container instance on the route.
679
+     * 
680
+     * @param  \Syscodes\Container\Container  $container
681
+     * 
682
+     * @return $this
683
+     */
684
+    public function setContainer(Container $container)
685
+    {
686
+        $this->container = $container;
687
+
688
+        return $this;
689
+    }
690
+
691
+    /**
692
+     * Dynamically access route parameters.
693
+     * 
694
+     * @param  string  $key
695
+     * 
696
+     * @return mixed
697
+     */
698
+    public function __get($key)
699
+    {
700
+        return $this->parameter($key);
701
+    }
702 702
 }
703 703
\ No newline at end of file
Please login to merge, or discard this patch.