Merge pull request #96 from skipperbent/development

Development

.gitignore

@@ -1,2 +1,3 @@
 .idea
-composer.lock
+composer.lock
+vendor/

README.md

@@ -1,22 +1,21 @@
 # Simple PHP router
-Simple, fast and yet powerful PHP router that is easy to get integrated and in any project. Heavily inspired by the Laravel router.
+Simple, fast and yet powerful PHP router that is easy to get integrated and in any project. Heavily inspired by the way Laravel handles routing, with both simplicity and expandability in mind.
 
 ## Installation
-Add the latest version pf Simple PHP Router to your ```composer.json```
+Add the latest version of Simple PHP Router running this command.
 
-```json
-{
-    "require": {
-        "pecee/simple-php-router": "1.*"
-    },
-    "require-dev": {
-        "pecee/simple-php-router": "1.*"
-    }
-}
+```
+composer require pecee/simple-router
 ```
 
+## Requirements
+
+- PHP 5.4 or greater
+
 ## Notes
 
+The goal of this project is to create a router that is 100% compatible with the Laravel documentation, but as simple as possible and as easy to integrate and change as possible.
+
 ### Features
 
 - Basic routing (get, post, put, delete) with support for custom multiple verbs.
@@ -28,12 +27,10 @@ Add the latest version pf Simple PHP Router to your ```composer.json```
 - Namespaces.
 - Route prefixes.
 - CSRF protection.
-
-### Features currently "in-the-works"
-
-- Global Constraints
-- Sub-Domain Routing
 - Optional parameters
+- Sub-domain routing
+- Custom boot managers to redirect urls to other routes
+- Input manager; to manage `GET`, `POST` params.
 
 ## Initialising the router
 
@@ -42,7 +39,7 @@ In your ```index.php``` require your ```routes.php``` and call the ```routeReque
 This is an example of a basic ```index.php``` file:
 
 ```php
-use \Pecee\SimpleRouter;
+use \Pecee\SimpleRouter\SimpleRouter;
 
 require_once 'routes.php'; // change this to whatever makes sense in your project
 
@@ -50,7 +47,7 @@ require_once 'routes.php'; // change this to whatever makes sense in your projec
 $defaultControllerNamespace = 'MyWebsite\\Controller';
 
 // Do the routing
-SimpleRouter::init($defaultControllerNamespace);
+SimpleRouter::start($defaultControllerNamespace);
 ```
 
 ## Adding routes
@@ -59,6 +56,9 @@ This router is heavily inspired by the Laravel 5.* router, so anything you find
 
 ### Basic example
 
+- ExceptionsHandlers must implement the `IExceptionHandler` interface.
+- Middlewares must implement the `IMiddleware` interface.
+
 ```php
 use Pecee\SimpleRouter\SimpleRouter;
 
@@ -70,20 +70,25 @@ use Pecee\SimpleRouter\SimpleRouter;
  * the request, for instance if a user is not authenticated.
  */
 
+// Add CSRF support (if needed)
+SimpleRouter::csrfVerifier(new \Pecee\Http\Middleware\BaseCsrfVerifier());
+
 SimpleRouter::group(['prefix' => 'v1', 'middleware' => '\MyWebsite\Middleware\SomeMiddlewareClass'], function() {
 
-    SimpleRouter::group(['prefix' => 'services'], function() {
+    SimpleRouter::group(['prefix' => '/services', 'exceptionHandler' => '\MyProject\Handler\CustomExceptionHandler'], function() {
 
-        SimpleRouter::get('/answers/{id}', 'ControllerAnswers@show')
-        ->where(['id' => '[0-9]+');
+        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: /ajax/music/world -> ControllerAjax@process (parameter: music/world)
+         * For example route: domain.com/ajax/music/world -> ControllerAjax@process (parameter: music/world)
          */
-        SimpleRouter::all('/ajax', 'ControllerAjax@process')->match('ajax\\/([A-Za-z0-9\\/]+)');
+        SimpleRouter::all('/ajax', 'ControllerAjax@process')->match('.*?\\/ajax\\/([A-Za-z0-9\\/]+)');
 
-        // Resetful resource
+        // Restful resource
         SimpleRouter::resource('/rest', 'ControllerRessource');
 
         // Load the entire controller (where url matches method names - getIndex(), postIndex() etc)
@@ -98,6 +103,20 @@ SimpleRouter::group(['prefix' => 'v1', 'middleware' => '\MyWebsite\Middleware\So
 });
 ```
 
+### Sub-domain routing
+
+Route groups may also be used to route wildcard sub-domains. Sub-domains may be assigned route parameters just like route URIs, allowing you to capture a portion of the sub-domain for usage in your route or controller. The sub-domain may be specified using the ```domain``` key on the group attribute array:
+
+```php
+Route::group(['domain' => '{account}.myapp.com'], function () {
+    Route::get('user/{id}', function ($account, $id) {
+        //
+    });
+});
+```
+
+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
 
 The ```SimpleRouter``` class referenced in the previous example, is just a simple helper class that knows how to communicate with the ```RouterBase``` class.
@@ -129,53 +148,47 @@ The framework has it's own ```Router``` class which inherits from the ```SimpleR
 namespace MyProject;
 
 use Pecee\Handler\ExceptionHandler;
+use Pecee\SimpleRouter\RouterBase;
 use Pecee\SimpleRouter\SimpleRouter;
 
 class Router extends SimpleRouter {
 
-    protected static $exceptionHandlers = array();
+    protected static $defaultExceptionHandler;
 
-    public static function start() {
-
-        Debug::getInstance()->add('Router initialised.');
+    public static function start($defaultNamespace = null) {
 
         // Load routes.php
-        $file = $_ENV['basePath'] . DIRECTORY_SEPARATOR . 'lib' . DIRECTORY_SEPARATOR . 'routes.php';
+        $file = $_ENV['base_path'] . DIRECTORY_SEPARATOR . 'lib' . DIRECTORY_SEPARATOR . 'routes.php';
         if(file_exists($file)) {
             require_once $file;
         }
 
-        // Init locale settings
-        Locale::getInstance();
-
-        // Set default namespace for routes
-        $defaultNamespace = '\\'.Registry::getInstance()->get('AppName') . '\\Controller';
-        
-        // Add custom csrf verifier (must extend BaseCsrfVerifier)
-        parent::csrfVerifier('MyProject\Middleware\CustomCsrfVerifier');
+        // Set default namespace
+        $defaultNamespace = '\\'.$_ENV['app_name'] . '\\Controller';
 
         // Handle exceptions
         try {
             parent::start($defaultNamespace);
         } catch(\Exception $e) {
-            /* @var $handler ExceptionHandler */
-            foreach(self::$exceptionHandlers as $handler) {
-                $class = new $handler();
-                $class->handleError($e);
+
+            if(self::$defaultExceptionHandler !== null) {
+                $class = new self::$defaultExceptionHandler();
+                $class->handleError(RouterBase::getInstance()->getRequest(), $route, $e);
             }
 
             throw $e;
         }
     }
 
-    public static function addExceptionHandler($handler) {
-        self::$exceptionHandlers[] = $handler;
+    public static function setDefaultExceptionHandler($handler) {
+        self::$defaultExceptionHandler = $handler;
     }
 
 }
 ```
 
-This is a basic example of a helper function for generating urls.
+#### Helper functions examples
+**This is a basic example of a helper function for generating urls.**
 
 ```php
 use Pecee\SimpleRouter\RouterBase;
@@ -184,7 +197,7 @@ function url($controller, $parameters = null, $getParams = null) {
 }
 ```
 
-This is a basic example for getting the current csrf token
+**This is a basic example for getting the current csrf token**
 
 ```php
 /**
@@ -241,6 +254,153 @@ Register the new class in your ```routes.php```, custom ```Router``` class or wh
 SimpleRouter::csrfVerifier(new \Demo\Middleware\CsrfVerifier());
 ```
 
+## Using router bootmanager to make custom rewrite rules
+
+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```).
+
+```php
+
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\RouterBootManager;
+
+class CustomRouterRules extends RouterBootManager{
+
+    public function boot(Request $request) {
+
+        $rewriteRules = [
+            '/my-cat-is-beatiful' => '/article/view/1',
+            '/horses-are-great' => '/article/view/2'
+        ];
+
+        foreach($rewriteRules as $url => $rule) {
+
+            // If the current uri matches the url, we use our custom route
+
+            if($request->getUri() === $url) {
+                $request->setUri($rule);
+            }
+        }
+
+        return $request;
+    }
+
+}
+
+```
+
+The above should be pretty self-explanatory and can easily be changed to loop through urls store in the database, file or cache.
+
+What happens is that if the current route matches the route defined in the index of our ```$rewriteRules``` array, we set the route to the array value instead.
+
+By doing this the route will now load the url ```/article/view/1``` instead of ```/my-cat-is-beatiful```.
+
+The last thing we need to do, is to add our custom boot-manager to the ```routes.php``` file. You can create as many bootmanagers as you like and easily add them in your ```routes.php``` file.
+
+**routes.php example:**
+
+```php
+// Add new bootmanager
+SimpleRouter::addBootManager(new CustomRouterRules());
+
+// This rule is what our custom bootmanager will use.
+SimpleRouter::get('/article/view/{id}', 'ControllerArticle@view');
+```
+
+## Easily overwrite route about to be loaded
+Sometimes it can be useful to manipulate the route that's about to be loaded, for instance if a user is not authenticated or if an error occurred within your Middleware that requires
+some other route to be initialised. 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\Http\Request``` object.
+
+**Note:** Please note that it's only possible to change the route BEFORE any route has initially been loaded, so doing this in your custom ExceptionHandler or Middleware is highly recommended.
+
+```php
+$route = Request::getInstance()->getLoadedRoute();
+
+$route->setCallback('Example\MyCustomClass@hello');
+
+// -- or --
+
+$route->setClass('Example\MyCustomClass');
+$route->setMethod('hello');
+```
+
+## Using the Input class to manage parameters
+
+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 = Request::getInstance()->getInput()->get('name');
+```
+
+**Return parameter object (matches both GET, POST, FILE):**
+```php
+$object = Request::getInstance()->getInput()->getObject('name');
+```
+
+**Return specific GET parameter (where name is the name of your parameter):**
+```php
+$object = Request::getInstance()->getInput()->get->name;
+$object = Request::getInstance()->getInput()->post->name;
+$object = Request::getInstance()->getInput()->file->name;
+```
+
+**Return all parameters:**
+```php
+// Get all
+$objects = Request::getInstance()->getInput()->all();
+
+// Only match certain keys
+$objects = Request::getInstance()->getInput()->all([
+    'company_name',
+    'user_id'
+]);
+```
+
+All object inherits from `InputItem` class and will always contain these methods:
+- `getValue()` - returns the value of the input.
+- `getIndex()` - returns the index/key of the input.
+- `getName()` - returns a human friendly name for the input (company_name will be Company Name etc).
+
+`InputFile` has the same methods as above along with some other file-specific methods like:
+- `getTmpName()` - get file temporary name.
+- `getSize()` - get file size.
+- `move($destination)` - move file to destination.
+- `getContents()` - get file content.
+- `getType()` - get mime-type for file.
+- `getError()` - get file upload error.
+
+
+### Easy access your input
+Create a helper function to easily get access to the input elements.
+
+Example:
+
+```php
+/**
+ * Get input class
+ * @return \Pecee\Http\Input\Input
+ */
+function input() {
+    return \Pecee\Http\Request::getInstance()->getInput();
+}
+```
+
+Then you can easily do something like this in your controller:
+
+```php
+// Get parameter site_id or default-value 2
+$value = input()->get('site_id', '2');
+```
+
+## Sites
+This is some sites that uses the simple-router project in production.
+
+- [holla.dk](http://www.holla.dk)
+- [ninjaimg.com](http://ninjaimg.com)
+
 ## Documentation
 While I work on a better documentation, please refer to the Laravel 5 routing documentation here:
 
@@ -249,9 +409,12 @@ http://laravel.com/docs/5.1/routing
 ## Easily extendable
 The router can be easily extended to customize your needs.
 
+## Ideas and issues
+If you want a great new feature or experience any issues what-so-ever, please feel free to leave an issue and i'll look into it whenever possible.
+
 ## The MIT License (MIT)
 
-Copyright (c) 2015 Simon Sessing� / simple-php-router
+Copyright (c) 2016 Simon Sessingø / simple-php-router
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

composer.json

@@ -13,7 +13,7 @@
         }
 	],
 	"require": {
-
+		"php": ">=5.4.0"
     },
     "require-dev": {
         "phpunit/phpunit": "4.7.7"

src/Pecee/CsrfToken.php

@@ -7,12 +7,6 @@ class CsrfToken {
 
     protected $token;
 
-    public function __construct() {
-        if($this->getToken() === null) {
-            $this->setToken($this->generateToken());
-        }
-    }
-
     /**
      * Generate random identifier for CSRF token
      * @return string
@@ -43,7 +37,7 @@ class CsrfToken {
      * @param $token
      */
     public function setToken($token) {
-        setcookie(self::CSRF_KEY, $token, time() + 60 * 120, '/');
+        setcookie(static::CSRF_KEY, $token, time() + 60 * 120, '/');
     }
 
     /**
@@ -51,10 +45,18 @@ class CsrfToken {
      * @return string|null
      */
     public function getToken(){
-        if(isset($_COOKIE[self::CSRF_KEY])) {
-            return $_COOKIE[self::CSRF_KEY];
+        if($this->hasToken()) {
+            return $_COOKIE[static::CSRF_KEY];
         }
         return null;
     }
 
+    /**
+     * Returns whether the csrf token has been defined
+     * @return bool
+     */
+    public function hasToken() {
+        return isset($_COOKIE[static::CSRF_KEY]);
+    }
+
 }

src/Pecee/Exception/RouterException.php

@@ -1,3 +1,3 @@
 <?php
-namespace Pecee\SimpleRouter;
+namespace Pecee\Exception;
 class RouterException extends \Exception { }

src/Pecee/Handler/IExceptionHandler.php

@@ -0,0 +1,11 @@
+<?php
+namespace Pecee\Handler;
+
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\RouterEntry;
+
+interface IExceptionHandler {
+
+	public function handleError(Request $request, RouterEntry $router = null, \Exception $error);
+
+}

src/Pecee/Http/Input/Input.php

@@ -0,0 +1,195 @@
+<?php
+namespace Pecee\Http\Input;
+
+class Input {
+
+    /**
+     * @var \Pecee\Http\Input\InputCollection
+     */
+    public $get;
+
+    /**
+     * @var \Pecee\Http\Input\InputCollection
+     */
+    public $post;
+
+    /**
+     * @var \Pecee\Http\Input\InputCollection
+     */
+    public $file;
+
+    public function __construct() {
+        $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 = $this->get->getData();
+        $output = array_merge($output, $this->post->getData());
+
+        if($filter !== null) {
+            $tmp = array();
+            foreach($output as $key => $val) {
+                if(in_array($key, $filter)) {
+                    $tmp[$key] = $val;
+                }
+            }
+            return $tmp;
+        }
+
+        return $output;
+    }
+
+    public function getObject($index, $default = null) {
+        $index = (strpos($index, '[') > -1) ? substr($index, 0, strpos($index, '[')) : $index;
+
+        $element = $this->get->findFirst($index);
+
+        if($element !== null) {
+            return $element;
+        }
+
+        if(request()->getMethod() !== 'get') {
+
+            $element = $this->post->findFirst($index);
+
+            if ($element !== null) {
+                return $element;
+            }
+
+            $element = $this->file->findFirst($index);
+            if ($element !== null) {
+                return $element;
+            }
+        }
+
+        return $default;
+    }
+
+    /**
+     * Get input element value matching index
+     * @param string $index
+     * @param string|null $default
+     * @return string|null
+     */
+    public function get($index, $default = null) {
+
+        $key = (strpos($index, '[') > -1) ? substr($index, strpos($index, '[')+1, strpos($index, ']') - strlen($index)) : null;
+        $index = (strpos($index, '[') > -1) ? substr($index, 0, strpos($index, '[')) : $index;
+
+        $item = $this->getObject($index);
+
+        if($item !== null) {
+
+            if($item instanceof InputFile) {
+                return $item;
+            }
+
+            if (is_array($item->getValue())) {
+                return ($key !== null && isset($item->getValue()[$key])) ? $item->getValue()[$key] : $item->getValue();
+            }
+
+            return (trim($item->getValue()) === '') ? $default : $item->getValue();
+        }
+
+        return $default;
+    }
+
+    public function setGet() {
+        $this->get = new InputCollection();
+
+        if(count($_GET)) {
+            foreach($_GET as $key => $get) {
+                if(!is_array($get)) {
+                    $this->get->{$key} = new InputItem($key, $get);
+                    continue;
+                }
+
+                $output = array();
+
+                foreach($get as $k => $g) {
+                    $output[$k] = new InputItem($k, $g);
+                }
+
+                $this->get->{$key} = new InputItem($key, $output);
+            }
+        }
+    }
+
+    public function setPost() {
+        $this->post = new InputCollection();
+
+        $postVars = array();
+
+        if(in_array($_SERVER['REQUEST_METHOD'], ['PUT', 'PATCH', 'DELETE'])) {
+            parse_str(file_get_contents('php://input'), $postVars);
+        } else {
+            $postVars = $_POST;
+        }
+
+        if(count($postVars)) {
+
+            foreach($postVars as $key => $post) {
+                if(!is_array($post)) {
+                    $this->post->{strtolower($key)} = new InputItem($key, $post);
+                    continue;
+                }
+
+                $output = array();
+
+                foreach($post as $k=>$p) {
+                    $output[$k] = new InputItem($k, $p);
+                }
+
+                $this->post->{strtolower($key)} = new InputItem($key, $output);
+            }
+        }
+    }
+
+    public function setFile() {
+        $this->file = new InputCollection();
+
+        if(count($_FILES)) {
+            foreach($_FILES as $key => $value) {
+                // Multiple files
+                if(!is_array($value['name'])) {
+                    // Strip empty values
+                    if($value['error'] != '4') {
+                        $file = new InputFile($key);
+                        $file->setName($value['name']);
+                        $file->setSize($value['size']);
+                        $file->setType($value['type']);
+                        $file->setTmpName($value['tmp_name']);
+                        $file->setError($value['error']);
+                        $this->file->{strtolower($key)} = $file;
+                    }
+                    continue;
+                }
+
+                $output = array();
+
+                foreach($value['name'] as $k=>$val) {
+                    // Strip empty values
+                    if($value['error'][$k] != '4') {
+                        $file = new InputFile($k);
+                        $file->setName($value['name'][$k]);
+                        $file->setSize($value['size'][$k]);
+                        $file->setType($value['type'][$k]);
+                        $file->setTmpName($value['tmp_name'][$k]);
+                        $file->setError($value['error'][$k]);
+                        $output[$k] = $file;
+                    }
+                }
+
+                $this->file->{strtolower($key)} = new InputItem($key, $output);
+            }
+        }
+    }
+
+}

src/Pecee/Http/Input/InputCollection.php

@@ -0,0 +1,67 @@
+<?php
+namespace Pecee\Http\Input;
+
+class InputCollection implements \IteratorAggregate {
+
+    protected $data = array();
+
+    /**
+     * Search for input element matching index.
+     * Useful for searching for finding items where $index doesn't contain form name.
+     *
+     * @param string $index
+     * @return mixed
+     */
+    public function findFirst($index) {
+        if(count($this->data)) {
+
+            if(isset($this->data[$index])) {
+                return $this->data[$index];
+            }
+
+            foreach($this->data as $key => $value) {
+                if(strtolower($index) === strtolower($key)) {
+                    return $value;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @param $index
+     * @throws \InvalidArgumentException
+     * @return InputItem
+     */
+    public function __get($index) {
+        $item = $this->findFirst($index);
+        // Ensure that item are always available
+        if($item === null) {
+            $this->data[$index] = new InputItem($index, null);
+            return $this->data[$index];
+        }
+
+        return $item;
+    }
+
+    public function __set($index, $value) {
+        $this->data[$index] = $value;
+    }
+
+    public function getData() {
+        return $this->data;
+    }
+
+    /**
+     * Retrieve an external iterator
+     * @link http://php.net/manual/en/iteratoraggregate.getiterator.php
+     * @return \Traversable An instance of an object implementing <b>Iterator</b> or
+     * <b>Traversable</b>
+     * @since 5.0.0
+     */
+    public function getIterator() {
+        return new \ArrayIterator($this->data);
+    }
+
+}

src/Pecee/Http/Input/InputFile.php

@@ -0,0 +1,68 @@
+<?php
+namespace Pecee\Http\Input;
+
+class InputFile extends InputItem {
+
+	protected $name;
+	protected $size;
+	protected $type;
+	protected $error;
+	protected $tmpName;
+
+	/**
+	 * @return string
+	 */
+	public function getSize() {
+		return $this->size;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getType() {
+		return $this->type;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getError() {
+		return $this->error;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getTmpName() {
+		return $this->tmpName;
+	}
+
+    public function getExtension() {
+		return pathinfo($this->getName(), PATHINFO_EXTENSION);
+    }
+
+	public function move($destination) {
+		return move_uploaded_file($this->tmpName, $destination);
+	}
+
+	public function getContents() {
+		return file_get_contents($this->tmpName);
+	}
+
+    public function setTmpName($name) {
+        $this->tmpName = $name;
+    }
+
+    public function setSize($size) {
+        $this->size = $size;
+    }
+
+    public function setType($type) {
+        $this->type = $type;
+    }
+
+    public function setError($error) {
+        $this->error = $error;
+    }
+
+}

src/Pecee/Http/Input/InputItem.php

@@ -0,0 +1,53 @@
+<?php
+namespace Pecee\Http\Input;
+
+class InputItem {
+
+    protected $index;
+    protected $name;
+    protected $value;
+
+    public function __construct($index, $value = null) {
+        $this->index = $index;
+        $this->value = $value;
+
+        // Make the name human friendly, by replace _ with space
+        $this->name = ucfirst(str_replace('_', ' ', $this->index));
+    }
+
+    /**
+     * @return array
+     */
+    public function getName() {
+        return $this->name;
+    }
+
+    /**
+     * @return array
+     */
+    public function getValue() {
+        return $this->value;
+    }
+
+    /**
+     * @return string
+     */
+    public function getIndex() {
+        return $this->index;
+    }
+
+    /**
+     * Set input name
+     * @param string $name
+     * @return static $this
+     */
+    public function setName($name) {
+        $this->name = $name;
+        return $this;
+    }
+
+    public function __toString() {
+        return (string)$this->getValue();
+    }
+
+}

src/Pecee/Http/Middleware/BaseCsrfVerifier.php

@@ -12,10 +12,13 @@ class BaseCsrfVerifier implements IMiddleware {
 
     protected $except;
     protected $csrfToken;
-
+    protected $token;
 
     public function __construct() {
         $this->csrfToken = new CsrfToken();
+
+        // Generate or get the CSRF-Token from Cookie.
+        $this->token = (!$this->hasToken()) ? $this->generateToken() : $this->csrfToken->getToken();
     }
 
     /**
@@ -50,14 +53,14 @@ class BaseCsrfVerifier implements IMiddleware {
 
         if($request->getMethod() != 'get' && !$this->skip($request)) {
 
-            $token = (isset($_POST[self::POST_KEY])) ? $_POST[self::POST_KEY] : null;
+            $token = (isset($_POST[static::POST_KEY])) ? $_POST[static::POST_KEY] : null;
 
             // If the token is not posted, check headers for valid x-csrf-token
             if($token === null) {
-                $token = $request->getHeader(self::HEADER_KEY);
+                $token = $request->getHeader(static::HEADER_KEY);
             }
 
-            if( !$this->csrfToken->validate( $token ) ) {
+            if( !$this->csrfToken->validate($token) ) {
                 throw new TokenMismatchException('Invalid csrf-token.');
             }
 
@@ -65,4 +68,22 @@ class BaseCsrfVerifier implements IMiddleware {
 
     }
 
+    public function generateToken() {
+        $token = $this->csrfToken->generateToken();
+        $this->csrfToken->setToken($token);
+        return $token;
+    }
+
+    public function hasToken() {
+        if($this->token != null) {
+            return true;
+        }
+
+        return $this->csrfToken->hasToken();
+    }
+
+    public function getToken() {
+        return $this->token;
+    }
+
 }

src/Pecee/Http/Request.php

@@ -1,15 +1,13 @@
 <?php
 namespace Pecee\Http;
 
+use Pecee\Http\Input\Input;
+
 class Request {
 
     protected static $instance;
 
     protected $data;
-    protected $uri;
-    protected $host;
-    protected $method;
-    protected $headers;
 
     /**
      * Return new instance
@@ -27,10 +25,24 @@ class Request {
         $this->host = $_SERVER['HTTP_HOST'];
         $this->uri = $_SERVER['REQUEST_URI'];
         $this->method = (isset($_POST['_method'])) ? strtolower($_POST['_method']) : strtolower($_SERVER['REQUEST_METHOD']);
-        $this->headers = array_change_key_case(getallheaders(), CASE_LOWER);
+        $this->headers = $this->getAllHeaders();
+        $this->input = new Input();
+    }
+
+    protected function getAllHeaders() {
+        $headers = array();
+        foreach ($_SERVER as $name => $value) {
+            if (substr($name, 0, 5) === 'HTTP_') {
+                $headers[strtolower(str_replace('_', '-', substr($name, 5)))] = $value;
+            }
+        }
+        return $headers;
     }
 
     public function getIsSecure() {
+        if(isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) === 'https') {
+            return true;
+        }
         return isset($_SERVER['HTTPS']) ? true : (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] === 443);
     }
 
@@ -84,7 +96,7 @@ class Request {
      * @return string
      */
     public function getIp() {
-        return isset($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR'];
+        return ((isset($_SERVER['HTTP_X_FORWARDED_FOR']) && strlen($_SERVER['HTTP_X_FORWARDED_FOR'])) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR']);
     }
 
     /**
@@ -113,13 +125,22 @@ class Request {
     }
 
     /**
-     * Get request input or default value
-     * @param string $name
-     * @param string $defaultValue
-     * @return mixed
+     * Get input class
+     * @return Input
      */
-    public function getInput($name, $defaultValue) {
-        return (isset($_REQUEST[$name]) ? $_REQUEST[$name] : $defaultValue);
+    public function getInput() {
+        return $this->input;
+    }
+
+    public function isFormatAccepted($format) {
+        return (isset($_SERVER['HTTP_ACCEPT']) && stripos($_SERVER['HTTP_ACCEPT'], $format) > -1);
+    }
+
+    public function getAcceptFormats() {
+        if(isset($_SERVER['HTTP_ACCEPT'])) {
+            return explode(',', $_SERVER['HTTP_ACCEPT']);
+        }
+        return array();
     }
 
     public function __set($name, $value = null) {
@@ -130,4 +151,33 @@ class Request {
         return isset($this->data[$name]) ? $this->data[$name] : null;
     }
 
+    /**
+     * Get the currently loaded route.
+     * @return \Pecee\SimpleRouter\RouterEntry
+     */
+    public function getLoadedRoute() {
+        return $this->loadedRoute;
+    }
+
+    /**
+     * @param mixed $uri
+     */
+    public function setUri($uri) {
+        $this->uri = $uri;
+    }
+
+    /**
+     * @param mixed $host
+     */
+    public function setHost($host) {
+        $this->host = $host;
+    }
+
+    /**
+     * @param mixed $method
+     */
+    public function setMethod($method) {
+        $this->method = $method;
+    }
+
 }

src/Pecee/Http/Response.php

@@ -19,14 +19,19 @@ class Response {
      * Redirect the response
      *
      * @param string $url
+     * @param int $httpCode
      */
-    public function redirect($url) {
-        $this->header('Location: ' . $url);
+    public function redirect($url, $httpCode = null) {
+        if($httpCode !== null) {
+            $this->httpCode($httpCode);
+        }
+
+        $this->header('location: ' . $url);
         die();
     }
 
     public function refresh() {
-        $this->redirect(url());
+        $this->redirect(Request::getInstance()->getUri());
     }
 
     /**
@@ -42,12 +47,24 @@ class Response {
         return $this;
     }
 
-    public function cache($duration = 2592000) {
+    public function cache($eTag, $lastModified = 2592000) {
+
         $this->headers([
-            'Cache-Control: public,max-age='.$duration.',must-revalidate',
-            'Expires: '.gmdate('D, d M Y H:i:s',(time()+$duration)).' GMT',
-            'Last-modified: '.gmdate('D, d M Y H:i:s',time()).' GMT'
+            'Cache-Control: public',
+            'Last-Modified: ' . gmdate("D, d M Y H:i:s", $lastModified) . ' GMT',
+            '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) {
+
+            $this->headers([
+                'HTTP/1.1 304 Not Modified'
+            ]);
+
+            exit();
+        }
+
         return $this;
     }
 

src/Pecee/SimpleRouter/IRouteEntry.php

@@ -1,7 +0,0 @@
-<?php
-
-namespace Pecee\SimpleRouter;
-
-interface IRouteEntry {
-
-}

src/Pecee/SimpleRouter/RouterBase.php

@@ -1,10 +1,10 @@
 <?php
 namespace Pecee\SimpleRouter;
 
-use Pecee\ArrayUtil;
+use Pecee\Exception\RouterException;
+use Pecee\Handler\IExceptionHandler;
 use Pecee\Http\Middleware\BaseCsrfVerifier;
 use Pecee\Http\Request;
-use Pecee\Url;
 
 class RouterBase {
 
@@ -15,99 +15,148 @@ class RouterBase {
     protected $routes;
     protected $processedRoutes;
     protected $controllerUrlMap;
-    protected $backstack;
-    protected $loadedRoute;
+    protected $backStack;
     protected $defaultNamespace;
+    protected $bootManagers;
     protected $baseCsrfVerifier;
+    protected $middlewaresToLoad;
 
-    // TODO: make interface for controller routers, so they can be easily detected
     // TODO: clean up - cut some of the methods down to smaller pieces
 
     public function __construct() {
-        $this->routes = array();
-        $this->backstack = array();
-        $this->controllerUrlMap = array();
         $this->request = Request::getInstance();
-        $this->baseCsrfVerifier = new BaseCsrfVerifier();
+        $this->routes = array();
+        $this->backStack = array();
+        $this->controllerUrlMap = array();
+        $this->bootManagers = array();
+        $this->middlewaresToLoad = array();
     }
 
     public function addRoute(RouterEntry $route) {
         if($this->currentRoute !== null) {
-            $this->backstack[] = $route;
+            $this->backStack[] = $route;
         } else {
             $this->routes[] = $route;
         }
     }
 
-    protected function processRoutes(array $routes, array $settings = array(), array $prefixes = array(), $backstack = false) {
+    protected function processRoutes(array $routes, array $settings = array(), array $prefixes = array(), $backStack = false, $group = null) {
         // Loop through each route-request
 
+        $routesCount = count($routes);
+        $mergedSettings = array();
+
         /* @var $route RouterEntry */
-        foreach($routes as $route) {
+        for($i = 0; $i < $routesCount; $i++) {
+
+            $route = $routes[$i];
+
+            $route->addSettings($settings);
+
+            if($backStack) {
+                $route->setGroup($group);
+            }
 
             if($this->defaultNamespace && !$route->getNamespace()) {
-                $namespace = null;
+                $namespace = $this->defaultNamespace;
                 if ($route->getNamespace()) {
-                    $namespace = $this->defaultNamespace . '\\' . $route->getNamespace();
-                } else {
-                    $namespace = $this->defaultNamespace;
+                    $namespace .= '\\' . $route->getNamespace();
                 }
 
                 $route->setNamespace($namespace);
             }
 
             $newPrefixes = $prefixes;
-            $mergedSettings = array_merge($settings, $route->getMergeableSettings());
 
-            if($route->getPrefix()) {
-                array_push($newPrefixes, rtrim($route->getPrefix(), '/'));
+            if($route->getPrefix() && trim($route->getPrefix(), '/') !== '') {
+                array_push($newPrefixes, trim($route->getPrefix(), '/'));
             }
-            $route->addSettings($mergedSettings);
 
             if(!($route instanceof RouterGroup)) {
-                if(is_array($newPrefixes) && count($newPrefixes) && $backstack) {
-                    $route->setUrl( join('/', $newPrefixes) . $route->getUrl() );
+                if(is_array($newPrefixes) && count($newPrefixes) && $backStack) {
+                    $route->setUrl( '/' . join('/', $newPrefixes) . $route->getUrl() );
                 }
 
+                $group = null;
                 $this->controllerUrlMap[] = $route;
             }
 
             $this->currentRoute = $route;
+
             if($route instanceof RouterGroup && is_callable($route->getCallback())) {
+                $group = $route;
+
                 $route->renderRoute($this->request);
+                $mergedSettings = array_merge($settings, $route->getMergeableSettings());
+
+                // Load middleware on group if route matches
+                if($route->getPrefix() !== null && $route->matchRoute($this->request)) {
+                    $this->middlewaresToLoad[] = $route;
+                }
             }
+
             $this->currentRoute = null;
 
-            if(count($this->backstack)) {
-                $backstack = $this->backstack;
-                $this->backstack = array();
+            if(count($this->backStack)) {
+                $backStack = $this->backStack;
+                $this->backStack = array();
 
                 // Route any routes added to the backstack
-                $this->processRoutes($backstack, $mergedSettings, $newPrefixes, true);
+                $this->processRoutes($backStack, $mergedSettings, $newPrefixes, true, $group);
             }
         }
     }
 
     public function routeRequest() {
 
+        $originalUri = $this->request->getUri();
+
+        // Initialize boot-managers
+        if(count($this->bootManagers)) {
+            /* @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.');
+                }
+            }
+        }
+
         // Verify csrf token for request
         if($this->baseCsrfVerifier !== null) {
-            /* @var $csrfVerifier BaseCsrfVerifier */
-            $csrfVerifier = $this->baseCsrfVerifier;
-            $csrfVerifier = new $csrfVerifier();
-            $csrfVerifier->handle($this->request);
+            $this->baseCsrfVerifier->handle($this->request);
         }
 
         // Loop through each route-request
         $this->processRoutes($this->routes);
 
+        // Load group middlewares
+        /* @var $route RouterEntry */
+        foreach($this->middlewaresToLoad as $route) {
+            $route->loadMiddleware($this->request);
+        }
+
         $routeNotAllowed = false;
 
+        // Make sure routes with longer urls are rendered first
+        usort($this->controllerUrlMap, function($a, $b) {
+            if(strlen($a->getUrl()) < strlen($b->getUrl())) {
+                return 1;
+            }
+            return -1;
+        });
+
+        $max = count($this->controllerUrlMap);
+
         /* @var $route RouterEntry */
-        foreach($this->controllerUrlMap as $route) {
+        for($i = 0; $i < $max; $i++) {
+
+            $route = $this->controllerUrlMap[$i];
+
             $routeMatch = $route->matchRoute($this->request);
 
-            if($routeMatch && !($routeMatch instanceof RouterGroup)) {
+            if($routeMatch) {
 
                 if(count($route->getRequestMethods()) && !in_array($this->request->getMethod(), $route->getRequestMethods())) {
                     $routeNotAllowed = true;
@@ -116,22 +165,44 @@ class RouterBase {
 
                 $routeNotAllowed = false;
 
-                $this->loadedRoute = $routeMatch;
-                $routeMatch->loadMiddleware($this->request);
-                $routeMatch->renderRoute($this->request);
+                $this->request->rewrite_uri = $this->request->uri;
+                $this->request->setUri($originalUri);
+
+                $this->request->loadedRoute = $route;
+                $route->loadMiddleware($this->request);
+
+                try {
+                    $this->request->loadedRoute->renderRoute($this->request);
+                } catch(\Exception $e) {
+                    $this->handleException($e);
+                }
+
                 break;
             }
         }
 
         if($routeNotAllowed) {
-            throw new RouterException('Route or method not allowed', 403);
+            $this->handleException(new RouterException('Route or method not allowed', 403));
         }
 
-        if(!$this->loadedRoute) {
+        if(!$this->request->loadedRoute) {
             throw new RouterException(sprintf('Route not found: %s', $this->request->getUri()), 404);
         }
     }
 
+    protected function handleException(\Exception $e) {
+        if($this->request->loadedRoute !== null && $this->request->loadedRoute->exceptionHandler !== null) {
+            $handler = new $this->request->loadedRoute->exceptionHandler();
+            if(!($handler instanceof IExceptionHandler)) {
+                throw new RouterException('Exception handler must implement the IExceptionHandler interface.');
+            }
+
+            $handler->handleError($this->request, $this->request->loadedRoute, $e);
+        }
+
+        throw $e;
+    }
+
     /**
      * @return string
      */
@@ -141,17 +212,37 @@ class RouterBase {
 
     /**
      * @param string $defaultNamespace
+     * @return static
      */
     public function setDefaultNamespace($defaultNamespace) {
         $this->defaultNamespace = $defaultNamespace;
+        return $this;
+    }
+
+    /**
+     * @return array
+     */
+    public function getBootManagers() {
+        return $this->bootManagers;
+    }
+
+    /**
+     * @param array $bootManagers
+     */
+    public function setBootManagers(array $bootManagers) {
+        $this->bootManagers = $bootManagers;
+    }
+
+    public function addBootManager(RouterBootManager $bootManager) {
+        $this->bootManagers[] = $bootManager;
     }
 
     /**
      * @return RouterEntry
      */
     public function getLoadedRoute() {
-        if(!($this->loadedRoute instanceof RouterGroup)) {
-            return $this->loadedRoute;
+        if(!($this->request->loadedRoute instanceof RouterGroup)) {
+            return $this->request->loadedRoute;
         }
         return null;
     }
@@ -160,7 +251,7 @@ class RouterBase {
      * @return array
      */
     public function getBackstack() {
-        return $this->backstack;
+        return $this->backStack;
     }
 
     /**
@@ -205,9 +296,34 @@ class RouterBase {
         return $this;
     }
 
-    protected function processUrl($route, $method = null, $parameters = null, $getParams = null) {
+    public function arrayToParams(array $getParams = null, $includeEmpty = true) {
+        if (is_array($getParams) && count($getParams) > 0) {
+            foreach ($getParams as $key => $val) {
+                if (!empty($val) || $includeEmpty) {
+                    $getParams[$key] = (is_array($val) ? $this->arrayToParams($val, $includeEmpty) : $key . '=' . $val);
+                }
+            }
+            return join('&', $getParams);
+        }
+        return '';
+    }
 
-        $url = '/' . trim($route->getUrl(), '/');
+    protected function processUrl(RouterRoute $route, $method = null, $parameters = null, $getParams = null) {
+
+        $domain = '';
+
+        if($route->getGroup() !== null && $route->getGroup()->getDomain() !== null) {
+            if(is_array($route->getGroup()->getDomain())) {
+                $domains = $route->getGroup()->getDomain();
+                $domain = array_shift($domains);
+            } else {
+                $domain = $route->getGroup()->getDomain();
+            }
+
+            $domain = '//' . $domain;
+        }
+
+        $url = $domain . '/' . trim($route->getUrl(), '/');
 
         if(($route instanceof RouterController || $route instanceof RouterResource) && $method !== null) {
             $url .= $method;
@@ -219,26 +335,32 @@ class RouterBase {
             }
         } else {
             /* @var $route RouterEntry */
-            $params = $route->getParameters();
-            if(count($params)) {
-                $i = 0;
-                foreach($params as $param => $value) {
-                    $value = (isset($parameters[$param])) ? $parameters[$param] : $value;
-                    $url = str_ireplace('{' . $param. '}', $value, $url);
-                    $i++;
-                }
+            if(is_array($parameters)) {
+                $params = array_merge($route->getParameters(), $parameters);
             } else {
-                // If no parameters are specified in the route, assume that the provided parameters should be used.
-                if(count($parameters)) {
-                    $url = rtrim($url, '/') . '/' . join('/', $parameters);
-                }
+                $params = $route->getParameters();
             }
+
+            $otherParams = [];
+
+            $i = 0;
+            foreach($params as $param => $value) {
+                $value = (isset($parameters[$param])) ? $parameters[$param] : $value;
+                if(stripos($url, '{' . $param. '}') !== false || stripos($url, '{' . $param . '?}') !== false) {
+                    $url = str_ireplace(array('{' . $param . '}', '{' . $param . '?}'), $value, $url);
+                } else {
+                    $otherParams[$param] = $value;
+                }
+                $i++;
+            }
+
+            $url = rtrim($url, '/') . '/' . join('/', $otherParams);
         }
 
         $url = rtrim($url, '/') . '/';
 
         if($getParams !== null && count($getParams)) {
-            $url .= '?'.Url::arrayToParams($getParams);
+            $url .= '?' . $this->arrayToParams($getParams);
         }
 
         return $url;
@@ -254,18 +376,36 @@ class RouterBase {
             throw new \InvalidArgumentException('Invalid type for getParams. Must be array or null');
         }
 
-        if($controller === null && $parameters === null && $this->loadedRoute !== null) {
-            return $this->processUrl($this->loadedRoute, null, $getParams);
+        // Return current route if no options has been specified
+        if($controller === null && $parameters === null) {
+            $getParams = (is_array($getParams)) ? array_merge($_GET, $getParams) : $_GET;
+
+            $url = parse_url(Request::getInstance()->getUri());
+            $url = $url['path'];
+
+            if(count($getParams)) {
+                $url .= '?' . $this->arrayToParams($getParams);
+            }
+
+            return $url;
+        }
+
+        if($controller === null && $this->request->loadedRoute !== null) {
+            return $this->processUrl($this->request->loadedRoute, $this->request->loadedRoute->getMethod(), $parameters, $getParams);
         }
 
         $c = '';
         $method = null;
 
+        $max = count($this->controllerUrlMap);
+
         /* @var $route RouterRoute */
-        foreach($this->controllerUrlMap as $route) {
+        for($i = 0; $i < $max; $i++) {
+
+            $route = $this->controllerUrlMap[$i];
 
             // Check an alias exist, if the matches - use it
-            if($route instanceof RouterRoute && strtolower($route->getAlias()) === strtolower($controller)) {
+            if($route instanceof RouterRoute && $route->hasAlias($controller)) {
                 return $this->processUrl($route, $route->getMethod(), $parameters, $getParams);
             }
 
@@ -283,7 +423,10 @@ class RouterBase {
         $c = '';
 
         // No match has yet been found, let's try to guess what url that should be returned
-        foreach($this->controllerUrlMap as $route) {
+        for($i = 0; $i < $max; $i++) {
+
+            $route = $this->controllerUrlMap[$i];
+
             if($route instanceof RouterRoute && !is_callable($route->getCallback()) && stripos($route->getCallback(), '@') !== false) {
                 $c = $route->getClass();
             } else if($route instanceof RouterController || $route instanceof RouterResource) {
@@ -305,13 +448,15 @@ class RouterBase {
         $url = array($controller);
 
         if(is_array($parameters)) {
-            ArrayUtil::append($url, $parameters);
+            foreach($parameters as $key => $value) {
+                array_push($url,$value);
+            }
         }
 
         $url = '/' . trim(join('/', $url), '/') . '/';
 
-        if(is_array($getParams)) {
-            $url .= '?' . Url::arrayToParams($getParams);
+        if($getParams !== null && count($getParams)) {
+            $url .= '?' . $this->arrayToParams($getParams);
         }
 
         return $url;
@@ -324,4 +469,8 @@ class RouterBase {
         return self::$instance;
     }
 
+    public static function reset() {
+        self::$instance = null;
+    }
+
 }

src/Pecee/SimpleRouter/RouterBootManager.php

@@ -0,0 +1,10 @@
+<?php
+namespace Pecee\SimpleRouter;
+
+use Pecee\Http\Request;
+
+abstract class RouterBootManager {
+
+    abstract public function boot(Request $request);
+
+}

src/Pecee/SimpleRouter/RouterController.php

@@ -1,6 +1,7 @@
 <?php
 namespace Pecee\SimpleRouter;
 
+use Pecee\Exception\RouterException;
 use Pecee\Http\Request;
 
 class RouterController extends RouterEntry {
@@ -38,10 +39,12 @@ class RouterController extends RouterEntry {
 
             return $class;
         }
+
+        return null;
     }
 
     public function matchRoute(Request $request) {
-        $url = parse_url($request->getUri());
+        $url = parse_url(urldecode($request->getUri()));
         $url = rtrim($url['path'], '/') . '/';
 
         if(strtolower($url) == strtolower($this->url) || stripos($url, $this->url) === 0) {
@@ -61,7 +64,7 @@ class RouterController extends RouterEntry {
                 // Set callback
                 $this->setCallback($this->controller . '@' . $this->method);
 
-                return $this;
+                return true;
             }
         }
         return null;
@@ -76,10 +79,12 @@ class RouterController extends RouterEntry {
 
     /**
      * @param string $url
+     * @return static
      */
     public function setUrl($url) {
         $url = rtrim($url, '/') . '/';
         $this->url = $url;
+        return $this;
     }
 
     /**
@@ -91,9 +96,11 @@ class RouterController extends RouterEntry {
 
     /**
      * @param string $controller
+     * @return static
      */
     public function setController($controller) {
         $this->controller = $controller;
+        return $this;
     }
 
     /**
@@ -105,9 +112,11 @@ class RouterController extends RouterEntry {
 
     /**
      * @param string $method
+     * @return static
      */
     public function setMethod($method) {
         $this->method = $method;
+        return $this;
     }
 
 }

src/Pecee/SimpleRouter/RouterEntry.php

@@ -2,6 +2,7 @@
 
 namespace Pecee\SimpleRouter;
 
+use Pecee\Exception\RouterException;
 use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
 
@@ -23,13 +24,12 @@ abstract class RouterEntry {
 
     protected $settings;
     protected $callback;
-    protected $parameters;
 
     public function __construct() {
         $this->settings = array();
         $this->settings['requestMethods'] = array();
-        $this->settings['parametersRegex'] = array();
-        $this->parameters = array();
+        $this->settings['where'] = array();
+        $this->settings['parameters'] = array();
     }
 
     /**
@@ -78,12 +78,22 @@ abstract class RouterEntry {
         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 $prefix
      * @return self
      */
     public function setPrefix($prefix) {
-        $this->prefix = '/' . trim($prefix, '/') . '/';
+        $this->prefix = '/' . ltrim($prefix, '/');
         return $this;
     }
 
@@ -113,7 +123,7 @@ abstract class RouterEntry {
     }
 
     /**
-     * @return string
+     * @return string|array
      */
     public function getMiddleware() {
         return $this->middleware;
@@ -137,7 +147,7 @@ abstract class RouterEntry {
      * @return mixed
      */
     public function getParameters(){
-        return $this->parameters;
+        return ($this->parameters === null) ? array() : $this->parameters;
     }
 
     /**
@@ -156,7 +166,7 @@ abstract class RouterEntry {
      * @return self
      */
     public function where(array $options) {
-        $this->parametersRegex = array_merge($this->parametersRegex, $options);
+        $this->where = array_merge($this->where, $options);
         return $this;
     }
 
@@ -179,10 +189,6 @@ abstract class RouterEntry {
     public function getMergeableSettings() {
         $settings = $this->settings;
 
-        /*if(isset($settings['middleware'])) {
-            unset($settings['middleware']);
-        }*/
-
         if(isset($settings['prefix'])) {
             unset($settings['prefix']);
         }
@@ -216,7 +222,7 @@ abstract class RouterEntry {
     }
 
     /**
-     * Dynamicially access settings value
+     * Dynamically access settings value
      *
      * @param $name
      * @return mixed|null
@@ -243,6 +249,92 @@ abstract class RouterEntry {
         return new $name();
     }
 
+    protected function parseParameters($route, $url, $parameterRegex = '[a-z0-9]+') {
+        $parameterNames = array();
+        $regex = '';
+        $lastCharacter = '';
+        $isParameter = false;
+        $parameter = '';
+
+        $routeLength = strlen($route);
+        for($i = 0; $i < $routeLength; $i++) {
+
+            $character = $route[$i];
+
+            // Skip "/" if we are at the end of a parameter
+            if($lastCharacter === '}' && $character === '/') {
+                $lastCharacter = $character;
+                continue;
+            }
+
+            if($character === '{') {
+                // Remove "/" and "\" from regex
+                if(substr($regex, strlen($regex)-1) === '/') {
+                    $regex = substr($regex, 0, strlen($regex) - 2);
+                }
+
+                $isParameter = true;
+            } elseif($isParameter && $character === '}') {
+                $required = true;
+                // Check for optional parameter
+
+                // Use custom parameter regex if it exists
+                if(is_array($this->where) && isset($this->where[$parameter])) {
+                    $parameterRegex = $this->where[$parameter];
+                }
+
+                if($lastCharacter === '?') {
+                    $parameter = substr($parameter, 0, strlen($parameter)-1);
+                    $regex .= '(?:\\/?(?P<'.$parameter.'>[^\/]+)?\\/?)';
+                    $required = false;
+                } else {
+                    $regex .= '\\/(?P<' . $parameter . '>'. $parameterRegex .')\\/';
+                }
+                $parameterNames[] = array('name' => $parameter, 'required' => $required);
+                $parameter = '';
+                $isParameter = false;
+
+            } elseif($isParameter) {
+                $parameter .= $character;
+            } elseif($character === '/') {
+                $regex .= '\\' . $character;
+            } else {
+                $regex .= str_replace('.', '\\.', $character);
+            }
+
+            $lastCharacter = $character;
+        }
+
+        $parameterValues = array();
+
+        if(preg_match('/^'.$regex.'$/is', $url, $parameterValues)) {
+            $parameters = array();
+
+            $max = count($parameterNames);
+
+            if($max) {
+                for($i = 0; $i < $max; $i++) {
+                    $name = $parameterNames[$i];
+                    $parameterValue = (isset($parameterValues[$name['name']]) && !empty($parameterValues[$name['name']])) ? $parameterValues[$name['name']] : null;
+
+                    if($name['required'] && $parameterValue === null) {
+                        throw new RouterException('Missing required parameter ' . $name['name'], 404);
+                    }
+
+                    if(!$name['required'] && $parameterValue === null) {
+                        continue;
+                    }
+
+                    $parameters[$name['name']] = $parameterValue;
+                }
+            }
+
+            return $parameters;
+        }
+
+        return null;
+    }
+
     public function loadMiddleware(Request $request) {
         if($this->getMiddleware()) {
             if(is_array($this->getMiddleware())) {
@@ -252,7 +344,7 @@ abstract class RouterEntry {
                         throw new RouterException($middleware . ' must be instance of Middleware');
                     }
 
-                    /* @var $class Middleware */
+                    /* @var $class IMiddleware */
                     $middleware->handle($request);
                 }
             } else {
@@ -261,16 +353,14 @@ abstract class RouterEntry {
                     throw new RouterException($this->getMiddleware() . ' must be instance of Middleware');
                 }
 
-                /* @var $class Middleware */
+                /* @var $class IMiddleware */
                 $middleware->handle($request);
             }
         }
     }
 
     public function renderRoute(Request $request) {
-
         if(is_object($this->getCallback()) && is_callable($this->getCallback())) {
-
             // When the callback is a function
             call_user_func_array($this->getCallback(), $this->getParameters());
         } else {
@@ -285,7 +375,11 @@ abstract class RouterEntry {
                 throw new RouterException(sprintf('Method %s does not exist in class %s', $method, $className), 404);
             }
 
-            call_user_func_array(array($class, $method), $this->getParameters());
+            $parameters = array_filter($this->getParameters(), function($var){
+                return !is_null($var);
+            });
+
+            call_user_func_array(array($class, $method), $parameters);
 
             return $class;
         }
@@ -317,6 +411,15 @@ abstract class RouterEntry {
         return $this->settings['requestMethods'];
     }
 
+    public function getGroup() {
+        return $this->group;
+    }
+
+    public function setGroup($group) {
+        $this->group = $group;
+        return $this;
+    }
+
     abstract function matchRoute(Request $request);
 
 }

src/Pecee/SimpleRouter/RouterGroup.php

@@ -2,12 +2,43 @@
 
 namespace Pecee\SimpleRouter;
 
+use Pecee\Exception\RouterException;
 use Pecee\Http\Request;
 
 class RouterGroup extends RouterEntry {
 
-    public function __construct() {
-        parent::__construct();
+    public function matchDomain(Request $request) {
+        if($this->domain !== null) {
+
+            if(is_array($this->domain)) {
+
+                $max = count($this->domain);
+
+                for($i = 0; $i < $max; $i++) {
+                    $domain = $this->domain[$i];
+
+                    $parameters = $this->parseParameters($domain, $request->getHost(), '[^.]*');
+
+                    if($parameters !== null) {
+                        $this->parameters = $parameters;
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            $parameters = $this->parseParameters($this->domain, $request->getHost(), '[^.]*');
+
+            if ($parameters !== null) {
+                $this->parameters = $parameters;
+                return true;
+            }
+
+            return false;
+        }
+
+        return true;
     }
 
     public function renderRoute(Request $request) {
@@ -26,11 +57,45 @@ class RouterGroup extends RouterEntry {
             throw new RouterException('Method not allowed');
         }
 
+        $this->matchDomain($request);
+
         return parent::renderRoute($request);
     }
 
     public function matchRoute(Request $request) {
-        return null;
+        // Skip if prefix doesn't match
+        if($this->getPrefix() !== null && stripos($request->getUri(), $this->getPrefix()) === false) {
+            return false;
+        }
+
+        return $this->matchDomain($request);
+    }
+
+    public function setExceptionHandler($class) {
+        $this->exceptionHandler = $class;
+        return $this;
+    }
+
+    public function getExceptionHandler() {
+        return $this->exceptionHandler;
+    }
+
+    public function getDomain() {
+        return $this->domain;
+    }
+
+    /**
+     * @param array $settings
+     * @return self
+     */
+    public function addSettings(array $settings = null) {
+        if($this->getNamespace() !== null && isset($settings['namespace'])) {
+            unset($settings['namespace']);
+        }
+        if(is_array($settings)) {
+            $this->settings = array_merge($this->settings, $settings);
+        }
+        return $this;
     }
 
 }

src/Pecee/SimpleRouter/RouterResource.php

@@ -1,15 +1,13 @@
 <?php
 namespace Pecee\SimpleRouter;
 
+use Pecee\Exception\RouterException;
 use Pecee\Http\Request;
 
 class RouterResource extends RouterEntry {
 
-    const DEFAULT_METHOD = 'index';
-
     protected $url;
     protected $controller;
-    protected $method;
     protected $postMethod;
 
     public function __construct($url, $controller) {
@@ -45,62 +43,58 @@ class RouterResource extends RouterEntry {
     protected function call($method, $parameters) {
         $this->setCallback($this->controller . '@' . $method);
         $this->parameters = $parameters;
-        return $this;
+        return true;
     }
 
     public function matchRoute(Request $request) {
-        $url = parse_url($request->getUri());
+        $url = parse_url(urldecode($request->getUri()));
         $url = rtrim($url['path'], '/') . '/';
 
-        if(strtolower($url) == strtolower($this->url) || stripos($url, $this->url) === 0) {
-            $url = rtrim($url, '/');
+        $route = rtrim($this->url, '/') . '/{id?}/{action?}';
 
-            $strippedUrl = trim(substr($url, strlen($this->url)), '/');
-            $path = explode('/', $strippedUrl);
+        $parameters = $this->parseParameters($route, $url, '[0-9]+?');
 
-            $args = $path;
-            $action = '';
+        if($parameters !== null) {
 
-            if(count($args)) {
-                $action = $args[0];
-                array_shift($args);
+            if(is_array($parameters)) {
+                $parameters = array_merge($this->parameters, $parameters);
             }
 
-            if (count($path)) {
+            $action = isset($parameters['action']) ? $parameters['action'] : null;
+            unset($parameters['action']);
 
-                // Delete
-                if($request->getMethod() === self::REQUEST_TYPE_DELETE && $this->postMethod === self::REQUEST_TYPE_POST) {
-                    return $this->call('destroy', $args);
-                }
-
-                // Update
-                if(in_array($request->getMethod(), array('put', 'patch')) && $this->postMethod === self::REQUEST_TYPE_POST) {
-                    return $this->call('update', array_merge(array($action), $args));
-                }
-
-                // Edit
-                if(isset($args[0]) && strtolower($args[0]) === 'edit' && $this->postMethod === self::REQUEST_TYPE_GET) {
-                    return $this->call('edit', array_merge(array($action), array_slice($args, 1)));
-                }
-
-                // Create
-                if(strtolower($action) === 'create' && $request->getMethod() === self::REQUEST_TYPE_GET) {
-                    return $this->call('create', $args);
-                }
-
-                // Save
-                if($this->postMethod === self::REQUEST_TYPE_POST) {
-                    return $this->call('store', $args);
-                }
-
-                // Show
-                if($action && $this->postMethod === self::REQUEST_TYPE_GET) {
-                    return $this->call('show', array_merge(array($action), $args));
-                }
-
-                // Index
-                return $this->call('index', $args);
+            // Delete
+            if($request->getMethod() === self::REQUEST_TYPE_DELETE && $this->postMethod === self::REQUEST_TYPE_POST) {
+                return $this->call('destroy', $parameters);
             }
+
+            // Update
+            if(in_array($request->getMethod(), array(self::REQUEST_TYPE_PATCH, self::REQUEST_TYPE_PUT)) && $this->postMethod === self::REQUEST_TYPE_POST) {
+                return $this->call('update', $parameters);
+            }
+
+            // Edit
+            if(isset($action) && strtolower($action) === 'edit' && $this->postMethod === self::REQUEST_TYPE_GET) {
+                return $this->call('edit', $parameters);
+            }
+
+            // Create
+            if(strtolower($action) === 'create' && $request->getMethod() === self::REQUEST_TYPE_GET) {
+                return $this->call('create', $parameters);
+            }
+
+            // Save
+            if($this->postMethod === self::REQUEST_TYPE_POST) {
+                return $this->call('store', $parameters);
+            }
+
+            // Show
+            if(isset($parameters['id']) && $this->postMethod === self::REQUEST_TYPE_GET) {
+                return $this->call('show', $parameters);
+            }
+
+            // Index
+            return $this->call('index', $parameters);
         }
 
         return null;
@@ -115,10 +109,12 @@ class RouterResource extends RouterEntry {
 
     /**
      * @param string $url
+     * @return static
      */
     public function setUrl($url) {
         $url = rtrim($url, '/') . '/';
         $this->url = $url;
+        return $this;
     }
 
     /**
@@ -130,23 +126,11 @@ class RouterResource extends RouterEntry {
 
     /**
      * @param string $controller
+     * @return static
      */
     public function setController($controller) {
         $this->controller = $controller;
-    }
-
-    /**
-     * @return string
-     */
-    public function getMethod() {
-        return $this->method;
-    }
-
-    /**
-     * @param string $method
-     */
-    public function setMethod($method) {
-        $this->method = $method;
+        return $this;
     }
 
 }

src/Pecee/SimpleRouter/RouterRoute.php

@@ -6,7 +6,7 @@ use Pecee\Http\Request;
 
 class RouterRoute extends RouterEntry {
 
-    const PARAMETERS_REGEX_MATCH = '{([A-Za-z\-\_]*?)}';
+    const PARAMETERS_REGEX_MATCH = '{([A-Za-z\-\_]*?)\?{0,1}}';
 
     protected $url;
 
@@ -14,99 +14,39 @@ class RouterRoute extends RouterEntry {
         parent::__construct();
         $this->setUrl($url);
         $this->setCallback($callback);
-
-        $this->settings['aliases'] = array();
-    }
-
-    protected function parseParameters($url, $multiple = false, $regex = self::PARAMETERS_REGEX_MATCH) {
-        $url = rtrim($url, '/');
-        $parameters = array();
-
-        if($multiple) {
-            preg_match_all('/'.$regex.'/is', $url, $parameters);
-        } else {
-            preg_match('/'.$regex.'/is', $url, $parameters);
-        }
-
-        if(isset($parameters[1]) && count($parameters[1]) > 0) {
-            return $parameters[1];
-        }
-
-        return null;
     }
 
     public function matchRoute(Request $request) {
 
-        // Check if request method is allowed
+        $url = parse_url(urldecode($request->getUri()));
+        $url = rtrim($url['path'], '/') . '/';
 
-        $url = parse_url($request->getUri());
-        $url = $url['path'];
-
-        $route = $this->url;
-
-        $routeMatch = preg_replace('/\/{0,1}'.self::PARAMETERS_REGEX_MATCH.'\/{0,1}/is', '', $route);
-
-        // Check if url parameter count matches
-        if(stripos($url, $routeMatch) === 0) {
-
-            $matches = true;
-
-            if($this->regexMatch) {
-                $parameters = $this->parseParameters($url, true, $this->regexMatch);
-
-                // If regex doesn't match, make sure to return an array
-                if(!is_array($parameters)) {
-                    $parameters = array();
-                }
-
-            } else {
-
-                $matches = (count(explode('/', rtrim($url, '/'))) == count(explode('/', rtrim($route, '/'))));
-
-                $url = explode('/', $url);
-                $route = explode('/', rtrim($route, '/'));
-
-                $parameters = array();
-
-                // Check if url matches
-                foreach ($route as $i => $path) {
-                    $parameter = $this->parseParameters($path, false);
-
-                    // Check if parameter of path matches, otherwise quit..
-                    if (is_null($parameter) && strtolower($path) != strtolower($url[$i])) {
-                        $matches = false;
-                        break;
-                    }
-
-                    // Save parameter if we have one
-                    if ($parameter) {
-                        $parameterValue = $url[$i];
-                        $regex = (isset($this->parametersRegex[$parameter]) ? $this->parametersRegex[$parameter] : null);
-
-                        if ($regex !== null) {
-                            // Use the regular expression rule provided to filter the value
-                            $matches = array();
-                            preg_match('/' . $regex . '/is', $url[$i], $matches);
-
-                            if (count($matches)) {
-                                $parameterValue = $matches[0];
-                            }
-                        }
-
-                        // Add parameter value, if it doesn't exist - replace it with null value
-                        $parameters[$parameter] = ($parameterValue === '') ? null : $parameterValue;
-                    }
-                }
-            }
-
-            // This route matches
-            if($matches) {
-                $this->parameters = $parameters;
-                return $this;
+        // Match on custom defined regular expression
+        if($this->regexMatch) {
+            $parameters = array();
+            if(preg_match('/('.$this->regexMatch.')/is', $request->getHost() . $url, $parameters)) {
+                $this->parameters = (!is_array($parameters[0]) ? array($parameters[0]) : $parameters[0]);
+                return true;
             }
+            return null;
+        }
+
+        // Make regular expression based on route
+        $route = rtrim($this->url, '/') . '/';
+
+        $parameters = $this->parseParameters($route, $url);
+
+        if($parameters !== null) {
+
+            if(is_array($this->parameters)) {
+                $this->parameters = array_merge($this->parameters, $parameters);
+            } else {
+                $this->parameters = $parameters;
+            }
+
+            return true;
         }
 
-        // No match here, move on...
         return null;
     }
 
@@ -122,13 +62,19 @@ class RouterRoute extends RouterEntry {
      * @return self
      */
     public function setUrl($url) {
+        $parameters = array();
+        $matches = array();
 
-        $parameters = $this->parseParameters($url, true);
+        if(preg_match_all('/'.self::PARAMETERS_REGEX_MATCH.'/is', $url, $matches)) {
+            $parameters = $matches[1];
+        }
 
-        if($parameters !== null) {
+        if(count($parameters)) {
+            $tmp = array();
             foreach($parameters as $param) {
-                $this->parameters[$param] = '';
+                $tmp[$param] = null;
             }
+            $this->parameters = $tmp;
         }
 
         $this->url = $url;
@@ -137,15 +83,35 @@ class RouterRoute extends RouterEntry {
 
     /**
      * Get alias for the url which can be used when getting the url route.
-     * @return string
+     * @return string|array
      */
     public function getAlias(){
         return $this->alias;
     }
 
+    /**
+     * Check if route has given alias.
+     *
+     * @param $name
+     * @return bool
+     */
+    public function hasAlias($name) {
+        if(is_array($this->alias)) {
+            foreach($this->alias as $alias) {
+                if(strtolower($alias) === strtolower($name)) {
+                    return true;
+                }
+            }
+        } else {
+            return strtolower($this->getAlias()) === strtolower($name);
+        }
+        
+        return false;
+    }
+
     /**
      * Set the url alias for easier getting the url route.
-     * @param string $alias
+     * @param string|array $alias
      * @return self
      */
     public function setAlias($alias){

src/Pecee/SimpleRouter/SimpleRouter.php

@@ -4,7 +4,7 @@
  * ---------------------------
  * Router helper class
  * ---------------------------
- * This class is added so calls can be made staticly 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 more pretty.
  */
 
 namespace Pecee\SimpleRouter;
@@ -16,12 +16,10 @@ class SimpleRouter {
     /**
      * Start/route request
      * @param null $defaultNamespace
-     * @throws RouterException
+     * @throws \Pecee\Exception\RouterException
      */
     public static function start($defaultNamespace = null) {
-        $router = RouterBase::GetInstance();
-        $router->setDefaultNamespace($defaultNamespace);
-        $router->routeRequest();
+        RouterBase::getInstance()->setDefaultNamespace($defaultNamespace)->routeRequest();
     }
 
     /**
@@ -32,48 +30,24 @@ class SimpleRouter {
         RouterBase::getInstance()->setBaseCsrfVerifier($baseCsrfVerifier);
     }
 
+    public static function addBootManager(RouterBootManager $bootManager) {
+        RouterBase::getInstance()->addBootManager($bootManager);
+    }
+
     public static function get($url, $callback, array $settings = null) {
-        $route = new RouterRoute($url, $callback);
-        $route->addSettings($settings);
-        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_GET));
-
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
-
-        return $route;
+        return self::match(['get'], $url, $callback, $settings);
     }
 
     public static function post($url, $callback, array $settings = null) {
-        $route = new RouterRoute($url, $callback);
-        $route->addSettings($settings);
-        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_POST));
-
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
-
-        return $route;
+        return self::match(['post'], $url, $callback, $settings);
     }
 
     public static function put($url, $callback, array $settings = null) {
-        $route = new RouterRoute($url, $callback);
-        $route->addSettings($settings);
-        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_PUT, RouterRoute::REQUEST_TYPE_PATCH));
-
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
-
-        return $route;
+        return self::match(['put'], $url, $callback, $settings);
     }
 
     public static function delete($url, $callback, array $settings = null) {
-        $route = new RouterRoute($url, $callback);
-        $route->addSettings($settings);
-        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_DELETE));
-
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
-
-        return $route;
+        return self::match(['delete'], $url, $callback, $settings);
     }
 
     public static function group($settings = array(), $callback) {
@@ -84,46 +58,68 @@ class SimpleRouter {
             $group->setSettings($settings);
         }
 
-        $router = RouterBase::getInstance();
-        $router->addRoute($group);
+        RouterBase::getInstance()->addRoute($group);
 
         return $group;
     }
 
+    /**
+     * Adds get + post route
+     *
+     * @param string $url
+     * @param callable $callback
+     * @param array|null $settings
+     * @return RouterRoute
+     */
+    public static function basic($url, $callback, array $settings = null) {
+        return self::match(['get', 'post'], $url, $callback, $settings);
+    }
+
     public static function match(array $requestMethods, $url, $callback, array $settings = null) {
         $route = new RouterRoute($url, $callback);
         $route->setRequestMethods($requestMethods);
-        $route->addSettings($settings);
 
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
+        if($settings !== null) {
+            $route->addSettings($settings);
+        }
+
+        RouterBase::getInstance()->addRoute($route);
 
         return $route;
     }
 
     public static function all($url, $callback, array $settings = null) {
         $route = new RouterRoute($url, $callback);
-        $route->addSettings($settings);
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
+
+        if($settings !== null) {
+            $route->addSettings($settings);
+        }
+
+        RouterBase::getInstance()->addRoute($route);
 
         return $route;
     }
 
     public static function controller($url, $controller, array $settings = null) {
         $route = new RouterController($url, $controller);
-        $route->addSettings($settings);
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
+
+        if($settings !== null) {
+            $route->addSettings($settings);
+        }
+
+        RouterBase::getInstance()->addRoute($route);
 
         return $route;
     }
 
     public static function resource($url, $controller, array $settings = null) {
         $route = new RouterResource($url, $controller);
-        $route->addSettings($settings);
-        $router = RouterBase::getInstance();
-        $router->addRoute($route);
+
+        if($settings !== null) {
+            $route->addSettings($settings);
+        }
+
+        RouterBase::getInstance()->addRoute($route);
 
         return $route;
     }

test/Dummy/DummyController.php

@@ -0,0 +1,9 @@
+<?php
+
+class DummyController {
+
+    public function start() {
+        echo static::class . '@' .'start() OK';
+    }
+
+}

test/Dummy/DummyMiddleware.php

@@ -0,0 +1,14 @@
+<?php
+
+require_once 'Exceptions/MiddlewareLoadedException.php';
+
+use Pecee\Http\Middleware\IMiddleware;
+use Pecee\Http\Request;
+
+class DummyMiddleware implements IMiddleware {
+
+    public function handle(Request $request) {
+       throw new MiddlewareLoadedException('Middleware loaded!');
+    }
+
+}

test/Dummy/Exceptions/MiddlewareLoadedException.php

@@ -0,0 +1,2 @@
+<?php
+class MiddlewareLoadedException extends \Exception {}

test/GroupTest.php

@@ -0,0 +1,51 @@
+<?php
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+
+class GroupTest extends PHPUnit_Framework_TestCase  {
+
+    protected $result;
+
+    public function __construct() {
+        // Initial setup
+        $_SERVER['HTTP_HOST'] = 'example.com';
+        $_SERVER['REQUEST_URI'] = '/api/v1/test';
+        $_SERVER['REQUEST_METHOD'] = 'get';
+    }
+
+    protected function group() {
+        $this->result = true;
+    }
+
+    public function testGroup() {
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        $this->result = false;
+
+        \Pecee\SimpleRouter\SimpleRouter::group(['prefix' => '/group'], $this->group());
+
+        try {
+            \Pecee\SimpleRouter\SimpleRouter::start();
+        } catch(Exception $e) {
+
+        }
+
+        $this->assertTrue($this->result);
+    }
+
+    public function testNestedGroup() {
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\Http\Request::getInstance()->setUri('/api/v1/test');
+
+        \Pecee\SimpleRouter\SimpleRouter::group(['prefix' => '/api'], function() {
+            \Pecee\SimpleRouter\SimpleRouter::group(['prefix' => '/v1'], function() {
+                \Pecee\SimpleRouter\SimpleRouter::get('/test', 'DummyController@start');
+            });
+        });
+
+        \Pecee\SimpleRouter\SimpleRouter::start();
+    }
+
+}

test/MiddlewareTest.php

@@ -0,0 +1,36 @@
+<?php
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+
+class MiddlewareTest extends PHPUnit_Framework_TestCase  {
+
+    public function __construct() {
+        // Initial setup
+        $_SERVER['HTTP_HOST'] = 'example.com';
+        $_SERVER['REQUEST_URI'] = '/my/test/url';
+        $_SERVER['REQUEST_METHOD'] = 'get';
+    }
+
+    public function testMiddlewareFound() {
+
+        \Pecee\Http\Request::getInstance()->setMethod('get');
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\SimpleRouter\SimpleRouter::get('/my/test/url', 'DummyController@start', ['middleware' => 'DummyMiddleware']);
+
+        try {
+            \Pecee\SimpleRouter\SimpleRouter::start();
+        }catch(Exception $e) {
+            $this->assertTrue(($e instanceof MiddlewareLoadedException));
+            return;
+        }
+
+        throw new Exception('Middleware not loaded');
+
+    }
+
+
+
+}

test/RouterRouteTest.php

@@ -0,0 +1,69 @@
+<?php
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+
+class RouterRouteTest extends PHPUnit_Framework_TestCase  {
+
+    public function __construct() {
+        // Initial setup
+        $_SERVER['HTTP_HOST'] = 'example.com';
+        $_SERVER['REQUEST_URI'] = '/my/test/url';
+        $_SERVER['REQUEST_METHOD'] = 'get';
+    }
+
+    public function testGet() {
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\Http\Request::getInstance()->setMethod('get');
+
+        \Pecee\SimpleRouter\SimpleRouter::get('/my/test/url', 'DummyController@start');
+        \Pecee\SimpleRouter\SimpleRouter::start();
+    }
+
+    public function testPost() {
+        \Pecee\Http\Request::getInstance()->setMethod('post');
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\SimpleRouter\SimpleRouter::post('/my/test/url', 'DummyController@start');
+        \Pecee\SimpleRouter\SimpleRouter::start();
+    }
+
+    public function testPut() {
+        \Pecee\Http\Request::getInstance()->setMethod('put');
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\SimpleRouter\SimpleRouter::put('/my/test/url', 'DummyController@start');
+        \Pecee\SimpleRouter\SimpleRouter::start();
+    }
+
+    public function testDelete() {
+        \Pecee\Http\Request::getInstance()->setMethod('delete');
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\SimpleRouter\SimpleRouter::delete('/my/test/url', 'DummyController@start');
+        \Pecee\SimpleRouter\SimpleRouter::start();
+
+    }
+
+    public function testMethodNotAllowed() {
+
+        \Pecee\SimpleRouter\RouterBase::reset();
+
+        \Pecee\Http\Request::getInstance()->setMethod('post');
+
+        \Pecee\SimpleRouter\SimpleRouter::get('/my/test/url', 'DummyController@start');
+
+        try {
+            \Pecee\SimpleRouter\SimpleRouter::start();
+        } catch(\Exception $e) {
+            $this->assertEquals(403, $e->getCode());
+        }
+
+    }
+
+}