Merge pull request #174 from skipperbent/v2-development

Optimisations + bugfixes
Make sure parameter-modifier is found before parsing parameters.
2026-06-17 16:57:53 +00:00 · 2016-11-24 11:05:57 +02:00 · 2016-11-24 10:04:47 +01:00 · 2016-11-24 09:56:21 +01:00 · 2016-11-24 09:42:37 +01:00 · 2016-11-24 09:36:10 +01:00
43 changed files with 2373 additions and 1354 deletions
@@ -18,7 +18,7 @@ The goal of this project is to create a router that is 100% compatible with the

 ### Features

- Basic routing (`GET`, `POST`, `PUT`, `DELETE`) with support for custom multiple verbs.
+- Basic routing (`GET`, `POST`, `PUT`, `PATCH`, `UPDATE`, `DELETE`) with support for custom multiple verbs.
 - Regular Expression Constraints for parameters.
 - Named routes.
 - Generating url to routes.
@@ -54,10 +54,10 @@ require_once 'routes.php';

 /* 
 * The default namespace for route-callbacks, so we don't have to specify it each time.
- * Can be overwritten by using the namespace config option.
+ * Can be overwritten by using the namespace config option on your routes.
 */
 
-SimpleRouter::setDefaultNamespace('MyWebsite\Controller');
+SimpleRouter::setDefaultNamespace('MyWebsite');

 // Start the routing
 SimpleRouter::start();
@@ -78,45 +78,74 @@ use Pecee\SimpleRouter\SimpleRouter;

 /*
 * This route will match the url /v1/services/answers/1/
-
 * The middleware is just a class that renders before the
- * Controller or callback is loaded. This is useful for stopping
- * the request, for instance if a user is not authenticated.
+ * controller or callback is loaded. 
+ * 
+ * This is useful for stopping the request, for 
+ * instance if a user is not authenticated etc.
 */

-// Add CSRF support (if needed)
-SimpleRouter::csrfVerifier(new \Pecee\Http\Middleware\BaseCsrfVerifier());
+
+// Add your csrfVerifier here
+
+SimpleRouter::csrfVerifier(new \Demo\Middlewares\CsrfVerifier());
+
+SimpleRouter::group(['middleware' => 'Middlewares\Site', 'exceptionHandler' => 'Handlers\CustomExceptionHandler'], function() {
+
+
+    SimpleRouter::get('/answers/{id}', 'ControllerAnswers@show', ['where' => ['id' => '[0-9]+']]);
+
+    /**
+     * Using optional parameters
+     */
+    SimpleRouter::get('/answers/{id?}', 'ControllerAnswers@show');
+
+        
+    /**
+     * This example will route url when matching the regular expression to the method.
+     * For example route: domain.com/ajax/music/world -> ControllerAjax@process (parameter: music/world)
+     */ 
+     
+    SimpleRouter::all('/ajax', 'ControllerAjax@process')->setMatch('.*?\\/ajax\\/([A-Za-z0-9\\/]+)');
+
+
+    /**
+     * Restful resource (see IRestController interface for available methods)
+     */
+     
+    SimpleRouter::resource('/rest', 'ControllerRessource');
+
+
+    /**
+     * Load the entire controller (where url matches method names - getIndex(), postIndex(), putIndex()). 
+     * The url paths will determine which method to render.
+     *
+     * For example:
+     *
+     * GET  /animals         => getIndex()
+     * GET  /animals/view    => getView()
+     * POST /animals/save    => postSave()
+     *
+     * etc.
+     */
+     
+    SimpleRouter::controller('/animals', 'ControllerAnimals');
+
+
+    /**
+     * Example of providing callback instead of Controller
+     */
+     
+    SimpleRouter::post('/something', function() {
+    
+        die('Callback example');
+        
+    });
+
+});

 SimpleRouter::get('/page/404', 'ControllerPage@notFound', ['as' => 'page.notfound']);

-SimpleRouter::group(['prefix' => '/v1', 'middleware' => '\MyWebsite\Middleware\SomeMiddlewareClass'], function() {
-
-    SimpleRouter::group(['prefix' => '/services', 'exceptionHandler' => '\MyProject\Handler\CustomExceptionHandler'], function() {
-
-        SimpleRouter::get('/answers/{id}', 'ControllerAnswers@show')->where(['id' => '[0-9]+');
-
-        // Optional parameter
-        SimpleRouter::get('/answers/{id?}', 'ControllerAnswers@show');
-
-        /**
-         * This example will route url when matching the regular expression to the method.
-         * For example route: domain.com/ajax/music/world -> ControllerAjax@process (parameter: music/world)
-         */
-        SimpleRouter::all('/ajax', 'ControllerAjax@process')->match('.*?\\/ajax\\/([A-Za-z0-9\\/]+)');
-
-        // Restful resource (see IRestController interface for available methods)
-        SimpleRouter::resource('/rest', 'ControllerRessource');
-
-        // Load the entire controller (where url matches method names - getIndex(), postIndex() etc)
-        SimpleRouter::controller('/controller', 'ControllerDefault');
-
-        // Example of providing callback instead of Controller
-        SimpleRouter::get('/something', function() {
-            die('Callback example');
-        });
-
-    });
-});
 ```

 #### ExceptionHandler example
@@ -126,32 +155,45 @@ This is a basic example of an ExceptionHandler implementation:
 ```php
 namespace Demo\Handlers;

+use Pecee\Handlers\IExceptionHandler;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

-class CustomExceptionHandler implements IExceptionHandler {
+class CustomExceptionHandler implements IExceptionHandler
+{
+	public function handleError(Request $request, ILoadableRoute &$route = null, \Exception $error)
+	{

-    public function handleError( Request $request, RouterEntry $router = null, \Exception $error) {
+		/* You can use the exception handler to format errors depending on the request and type. */

-        // If the error-code is 404; show another route which contains the page-not-found
-        if($error->getCode() === 404) {
-        
-            // Throw your custom 404-page view
-            // - or -
-            // load another route with our 404 page
-            // - or -
-            // you can return the $request object to ignore the error and continue on rendering the route.
-            
-            return $request->setUri(url('page.notfound'));
-        }
+		if (stripos($request->getUri(), '/api') !== false) {

-        // Output error as json if on api path.
-        if(stripos($request->getUri(), '/api') !== false) {
-            response()->json([ 'error' => $error->getMessage() ]);
-        }
+			response()->json([
+				'error' => $error->getMessage(),
+				'code'  => $error->getCode(),
+			]);

-        // Otherwise default exception will be thrown by the router.
-    }
+		}
+
+		/* The router will throw the NotFoundHttpException on 404 */
+		if($error instanceof NotFoundHttpException) {
+
+			/*
+			 * Render your own custom 404-view, rewrite the request to another route,
+			 * or simply return the $request object to ignore the error and continue on rendering the route.
+			 *
+			 * The code below will make the router render our page.notfound route.
+			 */
+
+			$request->setUri(url('page.notfound'));
+			return $request;
+
+		}
+
+		throw $error;
+		
+	}

 }
 ```
@@ -162,40 +204,47 @@ Route groups may also be used to route wildcard sub-domains. Sub-domains may be

 ```php
 Route::group(['domain' => '{account}.myapp.com'], function () {
+
    Route::get('user/{id}', function ($account, $id) {
-        //
+        // Do stuff...
    });
+    
 });
 ```

 The prefix group array attribute may be used to prefix each route in the group with a given URI. For example, you may want to prefix all route URIs within the group with admin:

-### Doing it the object oriented (hardcore) way
+### Adding routes manually (with no helper)

-The ```SimpleRouter``` class referenced in the previous example, is just a simple helper class that knows how to communicate with the ```RouterBase``` class.
+The ```SimpleRouter``` class referenced in the previous example, is just a simple helper class that knows how to communicate with the ```Router``` class.
 If you are up for a challenge, want the full control or simply just want to create your own ```Router``` helper class, this example is for you.

 ```php
-use \Pecee\SimpleRouter\RouterBase;
-use \Pecee\SimpleRouter\RouterRoute;
+use \Pecee\SimpleRouter\Router;
+use \Pecee\SimpleRouter\Route\RouteUrl;

-$router = RouterBase::getInstance();
+/* Grap the router instance */
+$router = Router::getInstance();
+
+$route = new RouteUrl('/answer/1', function() {

-$route = new RouterRoute('/answer/1', function() {
    die('this callback will match /answer/1');
+    
 });

-$route->setMiddleware('\HSWebserviceV1\Middleware\AuthMiddleware');
+$route->setMiddleware('\Demo\Middlewares\AuthMiddleware');
 $route->setNamespace('MyWebsite');
 $route->setPrefix('v1');

-// Add the route to the router
+/* Add the route to the router */
 $router->addRoute($route);
 ```

+### Extending
+
 This is a simple example of an integration into a framework.

-The framework has it's own ```Router``` class which inherits from the ```SimpleRouter``` class. This allows the framework to add custom functionality.
+The framework has it's own ```Router``` class which inherits from the ```SimpleRouter``` class. This allows the framework to add custom functionality like loading a custom `routes.php` file or add debugging information etc.

 ```php
 namespace Demo;
@@ -227,8 +276,25 @@ To simplify to use of simple-router functionality, we recommend you add these he
 ```php
 use Pecee\SimpleRouter\SimpleRouter;

-function url($controller, $parameters = null, $getParams = null) {
-    SimpleRouter::getRoute($controller, $parameters, $getParams);
+/**
+ * Get url for a route by using either name/alias, class or method name.
+ *
+ * The name parameter supports the following values:
+ * - Route name
+ * - Controller/resource name (with or without method)
+ * - Controller class name
+ *
+ * When searching for controller/resource by name, you can use this syntax "route.name@method".
+ * You can also use the same syntax when searching for a specific controller-class "MyController@home".
+ * If no arguments is specified, it will return the url for the current loaded route.
+ *
+ * @param string|null $name
+ * @param string|array|null $parameters
+ * @param array|null $getParams
+ * @return string
+ */
+function url($name = null, $parameters = null, $getParams = null) {
+    SimpleRouter::getUrl($name, $parameters, $getParams);
 }

 /**
@@ -267,22 +333,78 @@ function input() {

 ## Getting urls

-**In ```routes.php``` we have added this route:**
+By default all controller and resource routes will use a simplified version of their url as name.
+
+**Get routes using custom name (single route)**

 ```php
-SimpleRouter::get('/item/{id}', 'myController@show', ['as' => 'item']);
+SimpleRouter::get('/product-view/{id}', 'ProductsController@show', ['as' => 'product']);
+
+url('product', ['id' => 22], ['category' => 'shoes']);
+
+# output
+# /product-view/22/?category=shoes
 ```

-**In the template we then call:**
+**Getting the url using the name (controller route)**

 ```php
-url('item', ['id' => 22], ['category' => 'shoes']);
+SimpleRouter::controller('/images', 'ImagesController', ['as' => 'picture']);
+
+url('picture@getView', null, ['category' => 'shoes']);
+url('picture', 'getView', ['category' => 'shoes']);
+
+# output
+# /images/view/?category=shows
+# /images/view/?category=shows
 ```

-**Result url is:**
+**Getting the url using class**

 ```php
-/item/22/?category=shoes
+SimpleRouter::get('/product-view/{id}', 'ProductsController@show', ['as' => 'product']);
+SimpleRouter::controller('/images', 'ImagesController');
+
+url('ProductsController@show', ['id' => 22], ['category' => 'shoes']);
+url('ImagesController@getImage', null, ['id' => 22]);
+
+# output
+# /product-view/22/?category=shoes
+# /images/image/?category=shows
+```
+
+**Using custom names for methods on a controller/resource route**
+
+```php
+SimpleRouter::controller('gadgets', 'GadgetsController', ['names' => ['getIphoneInfo' => 'iphone']]);
+
+url('gadgets.iphone');
+
+# output
+# /gadgets/iphoneinfo/
+```
+
+**Getting REST/resource controller urls**
+
+```php
+SimpleRouter::resource('/phones', 'PhonesController');
+
+url('phones');
+url('phones.index');
+url('phones.create');
+url('phones.edit');
+
+// etc..
+
+# output
+# /phones/
+# /phones/create/
+# /phones/edit/
+```
+
+**Return the current url**
+```php
+url();
 ```

 ## Custom CSRF verifier
@@ -297,10 +419,10 @@ Querystrings are ignored.
 use Pecee\Http\Middleware\BaseCsrfVerifier;

 class CsrfVerifier extends BaseCsrfVerifier {
-
+    
    protected $except = [
        '/companies/*', 
-        '/api'
+        '/api',
    ];

 }
@@ -316,13 +438,13 @@ SimpleRouter::csrfVerifier(new \Demo\Middleware\CsrfVerifier());

 Sometimes it can be necessary to keep urls stored in the database, file or similar. In this example, we want the url ```/my-cat-is-beatiful``` to load the route ```/article/view/1``` which the router knows, because it's defined in the ```routes.php``` file.

-To interfere with the router, we create a class that inherits from ```RouterBootManager```. This class will be loaded before any other rules in ```routes.php``` and allow us to "change" the current route, if any of our criteria are fulfilled (like coming from the url ```/my-cat-is-beatiful```).
+To interfere with the router, we create a class that implements the ```IRouterBootManager``` interface. This class will be loaded before any other rules in ```routes.php``` and allow us to "change" the current route, if any of our criteria are fulfilled (like coming from the url ```/my-cat-is-beatiful```).

 ```php
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterBootManager;
+use Pecee\SimpleRouter\IRouterBootManager;

-class CustomRouterRules extends RouterBootManager{
+class CustomRouterRules implement IRouterBootManager {

    public function boot(Request $request) {

@@ -358,7 +480,7 @@ The last thing we need to do, is to add our custom boot-manager to the ```routes
 ## Easily overwrite route about to be loaded
 Sometimes it can be useful to manipulate the route about to be loaded. 
 simple-php-router allows you to easily change the route about to be executed. 
-All information about the current route is stored in the ```\Pecee\SimpleRouter\RouterBase``` instance's `loadedRoute` property. 
+All information about the current route is stored in the ```\Pecee\SimpleRouter\Router``` instance's `loadedRoute` property. 

 For easy access you can use the shortcut method `\Pecee\SimpleRouter\SimpleRouter::router()`.

@@ -379,7 +501,7 @@ $route->setMethod('hello');
 ### Examples

 It's only possible to change the route BEFORE the route has initially been loaded. If you want to redirect to another route, we highly recommend that you 
-modify the `RouterEntry` object from a `Middleware` or `ExceptionHandler`, like the examples below.
+modify the `IRoute` object from a `Middleware` or `ExceptionHandler`, like the examples below.

 #### Rewriting to new route

@@ -389,16 +511,18 @@ The example below will cause the router to re-route the request with another url


 ```php
-namespace demo\Middlewares;
+namespace Demo\Middlewares;

 use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 class CustomMiddleware implements Middleware {

-    public function handle(Request $request, RouterEntry &$route) {
+    public function handle(Request $request, ILoadableRoute &$route) {
+    
        $request->setUri(url('home'));
+        
    }
    
 }
@@ -415,16 +539,18 @@ If you wish to change the callback from outside, please have this in mind.
 **NOTE: Use this method if you want to load another controller. No additional middlewares or rules will be loaded.**

 ```php
-namespace demo\Middlewares;
+namespace Demo\Middlewares;

 use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 class CustomMiddleware implements Middleware {

-    public function handle(Request $request, RouterEntry &$route) { 
+    public function handle(Request $request, ILoadableRoute &$route) { 
+    
        $route->callback('DefaultController@home');
+        
    }
    
 }
@@ -435,22 +561,25 @@ class CustomMiddleware implements Middleware {
 We've added the `Input` class to easy access parameters from your Controller-classes.

 **Return single parameter value (matches both GET, POST, FILE):**
+
 ```php
 $value = input()->get('name');
 ```

 **Return parameter object (matches both GET, POST, FILE):**
+
 ```php
 $object = input()->getObject('name');
 ```

 **Return specific GET parameter (where name is the name of your parameter):**
+
 ```php
 $object = input()->get->name;
 $object = input()->post->name;
 $object = input()->file->name;

-// -- or --
+# -- or --

 $object = input()->get->get($key, $defaultValue);
 $object = input()->post->get($key, $defaultValue);
@@ -458,6 +587,7 @@ $object = input()->file->get($key, $defaultValue);
 ```

 **Return all parameters:**
+
 ```php
 // Get all
 $values = input()->all();
@@ -1,34 +1,44 @@
 <?php
 namespace Demo\Handlers;

-use Pecee\Handler\IExceptionHandler;
+use Pecee\Handlers\IExceptionHandler;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 class CustomExceptionHandler implements IExceptionHandler
 {
-	public function handleError(Request $request, RouterEntry &$route = null, \Exception $error)
+	public function handleError(Request $request, ILoadableRoute &$route = null, \Exception $error)
 	{
-		// Return json errors if we encounter an error on /api.
+
+		/* You can use the exception handler to format errors depending on the request and type. */
+
 		if (stripos($request->getUri(), '/api') !== false) {
-			header('content-type: application/json');
-			echo json_encode([
+
+			response()->json([
 				'error' => $error->getMessage(),
-				'code' => $error->getCode()
+				'code'  => $error->getCode(),
 			]);
-			die();
+
 		}

-		// else we just throw the error
-		if ($error->getCode() == 404) {
+		/* The router will throw the NotFoundHttpException on 404 */
+		if($error instanceof NotFoundHttpException) {

-			// Return 404 path
-			$request->setUri('/404');
+			/*
+			 * Render your own custom 404-view, rewrite the request to another route,
+			 * or simply return the $request object to ignore the error and continue on rendering the route.
+			 *
+			 * The code below will make the router render our page.notfound route.
+			 */
+
+			$request->setUri(url('page.notfound'));
 			return $request;

 		}

 		throw $error;
+
 	}

 }
@@ -3,11 +3,11 @@ namespace Demo\Middlewares;

 use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 class ApiVerification implements IMiddleware
 {
-	public function handle(Request $request, RouterEntry &$route)
+	public function handle(Request $request, ILoadableRoute &$route)
 	{
 		// Do authentication
 		$request->authenticated = true;
@@ -3,7 +3,7 @@ use Pecee\SimpleRouter\SimpleRouter;

 function url($controller, $parameters = null, $getParams = null)
 {
-	SimpleRouter::getRoute($controller, $parameters, $getParams);
+	SimpleRouter::getUrl($controller, $parameters, $getParams);
 }

 /**
@@ -9,11 +9,13 @@ Router::csrfVerifier(new \Demo\Middlewares\CsrfVerifier());

 Router::group(['exceptionHandler' => 'Demo\Handlers\CustomExceptionHandler'], function () {

-	Router::get('/', 'DefaultController@index')->setAlias('home');
-	Router::get('/contact', 'DefaultController@contact')->setAlias('contact');
-	Router::get('/404', 'DefaultController@notFound')->setAlias('404');
-	Router::basic('/companies', 'DefaultController@companies')->setAlias('companies');
-	Router::basic('/companies/{id}', 'DefaultController@companies')->setAlias('companies');
+	Router::get('/', 'DefaultController@index')->setName('home');
+
+	Router::get('/contact', 'DefaultController@contact')->setName('contact');
+
+	Router::get('/404', 'DefaultController@notFound')->setName('404');
+
+	Router::basic('/companies/{id?}', 'DefaultController@companies')->setName('companies');

 	// Api
 	Router::group(['prefix' => '/api', 'middleware' => 'Demo\Middlewares\ApiVerification'], function () {
@@ -1,5 +1,5 @@
 <?php
-namespace Pecee\Controller;
+namespace Pecee\Controllers;

 interface IRestController {

@@ -1,6 +0,0 @@
-<?php
-namespace Pecee\Exception;
-
-class RouterException extends \Exception
-{
-}
@@ -1,17 +0,0 @@
-<?php
-namespace Pecee\Handler;
-
-use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
-
-interface IExceptionHandler
-{
-	/**
-	 * @param Request $request
-	 * @param RouterEntry|null $route
-	 * @param \Exception $error
-	 * @return Request|null
-	 */
-	public function handleError(Request $request, RouterEntry &$route = null, \Exception $error);
-
-}
@@ -0,0 +1,17 @@
+<?php
+namespace Pecee\Handlers;
+
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\Route\ILoadableRoute;
+
+interface IExceptionHandler
+{
+	/**
+	 * @param Request $request
+	 * @param ILoadableRoute $route
+	 * @param \Exception $error
+	 * @return Request|null
+	 */
+	public function handleError(Request $request, ILoadableRoute &$route = null, \Exception $error);
+
+}
@@ -25,48 +25,123 @@ class Input
 	 */
 	protected $request;

+	protected $invalidContentType = false;
+
+	protected $invalidContentTypes = [
+		'text/plain',
+		'application/x-www-form-urlencoded',
+	];
+
 	public function __construct(Request $request)
 	{
 		$this->request = $request;
-		$this->setGet();
-		$this->setPost();
-		$this->setFile();
-	}

-	/**
-	 * Get all get/post items
-	 * @param array|null $filter Only take items in filter
-	 * @return array
-	 */
-	public function all(array $filter = null)
-	{
-		$output = $_POST;
+		$this->post = new InputCollection();
+		$this->get = new InputCollection();
+		$this->file = new InputCollection();

-		if ($this->request->getMethod() === 'post') {
+		if ($request->getMethod() !== 'get') {

-			$contents = file_get_contents('php://input');
+			$requestContentType = $request->getHeader('http-content-type');

-			if (stripos(trim($contents), '{') === 0) {
-				$output = json_decode($contents, true);
-				if ($output === false) {
-					$output = array();
+			$max = count($this->invalidContentTypes) - 1;
+
+			for ($i = $max; $i >= 0; $i--) {
+
+				$contentType = $this->invalidContentType[$i];
+
+				if (stripos($requestContentType, $contentType) === 0) {
+					$this->invalidContentType = true;
+					break;
 				}
 			}
 		}

-		$output = array_merge($_GET, $output);
+		if ($this->invalidContentType === false) {
+			$this->parseInputs();
+		}
+	}

-		if ($filter !== null) {
-			$output = array_filter($output, function ($key) use ($filter) {
-				if (in_array($key, $filter)) {
-					return true;
-				}
+	protected function parseInputs()
+	{
+		/* Parse get requests */
+
+		if (count($_GET) > 0) {
+
+			$max = count($_GET) - 1;
+			$keys = array_keys($_GET);
+
+			for ($i = $max; $i >= 0; $i--) {
+
+				$key = $keys[$i];
+				$value = $_GET[$key];
+
+				$this->get->{$key} = new InputItem($key, $value);
+			}

-				return false;
-			}, ARRAY_FILTER_USE_KEY);
 		}

-		return $output;
+		/* Parse post requests */
+
+		$postVars = $_POST;
+
+		if (in_array($this->request->getMethod(), ['put', 'patch', 'delete']) === true) {
+			parse_str(file_get_contents('php://input'), $postVars);
+		}
+
+		if (count($postVars) > 0) {
+
+			$max = count($postVars) - 1;
+			$keys = array_keys($postVars);
+
+			for ($i = $max; $i >= 0; $i--) {
+
+				$key = $keys[$i];
+				$value = $postVars[$key];
+
+				$this->post->{strtolower($key)} = new InputItem($key, $value);
+			}
+
+		}
+
+		/* Parse get requests */
+
+		if (count($_FILES) > 0) {
+
+			$max = count($_FILES) - 1;
+			$keys = array_keys($_FILES);
+
+			for ($i = $max; $i >= 0; $i--) {
+
+				$key = $keys[$i];
+				$value = $_FILES[$key];
+
+				// Handle array input
+				if (is_array($value['name']) === false) {
+					$values['index'] = $key;
+					$this->file->{strtolower($key)} = InputFile::createFromArray($values);
+					continue;
+				}
+
+				$output = new InputCollection();
+
+				foreach ($value['name'] as $k => $val) {
+
+					$output->{$k} = InputFile::createFromArray([
+						'index'    => $key,
+						'error'    => $value['error'][$k],
+						'tmp_name' => $value['tmp_name'][$k],
+						'type'     => $value['type'][$k],
+						'size'     => $value['size'][$k],
+						'name'     => $value['name'][$k],
+					]);
+
+				}
+
+				$this->file->{strtolower($key)} = $output;
+			}
+		}
+
 	}

 	public function getObject($index, $default = null)
@@ -98,9 +173,10 @@ class Input

 	/**
 	 * Get input element value matching index
+	 *
 	 * @param string $index
 	 * @param string|null $default
-	 * @return string|null
+	 * @return InputItem|string
 	 */
 	public function get($index, $default = null)
 	{
@@ -112,7 +188,7 @@ class Input
 				return $item;
 			}

-			return (trim($item->getValue()) === '') ? $default : $item->getValue();
+			return (!is_array($item->getValue()) && trim($item->getValue()) === '') ? $default : $item;
 		}

 		return $default;
@@ -123,89 +199,44 @@ class Input
 		return ($this->getObject($index) !== null);
 	}

-	public function setGet()
+	/**
+	 * Get all get/post items
+	 * @param array|null $filter Only take items in filter
+	 * @return array
+	 */
+	public function all(array $filter = null)
 	{
-		$this->get = new InputCollection();
+		if ($this->invalidContentType === true) {
+			return [];
+		}

-		if (count($_GET) > 0) {
-			foreach ($_GET as $key => $get) {
-				if (is_array($get) === false) {
-					$this->get->{$key} = new InputItem($key, $get);
-					continue;
+		$output = $_POST;
+
+		if ($this->request->getMethod() === 'post') {
+
+			$contents = file_get_contents('php://input');
+
+			if (stripos(trim($contents), '{') === 0) {
+				$output = json_decode($contents, true);
+				if ($output === false) {
+					$output = [];
 				}
-
-				$output = new InputCollection();
-
-				foreach ($get as $k => $g) {
-					$output->{$k} = new InputItem($k, $g);
-				}
-
-				$this->get->{$key} = $output;
 			}
 		}
-	}

-	public function setPost()
-	{
-		$this->post = new InputCollection();
+		$output = array_merge($_GET, $output);

-		$postVars = $_POST;
+		if ($filter !== null) {
+			$output = array_filter($output, function ($key) use ($filter) {
+				if (in_array($key, $filter)) {
+					return true;
+				}

-		if (in_array($this->request->getMethod(), ['put', 'patch', 'delete']) === true) {
-			parse_str(file_get_contents('php://input'), $postVars);
+				return false;
+			}, ARRAY_FILTER_USE_KEY);
 		}

-		if (count($postVars) > 0) {
-
-			foreach ($postVars as $key => $post) {
-				if (is_array($post) === false) {
-					$this->post->{strtolower($key)} = new InputItem($key, $post);
-					continue;
-				}
-
-				$output = new InputCollection();
-
-				foreach ($post as $k => $p) {
-					$output->{$k} = new InputItem($k, $p);
-				}
-
-				$this->post->{strtolower($key)} = $output;
-			}
-		}
-	}
-
-	public function setFile()
-	{
-		$this->file = new InputCollection();
-
-		if (count($_FILES) > 0) {
-			foreach ($_FILES as $key => $values) {
-
-				// Handle array input
-				if (is_array($values['name']) === false && trim($values['error']) !== '4') {
-					$values['index'] = $key;
-					$this->file->{strtolower($key)} = InputFile::createFromArray($values);
-					continue;
-				}
-
-				$output = new InputCollection();
-
-				foreach ($values['name'] as $k => $val) {
-					if (trim($val['error'][$k]) !== '4') {
-						$output->{$k} = InputFile::createFromArray([
-							'index' => $k,
-							'error' => $val['error'][$k],
-							'tmp_name' => $val['tmp_name'][$k],
-							'type' => $val['type'][$k],
-							'size' => $val['size'][$k],
-							'name' => $val['name'][$k]
-						]);
-					}
-				}
-
-				$this->file->{strtolower($key)} = $output;
-			}
-		}
+		return $output;
 	}

 }
@@ -3,7 +3,7 @@ namespace Pecee\Http\Input;

 class InputCollection implements \IteratorAggregate
 {
-	protected $data = array();
+	protected $data = [];

 	/**
 	 * Search for input element matching index.
@@ -41,17 +41,13 @@ class InputCollection implements \IteratorAggregate
 	{
 		$input = $this->findFirst($index);

-		if($input !== null && trim($input->getValue()) !== '') {
+		if ($input !== null && trim($input->getValue()) !== '') {
 			return $input->getValue();
 		}

 		return $default;
 	}

-	public function getValue($index, $default = null) {
-
-	}
-
 	/**
 	 * @param string $index
 	 * @throws \InvalidArgumentException
@@ -63,6 +59,7 @@ class InputCollection implements \IteratorAggregate
 		// Ensure that item are always available
 		if ($item === null) {
 			$this->data[$index] = new InputItem($index, null);
+
 			return $this->data[$index];
 		}

@@ -100,10 +100,19 @@ class InputFile extends InputItem
 	 */
 	public function setError($error)
 	{
-		$this->error = $error;
+		$this->error = (int)$error;
 		return $this;
 	}

+	public function getValue()
+	{
+		return $this->getTmpName();
+	}
+
+	public function hasError() {
+		return ($this->getError() !== 0);
+	}
+
 	/**
 	 * Create from array
 	 * @param array $values
@@ -116,21 +125,23 @@ class InputFile extends InputItem
 		}

 		$input = new static($values['index']);
-		$input->setTmpName((isset($values['error']) ? $values['error'] : null));
+		$input->setError((isset($values['error']) ? $values['error'] : null));
 		$input->setName((isset($values['name']) ? $values['name'] : null));
 		$input->setSize((isset($values['size']) ? $values['size'] : null));
 		$input->setType((isset($values['type']) ? $values['type'] : null));
-		$input->setError((isset($values['tmp_name']) ? $values['tmp_name'] : null));
+		$input->setTmpName((isset($values['tmp_name']) ? $values['tmp_name'] : null));

 		return $input;
 	}

-	/**
-	 * @return string
-	 */
-	public function getValue()
-	{
-		return $this->tmpName;
+	public function toArray() {
+		return [
+			'tmp_name' => $this->tmpName,
+			'type' => $this->type,
+			'size' => $this->size,
+			'name' => $this->name,
+			'error' => $this->error,
+		];
 	}

 }
@@ -2,9 +2,9 @@
 namespace Pecee\Http\Middleware;

 use Pecee\CsrfToken;
-use Pecee\Exception\TokenMismatchException;
+use Pecee\Http\Middleware\Exceptions\TokenMismatchException;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 class BaseCsrfVerifier implements IMiddleware
 {
@@ -51,7 +51,7 @@ class BaseCsrfVerifier implements IMiddleware
 		return false;
 	}

-	public function handle(Request $request, RouterEntry &$route = null)
+	public function handle(Request $request, ILoadableRoute &$route = null)
 	{

 		if ($request->getMethod() !== 'get' && !$this->skip($request)) {
@@ -1,6 +1,7 @@
 <?php
-namespace Pecee\Exception;
+namespace Pecee\Http\Middleware\Exceptions;

 class TokenMismatchException extends \Exception
 {
+
 }
@@ -2,15 +2,15 @@
 namespace Pecee\Http\Middleware;

 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
+use Pecee\SimpleRouter\Route\ILoadableRoute;

 interface IMiddleware
 {
 	/**
 	 * @param Request $request
-	 * @param RouterEntry $route
+	 * @param ILoadableRoute $route
 	 * @return Request|null
 	 */
-	public function handle(Request $request, RouterEntry &$route);
+	public function handle(Request $request, ILoadableRoute &$route);

 }
@@ -5,7 +5,7 @@ use Pecee\Http\Input\Input;

 class Request
 {
-	protected $data = array();
+	protected $data = [];
 	protected $headers;
 	protected $host;
 	protected $uri;
@@ -15,20 +15,21 @@ class Request
 	public function __construct()
 	{
 		$this->parseHeaders();
-		$this->input = new Input($this);
 		$this->host = $this->getHeader('http-host');;
 		$this->uri = $this->getHeader('request-uri');
-		$this->method = strtolower($this->input->post->findFirst('_method', $this->getHeader('request-method')));
+		$this->method = strtolower($this->getHeader('request-method'));
+		$this->input = new Input($this);
 	}

 	protected function parseHeaders()
 	{
-		$this->headers = array();
+		$this->headers = [];

 		foreach ($_SERVER as $name => $value) {
 			$this->headers[strtolower($name)] = $value;
 			$this->headers[strtolower(str_replace('_', '-', $name))] = $value;
 		}
+
 	}

 	public function isSecure()
@@ -136,7 +137,24 @@ class Request
 	 */
 	public function getHeader($name, $defaultValue = null)
 	{
-		return isset($this->headers[strtolower($name)]) ? $this->headers[strtolower($name)] : $defaultValue;
+		if (isset($this->headers[strtolower($name)])) {
+			return $this->headers[strtolower($name)];
+		}
+
+		$max = count($_SERVER) - 1;
+		$keys = array_keys($_SERVER);
+
+		for ($i = $max; $i >= 0; $i--) {
+
+			$key = $keys[$i];
+			$name = $_SERVER[$key];
+
+			if ($key === $name) {
+				return $name;
+			}
+		}
+
+		return $defaultValue;
 	}

 	/**
@@ -66,13 +66,12 @@ class Response
 			'Etag: ' . $eTag
 		]);

-		if (isset($_SERVER['HTTP_IF_MODIFIED_SINCE']) && strtotime($_SERVER['HTTP_IF_MODIFIED_SINCE']) === $lastModified ||
-			isset($_SERVER['HTTP_IF_NONE_MATCH']) && $_SERVER['HTTP_IF_NONE_MATCH'] === $eTag
-		) {
+		$httpModified = $this->request->getHeader('http-if-modified-since');
+		$httpIfNoneMatch = $this->request->getHeader('http-if-none-match');

-			$this->headers([
-				'HTTP/1.1 304 Not Modified'
-			]);
+		if ($httpModified !== null && strtotime($httpModified) == $lastModified || $httpIfNoneMatch !== null && $httpIfNoneMatch === $eTag) {
+
+			$this->header('HTTP/1.1 304 Not Modified');

 			exit();
 		}
@@ -86,7 +85,7 @@ class Response
 	 */
 	public function json(array $value)
 	{
-		$this->header('Content-type: application/json');
+		$this->header('Content-Type: application/json');
 		echo json_encode($value);
 		die();
 	}
@@ -109,8 +108,9 @@ class Response
 	 */
 	public function headers(array $headers)
 	{
-		foreach ($headers as $header) {
-			header($header);
+		$max = count($headers);
+		for($i = 0; $i < $max; $i++) {
+			$this->header($headers[$i]);
 		}
 		return $this;
 	}
@@ -0,0 +1,7 @@
+<?php
+namespace Pecee\SimpleRouter\Exceptions;
+
+class HttpException extends \Exception
+{
+
+}
@@ -0,0 +1,6 @@
+<?php
+namespace Pecee\SimpleRouter\Exceptions;
+
+class NotFoundHttpException extends HttpException
+{
+}
@@ -1,13 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-interface IControllerRoute
-{
-	public function getController();
-
-	public function setController($controller);
-
-	public function getMethod();
-
-	public function setMethod($method);
-}
@@ -1,9 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-interface ILoadableRoute
-{
-	public function getUrl();
-
-	public function setUrl($url);
-}
@@ -0,0 +1,15 @@
+<?php
+namespace Pecee\SimpleRouter;
+
+use Pecee\Http\Request;
+
+interface IRouterBootManager
+{
+	/**
+	 * Called when router loads it's routes
+	 *
+	 * @param Request $request
+	 * @return Request
+	 */
+	public function boot(Request $request);
+}
@@ -1,97 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-abstract class LoadableRoute extends RouterEntry implements ILoadableRoute
-{
-	const PARAMETERS_REGEX_MATCH = '%s([\w\-\_]*?)\%s{0,1}%s';
-	const PARAMETER_MODIFIERS = '{}';
-	const PARAMETER_OPTIONAL_SYMBOL = '?';
-
-	protected $url;
-	protected $alias;
-
-	public function getUrl()
-	{
-		return $this->url;
-	}
-
-	/**
-	 * Set url
-	 *
-	 * @param string $url
-	 * @return static
-	 */
-	public function setUrl($url)
-	{
-		$this->url = ($url === '/') ? '/' : '/' . trim($url, '/') . '/';
-		$regex = sprintf(static::PARAMETERS_REGEX_MATCH, static::PARAMETER_MODIFIERS[0], static::PARAMETER_OPTIONAL_SYMBOL, static::PARAMETER_MODIFIERS[1]);
-
-		if (preg_match_all('/' . $regex . '/is', $this->url, $matches)) {
-			foreach ($matches[1] as $key) {
-				$this->parameters[$key] = null;
-			}
-		}
-
-		return $this;
-	}
-
-	/**
-	 * Get alias for the url which can be used when getting the url route.
-	 * @return string|array
-	 */
-	public function getAlias()
-	{
-		return $this->alias;
-	}
-
-	/**
-	 * Check if route has given alias.
-	 *
-	 * @param string $name
-	 * @return bool
-	 */
-	public function hasAlias($name)
-	{
-		if ($this->getAlias() !== null) {
-			if (is_array($this->getAlias()) === true) {
-				foreach ($this->getAlias() as $alias) {
-					if (strtolower($alias) === strtolower($name)) {
-						return true;
-					}
-				}
-			}
-			return strtolower($this->getAlias()) === strtolower($name);
-		}
-
-		return false;
-	}
-
-	/**
-	 * Set the url alias for easier getting the url route.
-	 * @param string|array $alias
-	 * @return static
-	 */
-	public function setAlias($alias)
-	{
-		$this->alias = $alias;
-		return $this;
-	}
-
-	/**
-	 * Merge with information from another route.
-	 *
-	 * @param array $values
-	 * @return static
-	 */
-	public function merge(array $values)
-	{
-		// Change as to alias
-		if (isset($values['as'])) {
-			$this->setAlias($values['as']);
-		}
-
-		parent::merge($values);
-		return $this;
-	}
-
-}
@@ -0,0 +1,36 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+interface IControllerRoute extends IRoute
+{
+	/**
+	 * Get controller class-name
+	 *
+	 * @return string
+	 */
+	public function getController();
+
+	/**
+	 * Set controller class-name
+	 *
+	 * @param string $controller
+	 * @return static
+	 */
+	public function setController($controller);
+
+	/**
+	 * Return active method
+	 *
+	 * @return string
+	 */
+	public function getMethod();
+
+	/**
+	 * Set active method
+	 *
+	 * @param string $method
+	 * @return static
+	 */
+	public function setMethod($method);
+
+}
@@ -0,0 +1,60 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+use Pecee\Http\Request;
+
+interface IGroupRoute extends IRoute
+{
+	/**
+	 * Method called to check if a domain matches
+	 *
+	 * @param Request $request
+	 * @return bool
+	 */
+	public function matchDomain(Request $request);
+
+	/**
+	 * Set exception-handlers for group
+	 *
+	 * @param array $handlers
+	 * @return static $this
+	 */
+	public function setExceptionHandlers(array $handlers);
+
+	/**
+	 * Get exception-handlers for group
+	 *
+	 * @return array
+	 */
+	public function getExceptionHandlers();
+
+	/**
+	 * Get domains for domain.
+	 *
+	 * @return array
+	 */
+	public function getDomains();
+
+	/**
+	 * Set allowed domains for group.
+	 *
+	 * @param array $domains
+	 * @return $this
+	 */
+	public function setDomains(array $domains);
+
+	/**
+	 * Set prefix that child-routes will inherit.
+	 *
+	 * @param string $prefix
+	 * @return string
+	 */
+	public function setPrefix($prefix);
+
+	/**
+	 * Get prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix();
+}
@@ -0,0 +1,54 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+use Pecee\Http\Request;
+
+interface ILoadableRoute extends IRoute
+{
+	/**
+	 * Find url that matches method, parameters or name.
+	 * Used when calling the url() helper.
+	 *
+	 * @param string|null $method
+	 * @param array|null $parameters
+	 * @param string|null $name
+	 * @return string
+	 */
+	public function findUrl($method = null, $parameters = null, $name = null);
+
+	/**
+	 * Loads and renders middlewares-classes
+	 *
+	 * @param Request $request
+	 * @param ILoadableRoute $route
+	 */
+	public function loadMiddleware(Request $request, ILoadableRoute &$route);
+
+	public function getUrl();
+
+	public function setUrl($url);
+
+	/**
+	 * Returns the provided name for the router.
+	 *
+	 * @return string
+	 */
+	public function getName();
+
+	/**
+	 * Check if route has given name.
+	 *
+	 * @param string $name
+	 * @return bool
+	 */
+	public function hasName($name);
+
+	/**
+	 * Sets the router name, which makes it easier to obtain the url or router at a later point.
+	 *
+	 * @param string $name
+	 * @return static $this
+	 */
+	public function setName($name);
+
+}
@@ -0,0 +1,199 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+use Pecee\Http\Request;
+
+interface IRoute
+{
+	/**
+	 * Method called to check if a domain matches
+	 *
+	 * @param Request $request
+	 * @return bool
+	 */
+	public function matchRoute(Request $request);
+
+	/**
+	 * Called when route is matched.
+	 * Returns class to be rendered.
+	 *
+	 * @param Request $request
+	 * @return object
+	 */
+	public function renderRoute(Request $request);
+
+	/**
+	 * Returns callback name/identifier for the current route based on the callback.
+	 * Useful if you need to get a unique identifier for the loaded route, for instance
+	 * when using translations etc.
+	 *
+	 * @return string
+	 */
+	public function getIdentifier();
+
+	/**
+	 * Set allowed request methods
+	 *
+	 * @param array $methods
+	 * @return static $this
+	 */
+	public function setRequestMethods(array $methods);
+
+	/**
+	 * Get allowed request methods
+	 *
+	 * @return array
+	 */
+	public function getRequestMethods();
+
+	/**
+	 * @return IRoute|null
+	 */
+	public function getParent();
+
+	/**
+	 * Get the group for the route.
+	 *
+	 * @return IGroupRoute|null
+	 */
+	public function getGroup();
+
+	/**
+	 * Set group
+	 *
+	 * @param IGroupRoute $group
+	 * @return static $this
+	 */
+	public function setGroup(IGroupRoute $group);
+
+	/**
+	 * Set parent route
+	 *
+	 * @param IRoute $parent
+	 * @return static $this
+	 */
+	public function setParent(IRoute $parent);
+
+	/**
+	 * Set callback
+	 *
+	 * @param string $callback
+	 * @return static
+	 */
+	public function setCallback($callback);
+
+	/**
+	 * @return string
+	 */
+	public function getCallback();
+
+	public function getMethod();
+
+	public function getClass();
+
+	public function setMethod($method);
+
+	/**
+	 * @param string $namespace
+	 * @return static $this
+	 */
+	public function setNamespace($namespace);
+
+	/**
+	 * @return string
+	 */
+	public function getNamespace();
+
+	/**
+	 * @param string $namespace
+	 * @return static $this
+	 */
+	public function setDefaultNamespace($namespace);
+
+	public function getDefaultNamespace();
+
+	/**
+	 * Get regular expression match used for matching route (if defined).
+	 *
+	 * @return string
+	 */
+	public function getMatch();
+
+	/**
+	 * Add regular expression match for the entire route.
+	 *
+	 * @param string $regex
+	 * @return static
+	 */
+	public function setMatch($regex);
+
+	/**
+	 * Get parameter names.
+	 *
+	 * @return array
+	 */
+	public function getWhere();
+
+	/**
+	 * Set parameter names.
+	 *
+	 * @param array $options
+	 * @return static
+	 */
+	public function setWhere(array $options);
+
+	/**
+	 * Get parameters
+	 *
+	 * @return array
+	 */
+	public function getParameters();
+
+	/**
+	 * Get parameters
+	 *
+	 * @param array $parameters
+	 * @return static $this
+	 */
+	public function setParameters(array $parameters);
+
+	/**
+	 * Merge with information from another route.
+	 *
+	 * @param array $settings
+	 * @param bool $merge
+	 * @return static $this
+	 */
+	public function setSettings(array $settings, $merge = false);
+
+	/**
+	 * Export route settings to array so they can be merged with another route.
+	 *
+	 * @return array
+	 */
+	public function toArray();
+
+	/**
+	 * Get middlewares array
+	 *
+	 * @return array
+	 */
+	public function getMiddlewares();
+
+	/**
+	 * Set middleware class-name
+	 *
+	 * @param string $middleware
+	 * @return static
+	 */
+	public function setMiddleware($middleware);
+
+	/**
+	 * Set middlewares array
+	 *
+	 * @param array $middlewares
+	 * @return $this
+	 */
+	public function setMiddlewares(array $middlewares);
+
+}
@@ -0,0 +1,204 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+use Pecee\Http\Middleware\IMiddleware;
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\HttpException;
+
+abstract class LoadableRoute extends Route implements ILoadableRoute
+{
+	const PARAMETERS_REGEX_MATCH = '%s([\w\-\_]*?)\%s{0,1}%s';
+
+	protected $url;
+	protected $name;
+
+	/**
+	 * Loads and renders middlewares-classes
+	 *
+	 * @param Request $request
+	 * @param ILoadableRoute $route
+	 * @throws HttpException
+	 */
+	public function loadMiddleware(Request $request, ILoadableRoute &$route)
+	{
+		if (count($this->getMiddlewares()) > 0) {
+
+			$max = count($this->getMiddlewares());
+
+			for ($i = 0; $i < $max; $i++) {
+
+				$middleware = $this->getMiddlewares()[$i];
+
+				$middleware = $this->loadClass($middleware);
+				if (!($middleware instanceof IMiddleware)) {
+					throw new HttpException($middleware . ' must be instance of Middleware');
+				}
+
+				$middleware->handle($request, $route);
+			}
+		}
+	}
+
+	/**
+	 * Set url
+	 *
+	 * @param string $url
+	 * @return static
+	 */
+	public function setUrl($url)
+	{
+		$this->url = ($url === '/') ? '/' : '/' . trim($url, '/') . '/';
+
+		if(strpos($this->url, $this->paramModifiers[0]) !== false) {
+
+			$regex = sprintf(static::PARAMETERS_REGEX_MATCH, $this->paramModifiers[0], $this->paramOptionalSymbol, $this->paramModifiers[1]);
+
+			if (preg_match_all('/' . $regex . '/is', $this->url, $matches)) {
+
+				$max = count($matches[1]);
+
+				for ($i = 0; $i < $max; $i++) {
+					$this->parameters[$matches[1][$i]] = null;
+				}
+
+			}
+
+		}
+
+		return $this;
+	}
+
+	public function getUrl()
+	{
+		return $this->url;
+	}
+
+	/**
+	 * Find url that matches method, parameters or name.
+	 * Used when calling the url() helper.
+	 *
+	 * @param string|null $method
+	 * @param array|null $parameters
+	 * @param string|null $name
+	 * @return string
+	 */
+	public function findUrl($method = null, $parameters = null, $name = null)
+	{
+		$url = '';
+
+		$parameters = (array)$parameters;
+
+		if ($this->getGroup() !== null && count($this->getGroup()->getDomains()) > 0) {
+			$url .= '//' . $this->getGroup()->getDomains()[0];
+		}
+
+		$url .= $this->getUrl();
+
+		$params = array_merge($this->getParameters(), $parameters);
+
+		/* Url that contains parameters that aren't recognized */
+		$unknownParams = [];
+
+		/* Create the param string - {} */
+		$param1 = $this->paramModifiers[0] . '%s' . $this->paramModifiers[1];
+
+		/* Create the param string with the optional symbol - {?} */
+		$param2 = $this->paramModifiers[0] . '%s' . $this->paramOptionalSymbol . $this->paramModifiers[1];
+
+		/* Let's parse the values of any {} parameter in the url */
+
+		$max = count($params);
+		$keys = array_keys($params);
+
+		for ($i = 0; $i < $max; $i++) {
+			$param = $keys[$i];
+			$value = $params[$param];
+
+			$value = (isset($parameters[$param])) ? $parameters[$param] : $value;
+
+			if (stripos($url, $param1) !== false || stripos($url, $param) !== false) {
+				$url = str_ireplace([sprintf($param1, $param), sprintf($param2, $param)], $value, $url);
+			} else {
+				$unknownParams[$param] = $value;
+			}
+		}
+
+		$url .= join('/', $unknownParams);
+
+		return rtrim($url, '/') . '/';
+	}
+
+	/**
+	 * Returns the provided name for the router.
+	 *
+	 * @return string
+	 */
+	public function getName()
+	{
+		return $this->name;
+	}
+
+	/**
+	 * Check if route has given name.
+	 *
+	 * @param string $name
+	 * @return bool
+	 */
+	public function hasName($name)
+	{
+		return (strtolower($this->name) === strtolower($name));
+	}
+
+	/**
+	 * Sets the router name, which makes it easier to obtain the url or router at a later point.
+	 * Alias for LoadableRoute::setName().
+	 *
+	 * @see LoadableRoute::setName()
+	 * @param string|array $name
+	 * @return static
+	 */
+	public function name($name)
+	{
+		return $this->setName($name);
+	}
+
+	/**
+	 * Sets the router name, which makes it easier to obtain the url or router at a later point.
+	 *
+	 * @param string $name
+	 * @return static $this
+	 */
+	public function setName($name)
+	{
+		$this->name = $name;
+
+		return $this;
+	}
+
+	/**
+	 * Merge with information from another route.
+	 *
+	 * @param array $values
+	 * @param bool $merge
+	 * @return static
+	 */
+	public function setSettings(array $values, $merge = false)
+	{
+		if (isset($values['as'])) {
+			if ($this->name !== null && $merge !== false) {
+				$this->setName($values['as'] . '.' . $this->name);
+			} else {
+				$this->setName($values['as']);
+			}
+		}
+
+		if (isset($values['prefix'])) {
+			$this->setUrl($values['prefix'] . $this->getUrl());
+		}
+
+		parent::setSettings($values, $merge);
+
+		return $this;
+	}
+
+}
@@ -1,11 +1,11 @@
 <?php
-namespace Pecee\SimpleRouter;
+namespace Pecee\SimpleRouter\Route;

-use Pecee\Exception\RouterException;
-use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\HttpException;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;

-abstract class RouterEntry
+abstract class Route implements IRoute
 {
 	const REQUEST_TYPE_GET = 'get';
 	const REQUEST_TYPE_POST = 'post';
@@ -23,40 +23,67 @@ abstract class RouterEntry
 		self::REQUEST_TYPE_DELETE,
 	];

+	protected $paramModifiers = '{}';
+	protected $paramOptionalSymbol = '?';
+	protected $group;
 	protected $parent;
 	protected $callback;
+	protected $defaultNamespace;

+	/* Default options */
 	protected $namespace;
 	protected $regex;
-	protected $requestMethods = array();
-	protected $where = array();
-	protected $parameters = array();
-	protected $middlewares = array();
+	protected $requestMethods = [];
+	protected $where = [];
+	protected $parameters = [];
+	protected $middlewares = [];

-	protected function loadClass($name)
+	public function renderRoute(Request $request)
 	{
-		if (!class_exists($name)) {
-			throw new RouterException(sprintf('Class %s does not exist', $name));
+		if ($this->getCallback() !== null && is_callable($this->getCallback())) {
+
+			/* When the callback is a function */
+			call_user_func_array($this->getCallback(), $this->getParameters());
+
+		} else {
+
+			/* When the callback is a method */
+			$controller = explode('@', $this->getCallback());
+			$className = $this->getNamespace() . '\\' . $controller[0];
+
+			$class = $this->loadClass($className);
+			$method = $controller[1];
+
+			if (!method_exists($class, $method)) {
+				throw new NotFoundHttpException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
+			}
+
+			$parameters = array_filter($this->getParameters(), function ($var) {
+				return ($var !== null);
+			});
+
+			call_user_func_array([$class, $method], $parameters);
+
+			return $class;
 		}

-		return new $name();
+		return null;
 	}

 	protected function parseParameters($route, $url, $parameterRegex = '[\w]+')
 	{
-		$parameterNames = array();
+		$parameterNames = [];
 		$regex = '';
 		$lastCharacter = '';
 		$isParameter = false;
 		$parameter = '';

-		$routeLength = strlen($route);
-		for ($i = 0; $i < $routeLength; $i++) {
+		for ($i = 0; $i < strlen($route); $i++) {

 			$character = $route[$i];

 			if ($character === '{') {
-				// Remove "/" and "\" from regex
+				/* Remove "/" and "\" from regex */
 				if (substr($regex, strlen($regex) - 1) === '/') {
 					$regex = substr($regex, 0, strlen($regex) - 2);
 				}
@@ -65,7 +92,7 @@ abstract class RouterEntry
 			} elseif ($isParameter && $character === '}') {
 				$required = true;

-				// Check for optional parameter and use custom parameter regex if it exists
+				/* Check for optional parameter and use custom parameter regex if it exists */
 				if (is_array($this->where) === true && isset($this->where[$parameter])) {
 					$parameterRegex = $this->where[$parameter];
 				}
@@ -79,8 +106,8 @@ abstract class RouterEntry
 				}

 				$parameterNames[] = [
-					'name' => $parameter,
-					'required' => $required
+					'name'     => $parameter,
+					'required' => $required,
 				];

 				$parameter = '';
@@ -96,17 +123,22 @@ abstract class RouterEntry
 			$lastCharacter = $character;
 		}

-		$parameterValues = array();
+		$parameterValues = [];

 		if (preg_match('/^' . $regex . '\/?$/is', $url, $parameterValues)) {

-			$parameters = array();
+			$parameters = [];
+
+			$max = count($parameterNames);
+
+			for ($i = 0; $i < $max; $i++) {
+
+				$name = $parameterNames[$i];

-			foreach ($parameterNames as $name) {
 				$parameterValue = isset($parameterValues[$name['name']]) ? $parameterValues[$name['name']] : null;

 				if ($name['required'] && $parameterValue === null) {
-					throw new RouterException('Missing required parameter ' . $name['name'], 404);
+					throw new HttpException('Missing required parameter ' . $name['name'], 404);
 				}

 				if ($name['required'] === false && $parameterValue === null) {
@@ -122,53 +154,13 @@ abstract class RouterEntry
 		return null;
 	}

-	public function loadMiddleware(Request $request, RouterEntry &$route)
+	protected function loadClass($name)
 	{
-		if (count($this->getMiddlewares()) > 0) {
-			foreach ($this->getMiddlewares() as $middleware) {
-
-				$middleware = $this->loadClass($middleware);
-				if (!($middleware instanceof IMiddleware)) {
-					throw new RouterException($middleware . ' must be instance of Middleware');
-				}
-
-				/* @var $class IMiddleware */
-				$middleware->handle($request, $route);
-
-			}
-		}
-	}
-
-	public function renderRoute(Request $request)
-	{
-		if ($this->getCallback() !== null && is_callable($this->getCallback())) {
-
-			// When the callback is a function
-			call_user_func_array($this->getCallback(), $this->getParameters());
-
-		} else {
-
-			// When the callback is a method
-			$controller = explode('@', $this->getCallback());
-			$className = $this->getNamespace() . '\\' . $controller[0];
-
-			$class = $this->loadClass($className);
-			$method = $controller[1];
-
-			if (!method_exists($class, $method)) {
-				throw new RouterException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
-			}
-
-			$parameters = array_filter($this->getParameters(), function ($var) {
-				return ($var !== null);
-			});
-
-			call_user_func_array(array($class, $method), $parameters);
-
-			return $class;
+		if (!class_exists($name)) {
+			throw new HttpException(sprintf('Class %s does not exist', $name), 500);
 		}

-		return null;
+		return new $name();
 	}

 	/**
@@ -183,6 +175,7 @@ abstract class RouterEntry
 		if (strpos($this->callback, '@') !== false) {
 			return $this->callback;
 		}
+
 		return 'function_' . md5($this->callback);
 	}

@@ -195,11 +188,13 @@ abstract class RouterEntry
 	public function setRequestMethods(array $methods)
 	{
 		$this->requestMethods = $methods;
+
 		return $this;
 	}

 	/**
 	 * Get allowed request methods
+	 *
 	 * @return array
 	 */
 	public function getRequestMethods()
@@ -208,7 +203,7 @@ abstract class RouterEntry
 	}

 	/**
-	 * @return RouterEntry
+	 * @return IRoute|null
 	 */
 	public function getParent()
 	{
@@ -216,29 +211,56 @@ abstract class RouterEntry
 	}

 	/**
-	 * Set parent route
+	 * Get the group for the route.
 	 *
-	 * @param RouterEntry $parent
+	 * @return IGroupRoute|null
+	 */
+	public function getGroup()
+	{
+		return $this->group;
+	}
+
+	/**
+	 * Set group
+	 *
+	 * @param IGroupRoute $group
 	 * @return static $this
 	 */
-	public function setParent(RouterEntry $parent)
+	public function setGroup(IGroupRoute $group)
 	{
-		$this->parent = $parent;
+		$this->group = $group;
+
 		return $this;
 	}

 	/**
+	 * Set parent route
+	 *
+	 * @param IRoute $parent
+	 * @return static $this
+	 */
+	public function setParent(IRoute $parent)
+	{
+		$this->parent = $parent;
+
+		return $this;
+	}
+
+	/**
+	 * Set callback
+	 *
 	 * @param string $callback
 	 * @return static
 	 */
 	public function setCallback($callback)
 	{
 		$this->callback = $callback;
+
 		return $this;
 	}

 	/**
-	 * @return mixed
+	 * @return string
 	 */
 	public function getCallback()
 	{
@@ -249,8 +271,10 @@ abstract class RouterEntry
 	{
 		if (strpos($this->callback, '@') !== false) {
 			$tmp = explode('@', $this->callback);
+
 			return $tmp[1];
 		}
+
 		return null;
 	}

@@ -258,46 +282,232 @@ abstract class RouterEntry
 	{
 		if (strpos($this->callback, '@') !== false) {
 			$tmp = explode('@', $this->callback);
+
 			return $tmp[0];
 		}
+
 		return null;
 	}

 	public function setMethod($method)
 	{
 		$this->callback = sprintf('%s@%s', $this->getClass(), $method);
+
 		return $this;
 	}

 	public function setClass($class)
 	{
 		$this->callback = sprintf('%s@%s', $class, $this->getMethod());
+
 		return $this;
 	}

 	/**
+	 * @param string $namespace
+	 * @return static $this
+	 */
+	public function setNamespace($namespace)
+	{
+		$this->namespace = $namespace;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $namespace
+	 * @return static $this
+	 */
+	public function setDefaultNamespace($namespace)
+	{
+		$this->defaultNamespace = $namespace;
+
+		return $this;
+	}
+
+	public function getDefaultNamespace()
+	{
+		return $this->defaultNamespace;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getNamespace()
+	{
+		return ($this->namespace === null) ? $this->defaultNamespace : $this->namespace;
+	}
+
+	/**
+	 * Add regular expression match for the entire route.
+	 *
+	 * @param string $regex
+	 * @return static
+	 */
+	public function setMatch($regex)
+	{
+		$this->regex = $regex;
+
+		return $this;
+	}
+
+	/**
+	 * Get regular expression match used for matching route (if defined).
+	 *
+	 * @return string
+	 */
+	public function getMatch()
+	{
+		return $this->regex;
+	}
+
+	/**
+	 * Export route settings to array so they can be merged with another route.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		$values = [];
+
+		if ($this->namespace !== null) {
+			$values['namespace'] = $this->namespace;
+		}
+
+		if (count($this->requestMethods) > 0) {
+			$values['method'] = $this->requestMethods;
+		}
+
+		if (count($this->where) > 0) {
+			$values['where'] = $this->where;
+		}
+
+		if (count($this->parameters) > 0) {
+			$values['parameters'] = $this->parameters;
+		}
+
+		if (count($this->middlewares) > 0) {
+			$values['middleware'] = $this->middlewares;
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Merge with information from another route.
+	 *
+	 * @param array $values
+	 * @param bool $merge
+	 * @return static $this
+	 */
+	public function setSettings(array $values, $merge = false)
+	{
+		if (isset($values['namespace']) && $this->namespace === null) {
+			$this->setNamespace($values['namespace']);
+		}
+
+		if (isset($values['method'])) {
+			$this->setRequestMethods(array_merge($this->requestMethods, (array)$values['method']));
+		}
+
+		if (isset($values['where'])) {
+			$this->setWhere(array_merge($this->where, (array)$values['where']));
+		}
+
+		if (isset($values['parameters'])) {
+			$this->setParameters(array_merge($this->parameters, (array)$values['parameters']));
+		}
+
+		// Push middleware if multiple
+		if (isset($values['middleware'])) {
+			$this->setMiddlewares(array_merge((array)$values['middleware'], $this->middlewares));
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Get parameter names.
+	 *
+	 * @return array
+	 */
+	public function getWhere()
+	{
+		return $this->where;
+	}
+
+	/**
+	 * Set parameter names.
+	 *
+	 * @param array $options
+	 * @return static
+	 */
+	public function setWhere(array $options)
+	{
+		$this->where = $options;
+
+		return $this;
+	}
+
+	/**
+	 * Add regular expression parameter match.
+	 * Alias for LoadableRoute::where()
+	 *
+	 * @see LoadableRoute::where()
+	 * @param array $options
+	 * @return static
+	 */
+	public function where(array $options)
+	{
+		return $this->where($options);
+	}
+
+	/**
+	 * Get parameters
+	 *
+	 * @return array
+	 */
+	public function getParameters()
+	{
+		return $this->parameters;
+	}
+
+	/**
+	 * Get parameters
+	 *
+	 * @param array $parameters
+	 * @return static $this
+	 */
+	public function setParameters(array $parameters)
+	{
+		$this->parameters = $parameters;
+
+		return $this;
+	}
+
+	/**
+	 * Set middleware class-name
+	 *
 	 * @param string $middleware
 	 * @return static
 	 */
 	public function setMiddleware($middleware)
 	{
 		$this->middlewares[] = $middleware;
-		return $this;
-	}

-	public function setMiddlewares(array $middlewares)
-	{
-		$this->middlewares = $middlewares;
 		return $this;
 	}

 	/**
-	 * @param string $namespace
-	 * @return static
+	 * Set middlewares array
+	 *
+	 * @param array $middlewares
+	 * @return $this
 	 */
-	public function setNamespace($namespace)
+	public function setMiddlewares(array $middlewares)
 	{
-		$this->namespace = $namespace;
+		$this->middlewares = $middlewares;
+
 		return $this;
 	}

@@ -309,120 +519,4 @@ abstract class RouterEntry
 		return $this->middlewares;
 	}

-	/**
-	 * @return string
-	 */
-	public function getNamespace()
-	{
-		return $this->namespace;
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getParameters()
-	{
-		return $this->parameters;
-	}
-
-	/**
-	 * @param mixed $parameters
-	 * @return static
-	 */
-	public function setParameters($parameters)
-	{
-		$this->parameters = $parameters;
-		return $this;
-	}
-
-	/**
-	 * Add regular expression parameter match
-	 *
-	 * @param array $options
-	 * @return static
-	 */
-	public function where(array $options)
-	{
-		$this->where = $options;
-		return $this;
-	}
-
-	/**
-	 * Add regular expression match for url
-	 *
-	 * @param string $regex
-	 * @return static
-	 */
-	public function match($regex)
-	{
-		$this->regex = $regex;
-		return $this;
-	}
-
-	/**
-	 * Export route settings to array so they can be merged with another route.
-	 *
-	 * @return array
-	 */
-	public function toArray()
-	{
-		$values = array();
-
-		if ($this->namespace !== null) {
-			$values['namespace'] = $this->namespace;
-		}
-
-		if (count($this->middlewares) > 0) {
-			$values['middleware'] = $this->middlewares;
-		}
-
-		/*if (count($this->where) > 0) {
-			$values['where'] = $this->where;
-		}*/
-
-		if (count($this->requestMethods) > 0) {
-			$values['method'] = $this->requestMethods;
-		}
-
-		if (count($this->parameters) > 0) {
-			$values['parameters'] = $this->parameters;
-		}
-
-		return $values;
-	}
-
-	/**
-	 * Merge with information from another route.
-	 *
-	 * @param array $values
-	 * @return static $this
-	 */
-	public function merge(array $values)
-	{
-		if (isset($values['namespace'])) {
-			$this->setNamespace($values['namespace']);
-		}
-
-		// Push middleware if multiple
-		if (isset($values['middleware'])) {
-			$this->middlewares = array_merge((array)$values['middleware'], $this->middlewares);
-		}
-
-		if (isset($values['method'])) {
-			$this->setRequestMethods((array)$values['method']);
-		}
-
-		if (isset($values['where'])) {
-			$this->where($values['where']);
-		}
-
-		if (isset($values['parameters'])) {
-			$this->setParameters($values['parameters']);
-		}
-
-		return $this;
-	}
-
-	abstract function matchRoute(Request $request);
-
 }
@@ -0,0 +1,199 @@
+<?php
+namespace Pecee\SimpleRouter\Route;
+
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+
+class RouteController extends LoadableRoute implements IControllerRoute
+{
+	protected $defaultMethod = 'index';
+	protected $controller;
+	protected $method;
+	protected $names = [];
+
+	public function __construct($url, $controller)
+	{
+		$this->setUrl($url);
+		$this->setName(trim(str_replace('/', '.', $url), '/'));
+		$this->controller = $controller;
+	}
+
+	/**
+	 * Check if route has given name.
+	 *
+	 * @param string $name
+	 * @return bool
+	 */
+	public function hasName($name)
+	{
+		if ($this->name === null) {
+			return false;
+		}
+
+		/* Remove method/type */
+		if (stripos($name, '.') !== false) {
+			$method = substr($name, strrpos($name, '.') + 1);
+			$newName = substr($name, 0, strrpos($name, '.'));
+
+			if (strtolower($this->name) === strtolower($newName) && in_array($method, $this->names)) {
+				return true;
+			}
+		}
+
+		return parent::hasName($name);
+	}
+
+	public function findUrl($method = null, $parameters = null, $name = null)
+	{
+
+		if (stripos($name, '.') !== false) {
+			$found = array_search(substr($name, strrpos($name, '.') + 1), $this->names);
+			if ($found !== false) {
+				$method = $found;
+			}
+		}
+
+		$url = '';
+
+		$parameters = (array)$parameters;
+
+		/* Remove requestType from method-name, if it exists */
+		if ($method !== null) {
+			foreach (static::$requestTypes as $requestType) {
+				if (stripos($method, $requestType) === 0) {
+					$method = substr($method, strlen($requestType));
+					break;
+				}
+			}
+			$method .= '/';
+		}
+
+		if ($this->getGroup() !== null && count($this->getGroup()->getDomains()) > 0) {
+			$url .= '//' . $this->getGroup()->getDomains()[0];
+		}
+
+		$url .= '/' . trim($this->getUrl(), '/') . '/' . strtolower($method) . join('/', $parameters);
+
+		return '/' . trim($url, '/') . '/';
+	}
+
+	public function renderRoute(Request $request)
+	{
+		if ($this->getCallback() !== null && is_callable($this->getCallback())) {
+
+			// When the callback is a function
+			call_user_func_array($this->getCallback(), $this->getParameters());
+		} else {
+			// When the callback is a method
+			$controller = explode('@', $this->getCallback());
+			$className = $this->getNamespace() . '\\' . $controller[0];
+
+			$class = $this->loadClass($className);
+			$method = $request->getMethod() . ucfirst($controller[1]);
+
+			if (!method_exists($class, $method)) {
+				throw new NotFoundHttpException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
+			}
+
+			call_user_func_array([$class, $method], $this->getParameters());
+
+			return $class;
+		}
+
+		return null;
+	}
+
+	public function matchRoute(Request $request)
+	{
+		$url = parse_url(urldecode($request->getUri()), PHP_URL_PATH);
+		$url = rtrim($url, '/') . '/';
+
+		if (strtolower($url) == strtolower($this->url) || stripos($url, $this->url) === 0) {
+
+			$strippedUrl = trim(str_ireplace($this->url, '/', $url), '/');
+
+			$path = explode('/', $strippedUrl);
+
+			if (count($path) > 0) {
+
+				$method = (!isset($path[0]) || trim($path[0]) === '') ? $this->defaultMethod : $path[0];
+				$this->method = $method;
+
+				array_shift($path);
+				$this->parameters = $path;
+
+				// Set callback
+				$this->setCallback($this->controller . '@' . $this->method);
+
+				return true;
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get controller class-name.
+	 *
+	 * @return string
+	 */
+	public function getController()
+	{
+		return $this->controller;
+	}
+
+	/**
+	 * Get controller class-name.
+	 *
+	 * @param string $controller
+	 * @return static
+	 */
+	public function setController($controller)
+	{
+		$this->controller = $controller;
+
+		return $this;
+	}
+
+	/**
+	 * Return active method
+	 *
+	 * @return string
+	 */
+	public function getMethod()
+	{
+		return $this->method;
+	}
+
+	/**
+	 * Set active method
+	 *
+	 * @param string $method
+	 * @return static
+	 */
+	public function setMethod($method)
+	{
+		$this->method = $method;
+
+		return $this;
+	}
+
+	/**
+	 * Merge with information from another route.
+	 *
+	 * @param array $values
+	 * @param bool $merge
+	 * @return static
+	 */
+	public function setSettings(array $values, $merge = false)
+	{
+		if (isset($values['names'])) {
+			$this->names = $values['names'];
+		}
+
+		parent::setSettings($values, $merge);
+
+		return $this;
+	}
+
+}
@@ -1,14 +1,21 @@
 <?php
-namespace Pecee\SimpleRouter;
+namespace Pecee\SimpleRouter\Route;

 use Pecee\Http\Request;

-class RouterGroup extends RouterEntry
+class RouteGroup extends Route implements IGroupRoute
 {
 	protected $prefix;
-	protected $domains = array();
-	protected $exceptionHandlers = array();
+	protected $name;
+	protected $domains = [];
+	protected $exceptionHandlers = [];

+	/**
+	 * Method called to check if a domain matches
+	 *
+	 * @param Request $request
+	 * @return bool
+	 */
 	public function matchDomain(Request $request)
 	{
 		if (count($this->domains) > 0) {
@@ -18,6 +25,7 @@ class RouterGroup extends RouterEntry

 				if ($parameters !== null) {
 					$this->parameters = $parameters;
+
 					return true;
 				}
 			}
@@ -28,6 +36,12 @@ class RouterGroup extends RouterEntry
 		return true;
 	}

+	/**
+	 * Method called to check if route matches
+	 *
+	 * @param Request $request
+	 * @return bool
+	 */
 	public function matchRoute(Request $request)
 	{
 		// Skip if prefix doesn't match
@@ -38,25 +52,49 @@ class RouterGroup extends RouterEntry
 		return $this->matchDomain($request);
 	}

+	/**
+	 * Set exception-handlers for group
+	 *
+	 * @param array $handlers
+	 * @return static $this
+	 */
 	public function setExceptionHandlers(array $handlers)
 	{
 		$this->exceptionHandlers = $handlers;
+
 		return $this;
 	}

+	/**
+	 * Get exception-handlers for group
+	 *
+	 * @return array
+	 */
 	public function getExceptionHandlers()
 	{
 		return $this->exceptionHandlers;
 	}

+	/**
+	 * Get allowed domains for domain.
+	 *
+	 * @return array
+	 */
 	public function getDomains()
 	{
 		return $this->domains;
 	}

+	/**
+	 * Set allowed domains for group.
+	 *
+	 * @param array $domains
+	 * @return $this
+	 */
 	public function setDomains(array $domains)
 	{
 		$this->domains = $domains;
+
 		return $this;
 	}

@@ -67,10 +105,13 @@ class RouterGroup extends RouterEntry
 	public function setPrefix($prefix)
 	{
 		$this->prefix = '/' . trim($prefix, '/');
+
 		return $this;
 	}

 	/**
+	 * Set prefix that child-routes will inherit.
+	 *
 	 * @return string
 	 */
 	public function getPrefix()
@@ -82,12 +123,14 @@ class RouterGroup extends RouterEntry
 	 * Merge with information from another route.
 	 *
 	 * @param array $values
+	 * @param bool $merge
 	 * @return static
 	 */
-	public function merge(array $values)
+	public function setSettings(array $values, $merge = false)
 	{
+
 		if (isset($values['prefix'])) {
-			$this->setPrefix($values['prefix']);
+			$this->setPrefix($values['prefix'] . $this->prefix);
 		}

 		if (isset($values['exceptionHandler'])) {
@@ -98,9 +141,37 @@ class RouterGroup extends RouterEntry
 			$this->setDomains((array)$values['domain']);
 		}

-		parent::merge($values);
+		if (isset($values['as'])) {
+			if ($this->name !== null && $merge !== false) {
+				$this->name = $values['as'] . '.' . $this->name;
+			} else {
+				$this->name = $values['as'];
+			}
+		}
+
+		parent::setSettings($values, $merge);

 		return $this;
 	}

+	/**
+	 * Export route settings to array so they can be merged with another route.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		$values = [];
+
+		if ($this->prefix !== null) {
+			$values['prefix'] = $this->getPrefix();
+		}
+
+		if ($this->name !== null) {
+			$values['as'] = $this->name;
+		}
+
+		return array_merge($values, parent::toArray());
+	}
+
 }
@@ -1,17 +1,62 @@
 <?php
-namespace Pecee\SimpleRouter;
+namespace Pecee\SimpleRouter\Route;

-use Pecee\Exception\RouterException;
 use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;

-class RouterResource extends LoadableRoute implements IControllerRoute
+class RouteResource extends LoadableRoute implements IControllerRoute
 {
+	protected $urls = [
+		'index'   => '',
+		'create'  => 'create',
+		'store'   => '',
+		'show'    => '',
+		'edit'    => 'edit',
+		'update'  => '',
+		'destroy' => '',
+	];
+	protected $names = [];
 	protected $controller;

 	public function __construct($url, $controller)
 	{
 		$this->setUrl($url);
 		$this->controller = $controller;
+		$this->setName(trim(str_replace('/', '.', $url), '/'));
+	}
+
+	/**
+	 * Check if route has given name.
+	 *
+	 * @param string $name
+	 * @return bool
+	 */
+	public function hasName($name)
+	{
+		if ($this->name === null) {
+			return false;
+		}
+
+		if (strtolower($this->name) === strtolower($name)) {
+			return true;
+		}
+
+		/* Remove method/type */
+		if (stripos($name, '.') !== false) {
+			$name = substr($name, 0, strrpos($name, '.'));
+		}
+
+		return (strtolower($this->name) === strtolower($name));
+	}
+
+	public function findUrl($method = null, $parameters = null, $name = null)
+	{
+		$method = array_search($name, $this->names);
+		if ($method !== false) {
+			return rtrim($this->url . $this->urls[$method], '/') . '/';
+		}
+
+		return $this->url;
 	}

 	public function renderRoute(Request $request)
@@ -27,7 +72,7 @@ class RouterResource extends LoadableRoute implements IControllerRoute
 			$method = strtolower($controller[1]);

 			if (!method_exists($class, $method)) {
-				throw new RouterException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
+				throw new NotFoundHttpException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
 			}

 			call_user_func_array([$class, $method], $this->getParameters());
@@ -62,7 +107,7 @@ class RouterResource extends LoadableRoute implements IControllerRoute
 			$action = isset($parameters['action']) ? $parameters['action'] : null;
 			unset($parameters['action']);

-			$method = request()->getMethod();
+			$method = $request->getMethod();

 			// Delete
 			if (isset($parameters['id']) && $method === static::REQUEST_TYPE_DELETE) {
@@ -120,4 +165,39 @@ class RouterResource extends LoadableRoute implements IControllerRoute
 		return $this;
 	}

+	public function setName($name)
+	{
+		$this->name = $name;
+
+		$this->names = [
+			'index'   => $this->name . '.index',
+			'create'  => $this->name . '.create',
+			'store'   => $this->name . '.store',
+			'show'    => $this->name . '.show',
+			'edit'    => $this->name . '.edit',
+			'update'  => $this->name . '.update',
+			'destroy' => $this->name . '.destroy',
+		];
+
+		return $this;
+	}
+
+	/**
+	 * Merge with information from another route.
+	 *
+	 * @param array $values
+	 * @param bool $merge
+	 * @return static
+	 */
+	public function setSettings(array $values, $merge = false)
+	{
+		if (isset($values['names'])) {
+			$this->names = $values['names'];
+		}
+
+		parent::setSettings($values, $merge);
+
+		return $this;
+	}
+
 }
@@ -1,9 +1,9 @@
 <?php
-namespace Pecee\SimpleRouter;
+namespace Pecee\SimpleRouter\Route;

 use Pecee\Http\Request;

-class RouterRoute extends LoadableRoute
+class RouteUrl extends LoadableRoute
 {
 	public function __construct($url, $callback)
 	{
@@ -18,11 +18,13 @@ class RouterRoute extends LoadableRoute

 		// Match on custom defined regular expression
 		if ($this->regex !== null) {
-			$parameters = array();
+			$parameters = [];
 			if (preg_match('/(' . $this->regex . ')/is', $request->getHost() . $url, $parameters)) {
 				$this->parameters = (array)$parameters[0];
+
 				return true;
 			}
+
 			return null;
 		}

@@ -33,6 +35,7 @@ class RouterRoute extends LoadableRoute

 		if ($parameters !== null) {
 			$this->parameters = array_merge($this->parameters, $parameters);
+
 			return true;
 		}

@@ -0,0 +1,543 @@
+<?php
+namespace Pecee\SimpleRouter;
+
+use Pecee\Handlers\IExceptionHandler;
+use Pecee\Http\Middleware\BaseCsrfVerifier;
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\HttpException;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+use Pecee\SimpleRouter\Route\IControllerRoute;
+use Pecee\SimpleRouter\Route\IGroupRoute;
+use Pecee\SimpleRouter\Route\ILoadableRoute;
+use Pecee\SimpleRouter\Route\IRoute;
+
+class Router
+{
+
+	/**
+	 * The instance of this class
+	 * @var static
+	 */
+	protected static $instance;
+
+	/**
+	 * Current request
+	 * @var Request
+	 */
+	protected $request;
+
+	/**
+	 * Defines if a route is currently being processed.
+	 * @var bool
+	 */
+	protected $processingRoute;
+
+	/**
+	 * All added routes
+	 * @var array
+	 */
+	protected $routes;
+
+	/**
+	 * List of processed routes
+	 * @var array
+	 */
+	protected $processedRoutes;
+
+	/**
+	 * Stack of routes used to keep track of sub-routes added
+	 * when a route is being processed.
+	 * @var array
+	 */
+	protected $routeStack;
+
+	/**
+	 * List of added bootmanagers
+	 * @var array
+	 */
+	protected $bootManagers;
+
+	/**
+	 * Csrf verifier class
+	 * @var BaseCsrfVerifier
+	 */
+	protected $csrfVerifier;
+
+	/**
+	 * Get exception handlers
+	 * @var array
+	 */
+	protected $exceptionHandlers;
+
+	/**
+	 * The current loaded route
+	 * @var ILoadableRoute|null
+	 */
+	protected $loadedRoute;
+
+	/**
+	 * List over route changes (to avoid endless-looping)
+	 * @var array
+	 */
+	protected $routeRewrites = [];
+
+	/**
+	 * If the route has been rewritten/changed this property will contain the original url.
+	 * @var string
+	 */
+	protected $originalUrl;
+
+	/**
+	 * Get current router instance
+	 * @return static
+	 */
+	public static function getInstance()
+	{
+		if (static::$instance === null) {
+			static::$instance = new static();
+		}
+
+		return static::$instance;
+	}
+
+	public function __construct()
+	{
+		$this->reset();
+	}
+
+	public function reset()
+	{
+		$this->processingRoute = false;
+		$this->request = new Request();
+		$this->routes = [];
+		$this->bootManagers = [];
+		$this->routeStack = [];
+		$this->processedRoutes = [];
+		$this->exceptionHandlers = [];
+	}
+
+	/**
+	 * Add route
+	 * @param IRoute $route
+	 * @return IRoute
+	 */
+	public function addRoute(IRoute $route)
+	{
+		/*
+		 * If a route is currently being processed, that means that the
+		 * route being added are rendered from the parent routes callback,
+		 * so we add them to the stack instead.
+		 */
+		if ($this->processingRoute === true) {
+			$this->routeStack[] = $route;
+		} else {
+			$this->routes[] = $route;
+		}
+
+		return $route;
+	}
+
+	protected function processRoutes(array $routes, IGroupRoute $group = null, IRoute $parent = null)
+	{
+		// Loop through each route-request
+		/* @var $route IRoute */
+		foreach ($routes as $route) {
+
+			if ($route instanceof IGroupRoute) {
+
+				$group = $route;
+
+				if ($route->getCallback() !== null && is_callable($route->getCallback())) {
+
+					$this->processingRoute = true;
+					$route->renderRoute($this->request);
+					$this->processingRoute = false;
+
+					if ($route->matchRoute($this->request)) {
+
+						/* Add exceptionhandlers */
+						if (count($route->getExceptionHandlers()) > 0) {
+							$this->exceptionHandlers = array_merge($route->getExceptionHandlers(), $this->exceptionHandlers);
+						}
+
+					}
+				}
+			}
+
+			if ($group !== null) {
+
+				/* Add the parent group */
+				$route->setGroup($group);
+
+			}
+
+			if ($parent !== null) {
+
+				/* Add the parent route */
+				$route->setParent($parent);
+
+				/* Add/merge parent settings with child */
+				$route->setSettings($parent->toArray(), true);
+
+			}
+
+			if ($route instanceof ILoadableRoute) {
+
+				/* Add the route to the map, so we can find the active one when all routes has been loaded */
+				$this->processedRoutes[] = $route;
+			}
+
+			if (count($this->routeStack) > 0) {
+
+				/* Pop and grap the routes added when executing group callback earlier */
+				$stack = $this->routeStack;
+				$this->routeStack = [];
+
+				/* Route any routes added to the stack */
+				$this->processRoutes($stack, $route, $group);
+			}
+		}
+	}
+
+	public function routeRequest($rewrite = false)
+	{
+		$this->loadedRoute = null;
+		$routeNotAllowed = false;
+
+		try {
+
+			/* Initialize boot-managers */
+			if (count($this->bootManagers) > 0) {
+
+				$max = count($this->bootManagers) - 1;
+
+				/* @var $manager IRouterBootManager */
+				for ($i = 0; $i < $max; $i++) {
+
+					$manager = $this->bootManagers[$i];
+
+					$this->request = $manager->boot($this->request);
+
+					if (!($this->request instanceof Request)) {
+						throw new HttpException('Bootmanager "' . get_class($manager) . '" must return instance of ' . Request::class, 500);
+					}
+				}
+			}
+
+			if ($rewrite === false) {
+
+				/* Loop through each route-request */
+				$this->processRoutes($this->routes);
+
+				if ($this->csrfVerifier !== null) {
+
+					// Verify csrf token for request
+					$this->csrfVerifier->handle($this->request);
+				}
+
+				$this->originalUrl = $this->request->getUri();
+			}
+
+			$max = count($this->processedRoutes);
+
+			/* @var $route IRoute */
+			for ($i = 0; $i < $max; $i++) {
+
+				$route = $this->processedRoutes[$i];
+
+				/* If the route matches */
+				if ($route->matchRoute($this->request)) {
+
+					/* Check if request method matches */
+					if (count($route->getRequestMethods()) > 0 && !in_array($this->request->getMethod(), $route->getRequestMethods())) {
+						$routeNotAllowed = true;
+						continue;
+					}
+
+					$this->loadedRoute = $route;
+					$this->loadedRoute->loadMiddleware($this->request, $this->loadedRoute);
+
+					/* If the request has changed, we reinitialize the router */
+					if ($this->request->getUri() !== $this->originalUrl && !in_array($this->request->getUri(), $this->routeRewrites)) {
+						$this->routeRewrites[] = $this->request->getUri();
+						$this->routeRequest(true);
+
+						return;
+					}
+
+					/* Render route */
+					$routeNotAllowed = false;
+					$this->request->setUri($this->originalUrl);
+					$this->loadedRoute->renderRoute($this->request);
+
+					break;
+				}
+			}
+
+		} catch (\Exception $e) {
+			$this->handleException($e);
+		}
+
+		if ($routeNotAllowed === true) {
+			$this->handleException(new HttpException('Route or method not allowed', 403));
+		}
+
+		if ($this->loadedRoute === null) {
+			$this->handleException(new NotFoundHttpException('Route not found: ' . $this->request->getUri(), 404));
+		}
+	}
+
+	protected function handleException(\Exception $e)
+	{
+		$max = count($this->exceptionHandlers);
+
+		/* @var $handler IExceptionHandler */
+		for ($i = 0; $i < $max; $i++) {
+
+			$handler = $this->exceptionHandlers[$i];
+
+			$handler = new $handler();
+
+			if (!($handler instanceof IExceptionHandler)) {
+				throw new HttpException('Exception handler must implement the IExceptionHandler interface.', 500);
+			}
+
+			$request = $handler->handleError($this->request, $this->loadedRoute, $e);
+
+			/* If the request has changed */
+			if ($request !== null && $this->request->getUri() !== $this->originalUrl && !in_array($request->getUri(), $this->routeRewrites)) {
+				$this->request = $request;
+				$this->routeRewrites[] = $request->getUri();
+				$this->routeRequest(true);
+
+				return;
+			}
+		}
+
+		throw $e;
+	}
+
+	public function arrayToParams(array $getParams = [], $includeEmpty = true)
+	{
+		if (count($getParams) > 0) {
+
+			if ($includeEmpty === false) {
+				$getParams = array_filter($getParams, function ($item) {
+					return (!empty($item));
+				});
+			}
+
+			return '?' . http_build_query($getParams);
+		}
+
+		return '';
+	}
+
+	/**
+	 * Find route by alias, class, callback or method.
+	 *
+	 * @param string $name
+	 * @return ILoadableRoute|null
+	 */
+	public function findRoute($name)
+	{
+		$max = count($this->processedRoutes);
+
+		/* @var $route ILoadableRoute */
+		for ($i = 0; $i < $max; $i++) {
+
+			$route = $this->processedRoutes[$i];
+
+			/* Check if the name matches with a name on the route. Should match either router alias or controller alias. */
+			if ($route->hasName($name)) {
+				return $route;
+			}
+
+			/* Direct match to controller */
+			if ($route instanceof IControllerRoute && strtolower($route->getController()) === strtolower($name)) {
+				return $route;
+			}
+
+			/* Using @ is most definitely a controller@method or alias@method */
+			if (strpos($name, '@') !== false) {
+				list($controller, $method) = array_map('strtolower', explode('@', $name));
+
+				if ($controller === strtolower($route->getClass()) && $method === strtolower($route->getMethod())) {
+					return $route;
+				}
+			}
+
+			/* Check if callback matches (if it's not a function) */
+			if (strpos($name, '@') !== false && strpos($route->getCallback(), '@') !== false && !is_callable($route->getCallback())) {
+
+				/* Check if the entire callback is matching */
+				if (strtolower($route->getCallback()) === strtolower($name) || strpos($route->getCallback(), $name) === 0) {
+					return $route;
+				}
+
+				/* Check if the class part of the callback matches (class@method) */
+				if (strtolower($name) === strtolower($route->getClass())) {
+					return $route;
+				}
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get url for a route by using either name/alias, class or method name.
+	 *
+	 * The name parameter supports the following values:
+	 * - Route name
+	 * - Controller/resource name (with or without method)
+	 * - Controller class name
+	 *
+	 * When searching for controller/resource by name, you can use this syntax "route.name@method".
+	 * You can also use the same syntax when searching for a specific controller-class "MyController@home".
+	 * If no arguments is specified, it will return the url for the current loaded route.
+	 *
+	 * @param string|null $name
+	 * @param string|array|null $parameters
+	 * @param array|null $getParams
+	 * @return string
+	 */
+	public function getUrl($name = null, $parameters = null, $getParams = null)
+	{
+		if ($getParams !== null && is_array($getParams) === false) {
+			throw new \InvalidArgumentException('Invalid type for getParams. Must be array or null');
+		}
+
+		/* Only merge $_GET when all parameters are null */
+		if ($name === null && $parameters === null && $getParams === null) {
+			$getParams = $_GET;
+		} else {
+			$getParams = (array)$getParams;
+		}
+
+		/* Return current route if no options has been specified */
+		if ($name === null && $parameters === null) {
+			$url = rtrim(parse_url($this->request->getUri(), PHP_URL_PATH), '/');
+			return (($url === '') ? '/' : $url . '/') . $this->arrayToParams($getParams);
+		}
+
+		/* If nothing is defined and a route is loaded we use that */
+		if ($name === null && $this->loadedRoute !== null) {
+			return $this->loadedRoute->findUrl($this->loadedRoute->getMethod(), $parameters, $name) . $this->arrayToParams($getParams);
+		}
+
+		/* We try to find a match on the given name */
+		$route = $this->findRoute($name);
+
+		if ($route !== null) {
+			return $route->findUrl($route->getMethod(), $parameters, $name) . $this->arrayToParams($getParams);
+		}
+
+		/* Using @ is most definitely a controller@method or alias@method */
+		if (stripos($name, '@') !== false) {
+			list($controller, $method) = explode('@', $name);
+
+			/* Loop through all the routes to see if we can find a match */
+
+			$max = count($this->processedRoutes);
+
+			/* @var $route ILoadableRoute */
+			for ($i = 0; $i < $max; $i++) {
+
+				$route = $this->processedRoutes[$i];
+
+				/* Check if the route contains the name/alias */
+				if ($route->hasName($controller)) {
+					return $route->findUrl($method, $parameters, $name) . $this->arrayToParams($getParams);
+				}
+
+				/* Check if the route controller is equal to the name */
+				if ($route instanceof IControllerRoute && strtolower($route->getController()) === strtolower($controller)) {
+					return $route->findUrl($method, $parameters, $name) . $this->arrayToParams($getParams);
+				}
+
+			}
+		}
+
+		/* No result so we assume that someone is using a hardcoded url and join everything together. */
+		$url = trim(join('/', array_merge((array)$name, (array)$parameters)), '/');
+		return (($url === '') ? '/' : '/' . $url . '/') . $this->arrayToParams($getParams);
+	}
+
+	/**
+	 * Get bootmanagers
+	 * @return array
+	 */
+	public function getBootManagers()
+	{
+		return $this->bootManagers;
+	}
+
+	/**
+	 * Set bootmanagers
+	 * @param array $bootManagers
+	 */
+	public function setBootManagers(array $bootManagers)
+	{
+		$this->bootManagers = $bootManagers;
+	}
+
+	/**
+	 * Add bootmanager
+	 * @param IRouterBootManager $bootManager
+	 */
+	public function addBootManager(IRouterBootManager $bootManager)
+	{
+		$this->bootManagers[] = $bootManager;
+	}
+
+	/**
+	 * @return array
+	 */
+	public function getRoutes()
+	{
+		return $this->routes;
+	}
+
+	/**
+	 * Get current request
+	 *
+	 * @return Request
+	 */
+	public function getRequest()
+	{
+		return $this->request;
+	}
+
+	/**
+	 * Get csrf verifier class
+	 * @return BaseCsrfVerifier
+	 */
+	public function getCsrfVerifier()
+	{
+		return $this->csrfVerifier;
+	}
+
+	/**
+	 * Set csrf verifier class
+	 *
+	 * @param BaseCsrfVerifier $csrfVerifier
+	 * @return static
+	 */
+	public function setCsrfVerifier(BaseCsrfVerifier $csrfVerifier)
+	{
+		$this->csrfVerifier = $csrfVerifier;
+
+		return $this;
+	}
+
+	/**
+	 * Get loaded route
+	 * @return ILoadableRoute|null
+	 */
+	public function getLoadedRoute()
+	{
+		return $this->loadedRoute;
+	}
+
+}
@@ -1,558 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-use Pecee\Exception\RouterException;
-use Pecee\Handler\IExceptionHandler;
-use Pecee\Http\Middleware\BaseCsrfVerifier;
-use Pecee\Http\Request;
-use Pecee\Http\Response;
-
-class RouterBase
-{
-
-	/**
-	 * @var static
-	 */
-	protected static $instance;
-
-	/**
-	 * Current request
-	 * @var Request
-	 */
-	protected $request;
-
-	/**
-	 * Response
-	 * @var Response
-	 */
-	protected $response;
-
-	/**
-	 * Used to keep track of whether or not a should should be added to
-	 * the backstack-list for group-processing or not.
-	 * @var bool
-	 */
-	protected $processingRoute;
-
-	/**
-	 * All added routes
-	 * @var array
-	 */
-	protected $routes;
-
-	/**
-	 * List of
-	 * @var array
-	 */
-	protected $controllerUrlMap;
-
-	/**
-	 * Backstack array used to keep track of sub-routes
-	 * @var array
-	 */
-	protected $backStack;
-
-	/**
-	 * List of added bootmanagers
-	 * @var array
-	 */
-	protected $bootManagers;
-
-	/**
-	 * Csrf verifier class
-	 * @var BaseCsrfVerifier
-	 */
-	protected $csrfVerifier;
-
-	/**
-	 * Get exception handlers
-	 * @var array
-	 */
-	protected $exceptionHandlers;
-
-	/**
-	 * The current loaded route
-	 * @var RouterRoute|null
-	 */
-	protected $loadedRoute;
-
-	/**
-	 * List over route changes (to avoid endless-looping)
-	 * @var array
-	 */
-	protected $routeRewrites = [];
-
-	/**
-	 * If the route has been rewritten/changed this property will contain the original url.
-	 * @var string
-	 */
-	protected $originalUrl;
-
-	/**
-	 * Get current router instance
-	 * @return static
-	 */
-	public static function getInstance()
-	{
-		if (static::$instance === null) {
-			static::$instance = new static();
-		}
-
-		return static::$instance;
-	}
-
-	public function __construct()
-	{
-		$this->reset();
-	}
-
-	public function reset()
-	{
-		$this->processingRoute = false;
-		$this->request = new Request();
-		$this->response = new Response($this->request);
-		$this->routes = array();
-		$this->bootManagers = array();
-		$this->backStack = array();
-		$this->controllerUrlMap = array();
-		$this->exceptionHandlers = array();
-	}
-
-	/**
-	 * Add route
-	 * @param RouterEntry $route
-	 * @return RouterEntry
-	 */
-	public function addRoute(RouterEntry $route)
-	{
-		if ($this->processingRoute) {
-			$this->backStack[] = $route;
-		} else {
-			$this->routes[] = $route;
-		}
-
-		return $route;
-	}
-
-	protected function processRoutes(array $routes, array $settings = array(), array $prefixes = array(), RouterEntry $parent = null) {
-
-		$mergedSettings = [];
-
-		// Loop through each route-request
-		/* @var $route RouterEntry */
-		foreach ($routes as $route) {
-
-			$route->merge($settings);
-
-			if ($parent !== null) {
-				$route->setParent($parent);
-			}
-
-			if ($route instanceof ILoadableRoute) {
-
-				if($parent !== null && count($prefixes)) {
-					$route->setUrl(trim(join('/', $prefixes) . $route->getUrl(), '/'));
-				}
-
-				$this->controllerUrlMap[] = $route;
-
-			} elseif ($route instanceof RouterGroup) {
-
-				if ($route->getPrefix() !== null && trim($route->getPrefix(), '/') !== '') {
-					$prefixes[] = trim($route->getPrefix(), '/');
-				}
-
-				if ($route->getCallback() !== null && is_callable($route->getCallback())) {
-
-					$this->processingRoute = true;
-					$route->renderRoute($this->request);
-					$this->processingRoute = false;
-
-					if ($route->matchRoute($this->request)) {
-
-						$mergedSettings = array_merge($mergedSettings, $route->toArray());
-
-						// Add ExceptionHandler
-						if (count($route->getExceptionHandlers()) > 0) {
-							$this->exceptionHandlers = array_merge($route->getExceptionHandlers(),
-								$this->exceptionHandlers);
-						}
-					}
-				}
-			}
-
-			if (count($this->backStack) > 0) {
-				$backStack = $this->backStack;
-				$this->backStack = array();
-
-				// Route any routes added to the backstack
-				$this->processRoutes($backStack, $mergedSettings, $prefixes, $route);
-			}
-		}
-	}
-
-	public function routeRequest($rewrite = false)
-	{
-		$this->loadedRoute = null;
-		$routeNotAllowed = false;
-
-		try {
-
-			// Initialize boot-managers
-			if (count($this->bootManagers) > 0) {
-				/* @var $manager RouterBootManager */
-				foreach ($this->bootManagers as $manager) {
-					$this->request = $manager->boot($this->request);
-
-					if (!($this->request instanceof Request)) {
-						throw new RouterException('Custom router bootmanager "' . get_class($manager) . '" must return instance of Request.');
-					}
-				}
-			}
-
-			if ($rewrite === false) {
-
-				// Loop through each route-request
-				$this->processRoutes($this->routes);
-
-				if ($this->csrfVerifier !== null) {
-
-					// Verify csrf token for request
-					$this->csrfVerifier->handle($this->request);
-				}
-
-				$this->originalUrl = $this->request->getUri();
-			}
-
-			/* @var $route RouterEntry */
-			foreach ($this->controllerUrlMap as $route) {
-
-				if ($route->matchRoute($this->request)) {
-
-					if (count($route->getRequestMethods()) > 0 && !in_array($this->request->getMethod(), $route->getRequestMethods())) {
-						$routeNotAllowed = true;
-						continue;
-					}
-
-					$this->loadedRoute = $route;
-					$this->loadedRoute->loadMiddleware($this->request, $this->loadedRoute);
-
-					if ($this->request->getUri() !== $this->originalUrl && !in_array($this->request->getUri(), $this->routeRewrites)) {
-						$this->routeRewrites[] = $this->request->getUri();
-						$this->routeRequest(true);
-						return;
-					}
-
-					$routeNotAllowed = false;
-					$this->request->setUri($this->originalUrl);
-					$this->loadedRoute->renderRoute($this->request);
-
-					break;
-				}
-			}
-
-		} catch (\Exception $e) {
-			$this->handleException($e);
-		}
-
-		if ($routeNotAllowed) {
-			$this->handleException(new RouterException('Route or method not allowed', 403));
-		}
-
-		if ($this->loadedRoute === null) {
-			$this->handleException(new RouterException(sprintf('Route not found: %s', $this->request->getUri()), 404));
-		}
-	}
-
-	protected function handleException(\Exception $e)
-	{
-		/* @var $handler IExceptionHandler */
-		foreach ($this->exceptionHandlers as $handler) {
-
-			$handler = new $handler();
-
-			if (!($handler instanceof IExceptionHandler)) {
-				throw new RouterException('Exception handler must implement the IExceptionHandler interface.');
-			}
-
-			$request = $handler->handleError($this->request, $this->loadedRoute, $e);
-
-			if ($request !== null && $request->getUri() !== $this->originalUrl && !in_array($request->getUri(), $this->routeRewrites)) {
-				$this->routeRewrites[] = $request->getUri();
-				$this->routeRequest(true);
-				return;
-			}
-
-		}
-
-		throw $e;
-	}
-
-	public function arrayToParams(array $getParams = null, $includeEmpty = true)
-	{
-		if (is_array($getParams) === true && count($getParams) > 0) {
-
-			if ($includeEmpty === false) {
-				$getParams = array_filter($getParams, function ($item) {
-					return (!empty($item));
-				});
-			}
-
-			return '?' . http_build_query($getParams);
-		}
-
-		return '';
-	}
-
-	protected function processUrl(LoadableRoute $route, $method = null, $parameters = null, $getParams = null)
-	{
-		$domain = '';
-		$parent = $route->getParent();
-
-		$parameters = (array)$parameters;
-
-		if ($parent !== null && $parent instanceof RouterGroup && count($parent->getDomains()) > 0) {
-			$domain = $parent->getDomains();
-			$domain = '//' . $domain[0];
-		}
-
-		$url = $domain . '/' . trim($route->getUrl(), '/');
-
-		if ($route instanceof IControllerRoute && $method !== null) {
-
-			$url .= '/' . $method . '/';
-
-			if (count($parameters) > 0) {
-				$url .= join('/', (array)$parameters);
-			}
-
-		} else {
-
-			if ($parameters !== null && count($parameters) > 0) {
-				$params = array_merge($route->getParameters(), (array)$parameters);
-			} else {
-				$params = $route->getParameters();
-			}
-
-			$otherParams = array();
-
-			foreach ($params as $param => $value) {
-				$value = (isset($parameters[$param])) ? $parameters[$param] : $value;
-
-				$param1 = LoadableRoute::PARAMETER_MODIFIERS[0] . $param . LoadableRoute::PARAMETER_MODIFIERS[1];
-				$param2 = LoadableRoute::PARAMETER_MODIFIERS[0] . $param . LoadableRoute::PARAMETER_OPTIONAL_SYMBOL . LoadableRoute::PARAMETER_MODIFIERS[1];
-
-				if (stripos($url, $param1) !== false || stripos($url, $param) !== false) {
-					$url = str_ireplace([$param1, $param2], $value, $url);
-				} else {
-					$otherParams[$param] = $value;
-				}
-			}
-
-			$url = rtrim($url, '/') . '/' . join('/', $otherParams);
-		}
-
-		$url = rtrim($url, '/') . '/';
-
-		if ($getParams !== null) {
-			$url .= $this->arrayToParams($getParams);
-		}
-
-		return $url;
-	}
-
-	/**
-	 * Find route by alias, class, callback or method.
-	 *
-	 * @param string $query
-	 * @return LoadableRoute|null
-	 */
-	public function findRoute($query)
-	{
-		/* @var $route LoadableRoute */
-		foreach ($this->controllerUrlMap as $route) {
-
-			// Check an alias exist, if the matches - use it
-			// Matches either Router alias or controller alias.
-			if ($route->hasAlias($query)) {
-				return $route;
-			}
-
-			// Direct match to controller
-			if ($route instanceof IControllerRoute) {
-				if (strtolower($route->getController()) === strtolower($query)) {
-					return $route;
-				}
-			}
-
-			// Using @ is most definitely a controller@method or alias@method
-			if (strpos($query, '@') !== false) {
-				list($controller, $method) = array_map('strtolower', explode('@', $query));
-
-				if ($controller === strtolower($route->getClass()) && $method === strtolower($route->getMethod())) {
-					return $route;
-				}
-			}
-
-			// Use callback if it's not a function
-			if (strpos($query, '@') !== false && strpos($route->getCallback(), '@') !== false && !is_callable($route->getCallback())) {
-
-				if (strtolower($query) === strtolower($route->getClass())) {
-					return $route;
-				}
-
-				if (strtolower($route->getCallback()) === strtolower($query) || strpos($route->getCallback(), $query) === 0) {
-					return $route;
-				}
-
-			}
-		}
-
-		return null;
-	}
-
-	public function getRoute($controller = null, $parameters = null, $getParams = null)
-	{
-		if ($getParams !== null && is_array($getParams) === false) {
-			throw new \InvalidArgumentException('Invalid type for getParams. Must be array or null');
-		}
-
-		// Return current route if no options has been specified
-		if ($controller === null && $parameters === null) {
-
-			$getParams = ($getParams !== null) ? $getParams : $_GET;
-			$url = parse_url($this->request->getUri(), PHP_URL_PATH) . $this->arrayToParams($getParams);
-
-			return $url;
-		}
-
-		// If nothing is defined and a route is loaded we use that
-		if ($controller === null && $this->loadedRoute !== null) {
-			return $this->processUrl($this->loadedRoute, $this->loadedRoute->getMethod(), $parameters, $getParams);
-		}
-
-		$route = $this->findRoute($controller);
-
-		if ($route !== null) {
-			return $this->processUrl($route, $route->getMethod(), $parameters, $getParams);
-		}
-
-		// Using @ is most definitely a controller@method or alias@method
-		if (stripos($controller, '@') !== false) {
-			list($controller, $method) = explode('@', $controller);
-
-			/* @var $route LoadableRoute */
-			foreach ($this->controllerUrlMap as $route) {
-
-				if ($route->hasAlias($controller)) {
-					return $this->processUrl($route, $method, $parameters, $getParams);
-				}
-
-				// Match controllers either by: "alias @ method" or "controller@method"
-				if ($route instanceof IControllerRoute && strtolower($route->getController()) === strtolower($controller)) {
-					return $this->processUrl($route, $method, $parameters, $getParams);
-				}
-
-			}
-		}
-
-		$url = [($controller === null) ? '/' : $controller];
-
-		if ($parameters !== null && count($parameters) > 0) {
-			$url = array_merge($url, (array)$parameters);
-		}
-
-		$url = '/' . trim(join('/', $url), '/') . '/';
-
-		if ($getParams !== null) {
-			$url .= $this->arrayToParams($getParams);
-		}
-
-		return $url;
-	}
-
-	/**
-	 * Get bootmanagers
-	 * @return array
-	 */
-	public function getBootManagers()
-	{
-		return $this->bootManagers;
-	}
-
-	/**
-	 * Set bootmanagers
-	 * @param array $bootManagers
-	 */
-	public function setBootManagers(array $bootManagers)
-	{
-		$this->bootManagers = $bootManagers;
-	}
-
-	/**
-	 * Add bootmanager
-	 * @param RouterBootManager $bootManager
-	 */
-	public function addBootManager(RouterBootManager $bootManager)
-	{
-		$this->bootManagers[] = $bootManager;
-	}
-
-	/**
-	 * @return array
-	 */
-	public function getRoutes()
-	{
-		return $this->routes;
-	}
-
-	/**
-	 * Get current request
-	 *
-	 * @return Request
-	 */
-	public function getRequest()
-	{
-		return $this->request;
-	}
-
-	/**
-	 * Get response
-	 * @return Response
-	 */
-	public function getResponse()
-	{
-		return $this->response;
-	}
-
-	/**
-	 * Get csrf verifier class
-	 * @return BaseCsrfVerifier
-	 */
-	public function getCsrfVerifier()
-	{
-		return $this->csrfVerifier;
-	}
-
-	/**
-	 * Set csrf verifier class
-	 *
-	 * @param BaseCsrfVerifier $csrfVerifier
-	 * @return static
-	 */
-	public function setCsrfVerifier(BaseCsrfVerifier $csrfVerifier)
-	{
-		$this->csrfVerifier = $csrfVerifier;
-		return $this;
-	}
-
-	/**
-	 * Get loaded route
-	 * @return RouterRoute|null
-	 */
-	public function getLoadedRoute()
-	{
-		return $this->loadedRoute;
-	}
-
-}
@@ -1,9 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-use Pecee\Http\Request;
-
-abstract class RouterBootManager
-{
-	abstract public function boot(Request $request);
-}
@@ -1,110 +0,0 @@
-<?php
-namespace Pecee\SimpleRouter;
-
-use Pecee\Exception\RouterException;
-use Pecee\Http\Request;
-
-class RouterController extends LoadableRoute implements IControllerRoute
-{
-	protected $defaultMethod = 'index';
-	protected $controller;
-	protected $method;
-
-	public function __construct($url, $controller)
-	{
-		$this->setUrl($url);
-		$this->controller = $controller;
-	}
-
-	public function renderRoute(Request $request)
-	{
-		if ($this->getCallback() !== null && is_callable($this->getCallback())) {
-
-			// When the callback is a function
-			call_user_func_array($this->getCallback(), $this->getParameters());
-		} else {
-			// When the callback is a method
-			$controller = explode('@', $this->getCallback());
-			$className = $this->getNamespace() . '\\' . $controller[0];
-
-			$class = $this->loadClass($className);
-			$method = $request->getMethod() . ucfirst($controller[1]);
-
-			if (!method_exists($class, $method)) {
-				throw new RouterException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
-			}
-
-			call_user_func_array(array($class, $method), $this->getParameters());
-
-			return $class;
-		}
-
-		return null;
-	}
-
-	public function matchRoute(Request $request)
-	{
-		$url = parse_url(urldecode($request->getUri()), PHP_URL_PATH);
-		$url = rtrim($url, '/') . '/';
-
-		if (strtolower($url) == strtolower($this->url) || stripos($url, $this->url) === 0) {
-
-			$strippedUrl = trim(str_ireplace($this->url, '/', $url), '/');
-
-			$path = explode('/', $strippedUrl);
-
-			if (count($path) > 0) {
-
-				$method = (!isset($path[0]) || trim($path[0]) === '') ? $this->defaultMethod : $path[0];
-				$this->method = $method;
-
-				array_shift($path);
-				$this->parameters = $path;
-
-				// Set callback
-				$this->setCallback($this->controller . '@' . $this->method);
-
-				return true;
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getController()
-	{
-		return $this->controller;
-	}
-
-	/**
-	 * @param string $controller
-	 * @return static
-	 */
-	public function setController($controller)
-	{
-		$this->controller = $controller;
-		return $this;
-	}
-
-	/**
-	 * @return string
-	 */
-	public function getMethod()
-	{
-		return $this->method;
-	}
-
-	/**
-	 * @param string $method
-	 * @return static
-	 */
-	public function setMethod($method)
-	{
-		$this->method = $method;
-		return $this;
-	}
-
-}
@@ -3,21 +3,41 @@
 * ---------------------------
 * Router helper class
 * ---------------------------
- * This class is added so calls can be made statically like Router::get() making the code look more pretty.
+ *
+ * This class is added so calls can be made statically like Router::get() making the code look pretty.
+ * It also adds some extra functionality like default-namespace.
 */
 namespace Pecee\SimpleRouter;

-use Pecee\Exception\RouterException;
 use Pecee\Http\Middleware\BaseCsrfVerifier;
+use Pecee\Http\Response;
+use Pecee\SimpleRouter\Exceptions\HttpException;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+use Pecee\SimpleRouter\Route\IRoute;
+use Pecee\SimpleRouter\Route\RouteController;
+use Pecee\SimpleRouter\Route\RouteGroup;
+use Pecee\SimpleRouter\Route\RouteResource;
+use Pecee\SimpleRouter\Route\RouteUrl;

 class SimpleRouter
 {
+	/**
+	 * Default namespace added to all routes
+	 * @var string
+	 */
 	protected static $defaultNamespace;

+	/**
+	 * The response object
+	 * @var Response
+	 */
+	protected static $response;
+
 	/**
 	 * Start/route request
 	 *
-	 * @throws \Pecee\Exception\RouterException
+	 * @throws HttpException
+	 * @throws NotFoundHttpException
 	 */
 	public static function start()
 	{
@@ -48,9 +68,9 @@ class SimpleRouter
 	 * Boot managers allows you to alter the routes before the routing occurs.
 	 * Perfect if you want to load pretty-urls from a file or database.
 	 *
-	 * @param RouterBootManager $bootManager
+	 * @param IRouterBootManager $bootManager
 	 */
-	public static function addBootManager(RouterBootManager $bootManager)
+	public static function addBootManager(IRouterBootManager $bootManager)
 	{
 		static::router()->addBootManager($bootManager);
 	}
@@ -61,7 +81,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function get($url, $callback, array $settings = null)
 	{
@@ -74,7 +94,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function post($url, $callback, array $settings = null)
 	{
@@ -87,7 +107,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function put($url, $callback, array $settings = null)
 	{
@@ -100,7 +120,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function patch($url, $callback, array $settings = null)
 	{
@@ -113,7 +133,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function options($url, $callback, array $settings = null)
 	{
@@ -126,7 +146,7 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function delete($url, $callback, array $settings = null)
 	{
@@ -138,20 +158,17 @@ class SimpleRouter
 	 *
 	 * @param array $settings
 	 * @param \Closure $callback
-	 * @throws RouterException
-	 * @return RouterGroup
+	 * @throws \InvalidArgumentException
+	 * @return RouteGroup
 	 */
-	public static function group($settings = array(), \Closure $callback)
+	public static function group(array $settings = [], \Closure $callback)
 	{
-		$group = new RouterGroup();
+		$group = new RouteGroup();
 		$group->setCallback($callback);
-
-		if ($settings !== null && is_array($settings) === true) {
-			$group->merge($settings);
-		}
+		$group->setSettings($settings);

 		if (is_callable($callback) === false) {
-			throw new RouterException('Invalid callback provided. Only functions or methods supported');
+			throw new \InvalidArgumentException('Invalid callback provided. Only functions or methods supported');
 		}

 		static::router()->addRoute($group);
@@ -166,7 +183,7 @@ class SimpleRouter
 	 * @param callable $callback
 	 * @param array|null $settings
 	 * @see SimpleRouter::form
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function basic($url, $callback, array $settings = null)
 	{
@@ -181,7 +198,7 @@ class SimpleRouter
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
 	 * @see SimpleRouter::form
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function form($url, $callback, array $settings = null)
 	{
@@ -195,16 +212,16 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterEntry|RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function match(array $requestMethods, $url, $callback, array $settings = null)
 	{
-		$route = new RouterRoute($url, $callback);
+		$route = new RouteUrl($url, $callback);
 		$route->setRequestMethods($requestMethods);
 		$route = static::addDefaultNamespace($route);

 		if ($settings !== null) {
-			$route->merge($settings);
+			$route->setSettings($settings);
 		}

 		static::router()->addRoute($route);
@@ -218,16 +235,15 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string|\Closure $callback
 	 * @param array|null $settings
-	 * @return RouterRoute
+	 * @return RouteUrl
 	 */
 	public static function all($url, $callback, array $settings = null)
 	{
-		$route = new RouterRoute($url, $callback);
-
+		$route = new RouteUrl($url, $callback);
 		$route = static::addDefaultNamespace($route);

 		if ($settings !== null) {
-			$route->merge($settings);
+			$route->setSettings($settings);
 		}

 		static::router()->addRoute($route);
@@ -241,16 +257,15 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string $controller
 	 * @param array|null $settings
-	 * @return RouterController
+	 * @return RouteController
 	 */
 	public static function controller($url, $controller, array $settings = null)
 	{
-		$route = new RouterController($url, $controller);
-
+		$route = new RouteController($url, $controller);
 		$route = static::addDefaultNamespace($route);

 		if ($settings !== null) {
-			$route->merge($settings);
+			$route->setSettings($settings);
 		}

 		static::router()->addRoute($route);
@@ -264,14 +279,14 @@ class SimpleRouter
 	 * @param string $url
 	 * @param string $controller
 	 * @param array|null $settings
-	 * @return RouterResource
+	 * @return RouteResource
 	 */
 	public static function resource($url, $controller, array $settings = null)
 	{
-		$route = new RouterResource($url, $controller);
+		$route = new RouteResource($url, $controller);

 		if ($settings !== null) {
-			$route->merge($settings);
+			$route->setSettings($settings);
 		}

 		static::router()->addRoute($route);
@@ -280,16 +295,25 @@ class SimpleRouter
 	}

 	/**
-	 * Get url by controller or alias.
+	 * Get url for a route by using either name/alias, class or method name.
 	 *
-	 * @param string $controller
-	 * @param array|null $parameters
+	 * The name parameter supports the following values:
+	 * - Route name
+	 * - Controller/resource name (with or without method)
+	 * - Controller class name
+	 *
+	 * When searching for controller/resource by name, you can use this syntax "route.name@method".
+	 * You can also use the same syntax when searching for a specific controller-class "MyController@home".
+	 * If no arguments is specified, it will return the url for the current loaded route.
+	 *
+	 * @param string|null $name
+	 * @param string|array|null $parameters
 	 * @param array|null $getParams
 	 * @return string
 	 */
-	public static function getRoute($controller = null, $parameters = null, $getParams = null)
+	public static function getUrl($name = null, $parameters = null, $getParams = null)
 	{
-		return static::router()->getRoute($controller, $parameters, $getParams);
+		return static::router()->getUrl($name, $parameters, $getParams);
 	}

 	/**
@@ -305,30 +329,34 @@ class SimpleRouter
 	/**
 	 * Get the response object
 	 *
-	 * @return \Pecee\Http\Response
+	 * @return Response
 	 */
 	public static function response()
 	{
-		return static::router()->getResponse();
+		if (static::$response === null) {
+			static::$response = new Response(static::request());
+		}
+
+		return static::$response;
 	}

 	/**
 	 * Returns the router instance
 	 *
-	 * @return RouterBase
+	 * @return Router
 	 */
 	public static function router()
 	{
-		return RouterBase::getInstance();
+		return Router::getInstance();
 	}

 	/**
 	 * Prepends the default namespace to all new routes added.
 	 *
-	 * @param RouterEntry $route
-	 * @return RouterEntry
+	 * @param IRoute $route
+	 * @return IRoute
 	 */
-	protected static function addDefaultNamespace(RouterEntry $route)
+	protected static function addDefaultNamespace(IRoute $route)
 	{
 		if (static::$defaultNamespace !== null) {
 			$namespace = static::$defaultNamespace;
@@ -337,7 +365,7 @@ class SimpleRouter
 				$namespace .= '\\' . $route->getNamespace();
 			}

-			$route->setNamespace($namespace);
+			$route->setDefaultNamespace($namespace);
 		}

 		return $route;
@@ -6,7 +6,7 @@ use Pecee\Http\Request;

 class DummyMiddleware implements IMiddleware
 {
-	public function handle(Request $request, \Pecee\SimpleRouter\RouterEntry &$route = null)
+	public function handle(Request $request, \Pecee\SimpleRouter\Route\ILoadableRoute &$route)
 	{
 		throw new MiddlewareLoadedException('Middleware loaded!');
 	}
@@ -1,8 +1,8 @@
 <?php

-class ExceptionHandler implements \Pecee\Handler\IExceptionHandler
+class ExceptionHandler implements \Pecee\Handlers\IExceptionHandler
 {
-	public function handleError(\Pecee\Http\Request $request, \Pecee\SimpleRouter\RouterEntry &$route = null, \Exception $error)
+	public function handleError(\Pecee\Http\Request $request, \Pecee\SimpleRouter\Route\ILoadableRoute &$route = null, \Exception $error)
 	{
 		throw $error;
 	}
@@ -79,13 +79,16 @@ class GroupTest extends PHPUnit_Framework_TestCase
 		SimpleRouter::request()->setUri('/my/fancy/url/1');
 		SimpleRouter::request()->setMethod('get');

+		// Test array name
 		SimpleRouter::get('/my/fancy/url/1', 'DummyController@start', ['as' => 'fancy1']);
-		SimpleRouter::get('/my/fancy/url/2', 'DummyController@start')->setAlias('fancy2');
+
+		// Test method name
+		SimpleRouter::get('/my/fancy/url/2', 'DummyController@start')->setName('fancy2');

 		SimpleRouter::start();

-		$this->assertTrue((SimpleRouter::getRoute('fancy1') === '/my/fancy/url/1/'));
-		$this->assertTrue((SimpleRouter::getRoute('fancy2') === '/my/fancy/url/2/'));
+		$this->assertEquals('/my/fancy/url/1/', SimpleRouter::getUrl('fancy1'));
+		$this->assertEquals('/my/fancy/url/2/', SimpleRouter::getUrl('fancy2'));

 	}

@@ -5,6 +5,7 @@ require_once 'Dummy/DummyController.php';
 require_once 'Dummy/Handler/ExceptionHandler.php';

 use Pecee\SimpleRouter\SimpleRouter as SimpleRouter;
+use Pecee\SimpleRouter\Exceptions\NotFoundHttpException as NotFoundHttpException;

 class RouterRouteTest extends PHPUnit_Framework_TestCase
 {
@@ -25,7 +26,7 @@ class RouterRouteTest extends PHPUnit_Framework_TestCase
 		try {
 			SimpleRouter::start();
 		} catch (\Exception $e) {
-			$found = ($e instanceof \Pecee\Exception\RouterException && $e->getCode() == 404);
+			$found = ($e instanceof NotFoundHttpException && $e->getCode() == 404);
 		}

 		$this->assertTrue($found);
@@ -126,7 +127,7 @@ class RouterRouteTest extends PHPUnit_Framework_TestCase
 		$this->result = false;

 		SimpleRouter::group(['domain' => '{subdomain}.world.com'], function () {
-			SimpleRouter::get('test', function ($subdomain = null) {
+			SimpleRouter::get('/test', function ($subdomain = null) {
 				$this->result = ($subdomain === 'hello');
 			});
 		});
@@ -10,8 +10,8 @@ class RouterUrlTest extends PHPUnit_Framework_TestCase
 {
 	protected $result = false;

-	protected function getUrl($controller = null, $parameters = null, $getParams = null) {
-		return SimpleRouter::getRoute($controller, $parameters, $getParams);
+	protected function getUrl($name = null, $parameters = null, array $getParams = []) {
+		return SimpleRouter::getUrl($name, $parameters, $getParams);
 	}

 	public function testUrls()
@@ -23,60 +23,78 @@ class RouterUrlTest extends PHPUnit_Framework_TestCase
 		// Match normal route on alias
 		SimpleRouter::get('/', 'DummyController@silent', ['as' => 'home']);

-		SimpleRouter::group(['prefix' => '/admin'], function() {
+		SimpleRouter::get('/about', 'DummyController@about');
+
+		SimpleRouter::group(['prefix' => '/admin', 'as' => 'admin'], function() {

 			// Match route with prefix on alias
-			SimpleRouter::get('/{id?}', 'DummyController@start', ['as' => 'admin.home']);
+			SimpleRouter::get('/{id?}', 'DummyController@start', ['as' => 'home']);

 			// Match controller with prefix and alias
-			SimpleRouter::controller('/users', 'DummyController', ['as' => 'admin.users']);
+			SimpleRouter::controller('/users', 'DummyController', ['as' => 'users']);

 			// Match controller with prefix and NO alias
 			SimpleRouter::controller('/pages', 'DummyController');

 		});

+		SimpleRouter::group(['prefix' => 'api', 'as' => 'api'], function() {
+
+			// Match resource controller
+			SimpleRouter::resource('phones', 'DummyController');
+
+		});
+
+		SimpleRouter::controller('gadgets', 'DummyController', ['names' => ['getIphoneInfo' => 'iphone']]);
+
 		// Match controller with no prefix and no alias
 		SimpleRouter::controller('/cats', 'CatsController');

 		// Pretend to load page
 		SimpleRouter::start();

+		$this->assertEquals('/gadgets/iphoneinfo/', $this->getUrl('gadgets.iphone'));
+
+		$this->assertEquals('/api/phones/create/', $this->getUrl('api.phones.create'));
+
 		// Should match /
-		$this->assertEquals($this->getUrl('home'), '/');
+		$this->assertEquals('/', $this->getUrl('home'));
+
+		// Should match /about/
+		$this->assertEquals('/about/', $this->getUrl('DummyController@about'));

 		// Should match /admin/
-		$this->assertEquals($this->getUrl('DummyController@start'), '/admin/');
+		$this->assertEquals('/admin/', $this->getUrl('DummyController@start'));

 		// Should match /admin/
-		$this->assertEquals($this->getUrl('admin.home'), '/admin/');
+		$this->assertEquals('/admin/', $this->getUrl('admin.home'));

 		// Should match /admin/2/
-		$this->assertEquals($this->getUrl('admin.home', ['id' => 2]), '/admin/2/');
+		$this->assertEquals('/admin/2/', $this->getUrl('admin.home', ['id' => 2]));

 		// Should match /admin/users/
-		$this->assertEquals($this->getUrl('admin.users'), '/admin/users/');
+		$this->assertEquals('/admin/users/', $this->getUrl('admin.users'));

 		// Should match /admin/users/home/
-		$this->assertEquals($this->getUrl('admin.users@home'), '/admin/users/home/');
+		$this->assertEquals('/admin/users/home/', $this->getUrl('admin.users@home'));

 		// Should match /cats/
-		$this->assertEquals($this->getUrl('CatsController'), '/cats/');
+		$this->assertEquals('/cats/', $this->getUrl('CatsController'));

 		// Should match /cats/view/
-		$this->assertEquals($this->getUrl('CatsController', 'view'), '/cats/view/');
+		$this->assertEquals('/cats/view/', $this->getUrl('CatsController', 'view'));

 		// Should match /cats/view/
-		$this->assertEquals($this->getUrl('CatsController', ['view']), '/cats/view/');
+		//$this->assertEquals('/cats/view/', $this->getUrl('CatsController', ['view']));

 		// Should match /cats/view/666
-		$this->assertEquals($this->getUrl('CatsController@view', ['666']), '/cats/view/666/');
+		$this->assertEquals('/cats/view/666/', $this->getUrl('CatsController@getView', ['666']));

 		// Should match /funny/man/
-		$this->assertEquals($this->getUrl('/funny/man'), '/funny/man/');
+		$this->assertEquals('/funny/man/', $this->getUrl('/funny/man'));

-		// Should match /?jackdaniels=true
-		$this->assertEquals($this->getUrl('home', null, ['jackdaniels' => 'true']), '/?jackdaniels=true');
+		// Should match /?jackdaniels=true&cola=yeah
+		$this->assertEquals('/?jackdaniels=true&cola=yeah', $this->getUrl('home', null, ['jackdaniels' => 'true', 'cola' => 'yeah']));

 	}
Author	SHA1	Message	Date
Simon Sessingø	6445746324	Merge pull request #174 from skipperbent/v2-development Optimisations + bugfixes	2016-11-24 11:05:57 +02:00
Simon Sessingø	ff1f027bda	Make sure parameter-modifier is found before parsing parameters.	2016-11-24 10:04:47 +01:00
Simon Sessingø	9418d54c8e	No need to return getValue as it will be returned on render.	2016-11-24 09:56:21 +01:00
Simon Sessingø	e4ab14a2cb	Ensure that setError is always int.	2016-11-24 09:42:37 +01:00
Simon Sessingø	258e0e0f13	Optimisations + bugfixes	2016-11-24 09:36:10 +01:00
Simon Sessingø	1a2921acb4	Merge pull request #173 from skipperbent/v2-development Development	2016-11-21 09:30:58 +02:00
Simon Sessingø	f1a9a50ee5	Development - Only add $_GET param is every other parameter is null when calling getUrl.	2016-11-21 08:29:26 +01:00
Simon Sessingø	258d9d05c7	Merge pull request #171 from skipperbent/v2-development Enhancements	2016-11-21 09:04:22 +02:00
Simon Sessingø	2cc97c120f	Enhancements - Added example on how to get current url in documentation. - Fixed so urls always ends with /.	2016-11-21 07:56:37 +01:00
Simon Sessingø	7e7319de06	Merge pull request #169 from skipperbent/v2-development Fixed // on currentRoute urls.	2016-11-21 05:27:53 +02:00
Simon Sessingø	5ad7dcf9fd	Fixed // on currentRoute urls.	2016-11-21 04:27:06 +01:00
Simon Sessingø	531b35532b	Merge pull request #167 from skipperbent/v2-development Bugfixes	2016-11-21 05:07:59 +02:00
Simon Sessingø	dfd32c0904	Bugfixes - Moved middleware stuff back to Route class. - Fixed Tests not working due to invalid method. - Updated depricated method-calls in demo-project.	2016-11-21 04:06:45 +01:00
Simon Sessingø	c258f937e8	Merge pull request #165 from skipperbent/v2-development V 2.4.0 development	2016-11-21 04:09:26 +02:00
Simon Sessingø	efe5767220	Development - Removed yet another depricated method. - Fixed $_GET parameters being merged on default when calling getUrl. - Fixed double / that could appear on urls sometimes.	2016-11-21 03:05:43 +01:00
Simon Sessingø	5415d73f4d	Added phpDocs	2016-11-21 02:15:25 +01:00
Simon Sessingø	60c0bd6355	Removed getRoutes depricated class from Route class.	2016-11-21 01:53:53 +01:00
Simon Sessingø	8370d3d94e	Development - Made easier to extend. - Added IRoute class. - Changed namespace for Route classes. - Moved find-url related stuff to Route classes itself. - Added more tests for finding urls. - Added support for custom names on RouteController and RouteResource. - Removed depricated methods. - Updated documentation. - Updated demo-project to reflect changes. - Other small bugfixes and improvements.	2016-11-21 01:50:28 +01:00
Simon Sessingø	df3acb6605	Enchacements - Added more doctype and descriptions on functionality. - Renamed methods and properties to make better sense. - Added IRoute interface for easier extendability.	2016-11-20 18:05:57 +01:00
Simon Sessingø	88d58cd7b7	Merge pull request #163 from skipperbent/v2-development Fixed: wrong argument-type in getUrl method	2016-11-19 21:12:57 +02:00
Simon Sessingø	4a48a3fcf9	Fixed: wrong argument-type in getUrl method	2016-11-19 20:12:06 +01:00
Simon Sessingø	d04c74ccad	Merge pull request #161 from skipperbent/v2-development V2 development	2016-11-19 20:41:26 +02:00
Simon Sessingø	9922dcc552	Updated documentation	2016-11-19 19:37:59 +01:00
Simon Sessingø	87d619ca24	More optimisations	2016-11-19 19:28:10 +01:00
Simon Sessingø	7e63197252	Major overhaul	2016-11-19 19:24:05 +01:00
Simon Sessingø	02809a4daf	Merge pull request #159 from skipperbent/v2-development Bugfixes	2016-11-19 10:15:56 +02:00
Simon Sessingø	ba719cf880	Bugfixes	2016-11-19 09:15:34 +01:00
Simon Sessingø	da6b5af19f	Merge pull request #157 from skipperbent/v2-development Bugfixes	2016-11-19 09:47:19 +02:00
Simon Sessingø	808d59d3d3	Bugfixes	2016-11-19 08:46:48 +01:00
Simon Sessingø	914ec9d1b7	Merge pull request #155 from skipperbent/v2-development Small optimisations	2016-11-19 07:02:23 +02:00
Simon Sessingø	d1f33d9b01	Small optimisation	2016-11-19 06:01:53 +01:00