Merge pull request #49 from skipperbent/development

Development

README.md

@@ -1,5 +1,5 @@
 # Simple PHP router
-Simple, fast PHP router that is easy to get integrated and in almost 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 Laravel router.
 
 ## Installation
 Add the latest version pf Simple PHP Router to your ```composer.json```
@@ -17,6 +17,8 @@ Add the latest version pf Simple PHP Router to your ```composer.json```
 
 ## 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 +30,12 @@ Add the latest version pf Simple PHP Router to your ```composer.json```
 - Namespaces.
 - Route prefixes.
 - CSRF protection.
+- Optional parameters
+- Sub-domain routing
 
 ### Features currently "in-the-works"
 
 - Global Constraints
-- Sub-Domain Routing
-- Optional/required parameters
 
 ## Initialising the router
 
@@ -72,18 +74,20 @@ use Pecee\SimpleRouter\SimpleRouter;
 
 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 +102,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,47 +147,57 @@ 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);
+
+            $route = RouterBase::getInstance()->getLoadedRoute();
+
+            $exceptionHandler = null;
+
+            // Load and use exception-handler defined on group
+            
+            if($route && $route->getGroup()) {
+                $exceptionHandler = $route->getGroup()->getExceptionHandler();
+                
+                if($exceptionHandler !== null) {
+                    $class = new $exceptionHandler();
+                    $class->handleError(RouterBase::getInstance()->getRequest(), $route, $e);
+                }
+            }
+
+            // Otherwise use the fallback default exceptions handler
+           
+            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;
     }
 
 }
@@ -197,19 +225,49 @@ function csrf_token() {
 }
 ```
 
-### Example for getting the url
+## Getting urls
 
-In ```routes.php``` we have added this route:
+**In ```routes.php``` we have added this route:**
 
-```SimpleRouter::get('/item/{id}', 'myController@show', ['as' => 'item']);```
+```php
+SimpleRouter::get('/item/{id}', 'myController@show', ['as' => 'item']);
+```
 
-In the template we then call:
+**In the template we then call:**
 
-```url('item', ['id' => 22], ['category' => 'shoes']);```
+```php
+url('item', ['id' => 22], ['category' => 'shoes']);
+```
 
-Result url is:
+**Result url is:**
 
-```/item/22?category=shoes ```
+```php
+/item/22/?category=shoes
+```
+
+## Custom CSRF verifier
+
+Create a new class and extend the ```BaseCsrfVerifier``` middleware class provided with simple-php-router.
+
+Add the property ```except``` with an array of the urls to the routes you would like to exclude from the CSRF validation. Using ```*``` at the end for the url will match the entire url.
+
+Querystrings are ignored.
+
+```php
+use Pecee\Http\Middleware\BaseCsrfVerifier;
+
+class CsrfVerifier extends BaseCsrfVerifier {
+
+    protected $except = ['/companies/*', '/user/save'];
+
+}
+```
+
+Register the new class in your ```routes.php```, custom ```Router``` class or wherever you register your routes.
+
+```php
+SimpleRouter::csrfVerifier(new \Demo\Middleware\CsrfVerifier());
+```
 
 ## Documentation
 While I work on a better documentation, please refer to the Laravel 5 routing documentation here:
@@ -221,7 +279,7 @@ The router can be easily extended to customize your needs.
 
 ## The MIT License (MIT)
 
-Copyright (c) 2015 Simon Sessing� / simple-php-router
+Copyright (c) 2015 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
@@ -239,4 +297,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

composer.json

@@ -20,7 +20,7 @@
     },
     "autoload": {
         "psr-4": {
-            "Pecee\\": "src/"
+            "Pecee\\": "src/Pecee/"
         }
     }
 }

src/Pecee/Exception/TokenMismatchException.php

@@ -0,0 +1,4 @@
+<?php
+namespace Pecee\Exception;
+
+class TokenMismatchException extends \Exception {}

src/Pecee/Http/Middleware/BaseCsrfVerifier.php

@@ -1,19 +1,54 @@
 <?php
-
 namespace Pecee\Http\Middleware;
 
 use Pecee\CsrfToken;
+use Pecee\Exception\TokenMismatchException;
 use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterException;
 
-class BaseCsrfVerifier extends Middleware {
+class BaseCsrfVerifier implements IMiddleware {
 
     const POST_KEY = 'csrf-token';
     const HEADER_KEY = 'X-CSRF-TOKEN';
 
+    protected $except;
+    protected $csrfToken;
+
+
+    public function __construct() {
+        $this->csrfToken = new CsrfToken();
+    }
+
+    /**
+     * Check if the url matches the urls in the except property
+     * @param Request $request
+     * @return bool
+     */
+    protected function skip(Request $request) {
+
+        if($this->except === null || !is_array($this->except)) {
+            return false;
+        }
+
+        foreach($this->except as $url) {
+            $url = rtrim($url, '/');
+            if($url[strlen($url)-1] === '*') {
+                $url = rtrim($url, '*');
+                $skip = (stripos($request->getUri(), $url) === 0);
+            } else {
+                $skip = ($url === rtrim($request->getUri(), '/'));
+            }
+
+            if($skip) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     public function handle(Request $request) {
 
-        if($request->getMethod() != 'get') {
+        if($request->getMethod() != 'get' && !$this->skip($request)) {
 
             $token = (isset($_POST[self::POST_KEY])) ? $_POST[self::POST_KEY] : null;
 
@@ -22,9 +57,8 @@ class BaseCsrfVerifier extends Middleware {
                 $token = $request->getHeader(self::HEADER_KEY);
             }
 
-            $tokenValidator = new CsrfToken();
-            if( !$tokenValidator->validate( $token ) ) {
-                throw new RouterException('Invalid csrf-token.');
+            if( !$this->csrfToken->validate( $token ) ) {
+                throw new TokenMismatchException('Invalid csrf-token.');
             }
 
         }

src/Pecee/Http/Middleware/IMiddleware.php

@@ -0,0 +1,8 @@
+<?php
+namespace Pecee\Http\Middleware;
+
+use Pecee\Http\Request;
+
+interface IMiddleware {
+    public function handle(Request $request);
+}

src/Pecee/Http/Middleware/Middleware.php

@@ -1,11 +0,0 @@
-<?php
-
-namespace Pecee\Http\Middleware;
-
-use Pecee\Http\Request;
-use Pecee\SimpleRouter\RouterEntry;
-
-abstract class Middleware
-{
-    abstract function handle(Request $request);
-}

src/Pecee/Http/Request.php

@@ -3,16 +3,35 @@ namespace Pecee\Http;
 
 class Request {
 
+    protected static $instance;
+
+    protected $data;
     protected $uri;
     protected $host;
     protected $method;
     protected $headers;
 
+    /**
+     * Return new instance
+     * @return static
+     */
+    public static function getInstance() {
+        if(self::$instance === null) {
+            self::$instance = new static();
+        }
+        return self::$instance;
+    }
+
     public function __construct() {
+        $this->data = array();
         $this->host = $_SERVER['HTTP_HOST'];
-        $this->uri = rtrim($_SERVER['REQUEST_URI'], '/') . '/';
+        $this->uri = $_SERVER['REQUEST_URI'];
         $this->method = (isset($_POST['_method'])) ? strtolower($_POST['_method']) : strtolower($_SERVER['REQUEST_METHOD']);
-        $this->headers = getallheaders();
+        $this->headers = array_change_key_case(getallheaders(), CASE_LOWER);
+    }
+
+    public function getIsSecure() {
+        return isset($_SERVER['HTTPS']) ? true : (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] === 443);
     }
 
     /**
@@ -60,13 +79,55 @@ class Request {
         return $this->headers;
     }
 
+    /**
+     * Get id address
+     * @return string
+     */
+    public function getIp() {
+        return isset($_SERVER['HTTP_X_FORWARDED_FOR']) ? $_SERVER['HTTP_X_FORWARDED_FOR'] : $_SERVER['REMOTE_ADDR'];
+    }
+
+    /**
+     * Get referer
+     * @return string
+     */
+    public function getReferer() {
+        return isset($_SERVER['HTTP_REFERER']) ? $_SERVER['HTTP_REFERER'] : '';
+    }
+
+    /**
+     * Get user agent
+     * @return string
+     */
+    public function getUserAgent() {
+        return isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : '';
+    }
+
     /**
      * Get header value by name
      * @param string $name
      * @return string|null
      */
     public function getHeader($name) {
-        return (isset($this->headers[$name])) ? $this->headers[$name] : null;
+        return (isset($this->headers[strtolower($name)])) ? $this->headers[strtolower($name)] : null;
+    }
+
+    /**
+     * Get request input or default value
+     * @param string $name
+     * @param string $defaultValue
+     * @return mixed
+     */
+    public function getInput($name, $defaultValue) {
+        return (isset($_REQUEST[$name]) ? $_REQUEST[$name] : $defaultValue);
+    }
+
+    public function __set($name, $value = null) {
+        $this->data[$name] = $value;
+    }
+
+    public function __get($name) {
+        return isset($this->data[$name]) ? $this->data[$name] : null;
     }
 
 }

src/Pecee/Http/Response.php

@@ -21,17 +21,78 @@ class Response {
      * @param string $url
      */
     public function redirect($url) {
-        header('location: ' . $url);
+        $this->header('Location: ' . $url);
         die();
     }
 
     public function refresh() {
-        $this->redirect(url());
+        $this->redirect(Request::getInstance()->getUri());
     }
 
+    /**
+     * Add http authorisation
+     * @param string $name
+     * @return self $this
+     */
     public function auth($name = '') {
-        header('WWW-Authenticate: Basic realm="' . $name . '"');
-        header('HTTP/1.0 401 Unauthorized');
+        $this->headers([
+            'WWW-Authenticate: Basic realm="' . $name . '"',
+            'HTTP/1.0 401 Unauthorized'
+        ]);
+        return $this;
+    }
+
+    public function cache($eTag, $lastModified = 2592000) {
+
+        $this->headers([
+            '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;
+    }
+
+    /**
+     * Json encode array
+     * @param array $value
+     */
+    public function json(array $value) {
+        $this->header('Content-type: application/json');
+        echo json_encode($value);
+        die();
+    }
+
+    /**
+     * Add header to response
+     * @param string $value
+     * @return self $this
+     */
+    public function header($value) {
+        header($value);
+        return $this;
+    }
+
+    /**
+     * Add multiple headers to response
+     * @param array $headers
+     * @return self $this
+     */
+    public function headers(array $headers) {
+        foreach($headers as $header) {
+            header($header);
+        }
+        return $this;
     }
 
 }

src/Pecee/SimpleRouter/RouterBase.php

@@ -1,10 +1,8 @@
 <?php
 namespace Pecee\SimpleRouter;
 
-use Pecee\ArrayUtil;
 use Pecee\Http\Middleware\BaseCsrfVerifier;
 use Pecee\Http\Request;
-use Pecee\Url;
 
 class RouterBase {
 
@@ -27,8 +25,7 @@ class RouterBase {
         $this->routes = array();
         $this->backstack = array();
         $this->controllerUrlMap = array();
-        $this->request = new Request();
-        $this->baseCsrfVerifier = new BaseCsrfVerifier();
+        $this->request = Request::getInstance();
     }
 
     public function addRoute(RouterEntry $route) {
@@ -39,11 +36,19 @@ class RouterBase {
         }
     }
 
-    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
 
+        $activeGroup = null;
+        $routesCount = count($routes);
+        $mergedSettings = array();
+
         /* @var $route RouterEntry */
-        foreach($routes as $route) {
+        for($i = 0; $i < $routesCount; $i++) {
+
+            $route = $routes[$i];
+
+            $route->setGroup($group);
 
             if($this->defaultNamespace && !$route->getNamespace()) {
                 $namespace = null;
@@ -57,14 +62,15 @@ class RouterBase {
             }
 
             $newPrefixes = $prefixes;
-            $mergedSettings = array_merge($settings, $route->getMergeableSettings());
+
             if($route->getPrefix()) {
                 array_push($newPrefixes, rtrim($route->getPrefix(), '/'));
             }
-            $route->addSettings($mergedSettings);
+
+            $route->addSettings($settings);
 
             if(!($route instanceof RouterGroup)) {
-                if(is_array($newPrefixes) && count($newPrefixes) && $backstack) {
+                if(is_array($newPrefixes) && count($newPrefixes) && $backStack) {
                     $route->setUrl( join('/', $newPrefixes) . $route->getUrl() );
                 }
 
@@ -72,17 +78,21 @@ class RouterBase {
             }
 
             $this->currentRoute = $route;
+
             if($route instanceof RouterGroup && is_callable($route->getCallback())) {
                 $route->renderRoute($this->request);
+                $activeGroup = $route;
+                $mergedSettings = array_merge($route->getMergeableSettings(), $settings);
             }
+
             $this->currentRoute = null;
 
             if(count($this->backstack)) {
-                $backstack = $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, $activeGroup);
             }
         }
     }
@@ -100,18 +110,18 @@ class RouterBase {
         // Loop through each route-request
         $this->processRoutes($this->routes);
 
-        // Make sure the urls is in the right order when comparing
-        usort($this->controllerUrlMap, function($a, $b) {
-            return strcmp($b->getUrl(), $a->getUrl());
-        });
-
         $routeNotAllowed = false;
 
+        $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;
@@ -120,8 +130,9 @@ class RouterBase {
 
                 $routeNotAllowed = false;
 
-                $this->loadedRoute = $routeMatch;
-                $routeMatch->renderRoute($this->request);
+                $this->loadedRoute = $route;
+                $route->loadMiddleware($this->request);
+                $route->renderRoute($this->request);
                 break;
             }
         }
@@ -208,9 +219,18 @@ class RouterBase {
         return $this;
     }
 
+    protected function getParamsToArray($query) {
+        $output = array();
+        if($query[0] === '?') {
+            $query = substr($query, 1);
+        }
+        parse_str($query, $output);
+        return $output;
+    }
+
     protected function processUrl($route, $method = null, $parameters = null, $getParams = null) {
 
-        $url = $route->getUrl();
+        $url = '/' . trim($route->getUrl(), '/');
 
         if(($route instanceof RouterController || $route instanceof RouterResource) && $method !== null) {
             $url .= $method;
@@ -227,16 +247,21 @@ class RouterBase {
                 $i = 0;
                 foreach($params as $param => $value) {
                     $value = (isset($parameters[$param])) ? $parameters[$param] : $value;
-                    $url = str_ireplace('{' . $param. '}', $value, $url);
+                    $url = str_ireplace(array('{' . $param. '}', '{' . $param. '?}'), $value, $url);
                     $i++;
                 }
+            } 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);
+                }
             }
         }
 
         $url = rtrim($url, '/') . '/';
 
         if($getParams !== null && count($getParams)) {
-            $url .= '?'.Url::arrayToParams($getParams);
+            $url .= '?' . $this->getParamsToArray($getParams);
         }
 
         return $url;
@@ -252,15 +277,19 @@ class RouterBase {
             throw new \InvalidArgumentException('Invalid type for getParams. Must be array or null');
         }
 
-        if($controller === null && $parameters === null) {
+        if($controller === null && $parameters === null && $this->loadedRoute !== null) {
             return $this->processUrl($this->loadedRoute, null, $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)) {
@@ -281,7 +310,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) {
@@ -303,10 +335,18 @@ class RouterBase {
         $url = array($controller);
 
         if(is_array($parameters)) {
-            ArrayUtil::append($url, $parameters);
+            foreach($parameters as $key => $value) {
+                array_push($url,$value);
+            }
         }
 
-        return join('/', $url);
+        $url = '/' . trim(join('/', $url), '/') . '/';
+
+        if(is_array($getParams)) {
+            $url .= '?' . $this->getParamsToArray($getParams);
+        }
+
+        return $url;
     }
 
     public static function getInstance() {

src/Pecee/SimpleRouter/RouterController.php

@@ -17,6 +17,31 @@ class RouterController extends RouterEntry {
         $this->controller = $controller;
     }
 
+    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 {
+            // 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($request->getUri());
         $url = rtrim($url['path'], '/') . '/';
@@ -38,7 +63,7 @@ class RouterController extends RouterEntry {
                 // Set callback
                 $this->setCallback($this->controller . '@' . $this->method);
 
-                return $this;
+                return true;
             }
         }
         return null;

src/Pecee/SimpleRouter/RouterEntry.php

@@ -2,7 +2,7 @@
 
 namespace Pecee\SimpleRouter;
 
-use Pecee\Http\Middleware\Middleware;
+use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
 
 abstract class RouterEntry {
@@ -10,26 +10,25 @@ abstract class RouterEntry {
     const REQUEST_TYPE_POST = 'post';
     const REQUEST_TYPE_GET = 'get';
     const REQUEST_TYPE_PUT = 'put';
+    const REQUEST_TYPE_PATCH = 'patch';
     const REQUEST_TYPE_DELETE = 'delete';
 
     public static $allowedRequestTypes = array(
         self::REQUEST_TYPE_DELETE,
         self::REQUEST_TYPE_GET,
         self::REQUEST_TYPE_POST,
-        self::REQUEST_TYPE_PUT
+        self::REQUEST_TYPE_PUT,
+        self::REQUEST_TYPE_PATCH
     );
 
     protected $settings;
     protected $callback;
-    protected $parameters;
-    protected $parametersRegex;
-    protected $regexMatch;
 
     public function __construct() {
         $this->settings = array();
         $this->settings['requestMethods'] = array();
-        $this->parameters = array();
-        $this->parametersRegex = array();
+        $this->settings['parametersRegex'] = array();
+        $this->settings['parameters'] = array();
     }
 
     /**
@@ -137,7 +136,7 @@ abstract class RouterEntry {
      * @return mixed
      */
     public function getParameters(){
-        return $this->parameters;
+        return ($this->parameters === null) ? array() : $this->parameters;
     }
 
     /**
@@ -179,9 +178,9 @@ abstract class RouterEntry {
     public function getMergeableSettings() {
         $settings = $this->settings;
 
-        if(isset($settings['middleware'])) {
+        /*if(isset($settings['middleware'])) {
             unset($settings['middleware']);
-        }
+        }*/
 
         if(isset($settings['prefix'])) {
             unset($settings['prefix']);
@@ -208,7 +207,7 @@ abstract class RouterEntry {
     public function setSettings($settings) {
         $this->settings = $settings;
 
-        if($settings['prefix']) {
+        if(isset($settings['prefix'])) {
             $this->setPrefix($settings['prefix']);
         }
 
@@ -216,7 +215,7 @@ abstract class RouterEntry {
     }
 
     /**
-     * Dynamicially access settings value
+     * Dynamically access settings value
      *
      * @param $name
      * @return mixed|null
@@ -243,21 +242,112 @@ abstract class RouterEntry {
         return new $name();
     }
 
-    protected function loadMiddleware(Request $request) {
-        if($this->getMiddleware()) {
-            $middleware = $this->loadClass($this->getMiddleware());
-            if (!($middleware instanceof Middleware)) {
-                throw new RouterException($this->getMiddleware() . ' must be instance of Middleware');
+    protected function parseParameters($route, $url, $parameterRegex = '[a-z0-9]*?') {
+        $parameterNames = array();
+        $regex = '';
+        $lastCharacter = '';
+        $isParameter = false;
+        $parameter = '';
+
+        // Use custom parameter regex if it exists
+        if(is_array($this->parametersRegex) && isset($this->parametersRegex[$parameter])) {
+            $parameterRegex = $this->parametersRegex[$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;
             }
 
-            /* @var $class Middleware */
-            $middleware->handle($request);
+            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
+                if($lastCharacter === '?') {
+                    $parameter = substr($parameter, 0, strlen($parameter)-1);
+                    $regex .= '(?:(?:\/{0,1}(?P<'.$parameter.'>'.$parameterRegex.')){0,1}\\/{0,1})';
+                    $required = false;
+                } else {
+                    $regex .= '(?:\\/{0,1}(?P<' . $parameter . '>'. $parameterRegex .')\\/{0,1})';
+                }
+                $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);
+                    }
+
+                    $parameters[$name['name']] = $parameterValue;
+                }
+            }
+
+            return $parameters;
+        }
+
+        return null;
+    }
+
+    public function loadMiddleware(Request $request) {
+        if($this->getMiddleware()) {
+            if(is_array($this->getMiddleware())) {
+                foreach($this->getMiddleware() 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);
+                }
+            } else {
+                $middleware = $this->loadClass($this->getMiddleware());
+                if (!($middleware instanceof IMiddleware)) {
+                    throw new RouterException($this->getMiddleware() . ' must be instance of Middleware');
+                }
+
+                /* @var $class IMiddleware */
+                $middleware->handle($request);
+            }
         }
     }
 
     public function renderRoute(Request $request) {
-        // Load middleware
-        $this->loadMiddleware($request);
 
         if(is_object($this->getCallback()) && is_callable($this->getCallback())) {
 
@@ -307,6 +397,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

@@ -10,30 +10,74 @@ class RouterGroup extends RouterEntry {
         parent::__construct();
     }
 
-    public function matchRoute(Request $request) {
-        // Check if request method is allowed
+    protected function matchDomain(Request $request) {
+        if($this->domain !== null) {
 
-        if(strtolower($request->getUri()) == strtolower($this->prefix) || stripos($request->getUri(), $this->prefix) === 0) {
+            if(is_array($this->domain)) {
 
-            $hasAccess = (!$this->method);
+                $max = count($this->domain);
 
-            if($this->method) {
-                if(is_array($this->method)) {
-                    $hasAccess = (in_array($request->getMethod(), $this->getRequestMethods()));
-                } else {
-                    $hasAccess = strtolower($this->getRequestMethods()) == strtolower($request->getMethod());
+                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 null;
             }
 
-            if(!$hasAccess) {
-                throw new RouterException('Method not allowed');
+            $parameters = $this->parseParameters($this->domain, $request->getHost(), '[^.]*');
+
+            if ($parameters !== null) {
+                $this->parameters = $parameters;
+                return true;
             }
 
-            return $this;
+            return null;
         }
 
-        // No match here, move on...
+        return false;
+    }
+
+    public function renderRoute(Request $request) {
+        // Check if request method is allowed
+        $hasAccess = (!$this->method);
+
+        if($this->method) {
+            if(is_array($this->method)) {
+                $hasAccess = (in_array($request->getMethod(), $this->getRequestMethods()));
+            } else {
+                $hasAccess = strtolower($this->getRequestMethods()) == strtolower($request->getMethod());
+            }
+        }
+
+        if(!$hasAccess) {
+            throw new RouterException('Method not allowed');
+        }
+
+        if($this->matchDomain($request) === null) {
+            return null;
+        }
+
+        return parent::renderRoute($request);
+    }
+
+    public function matchRoute(Request $request) {
         return null;
     }
 
+    public function setExceptionHandler($class) {
+        $this->exceptionHandler = $class;
+        return $this;
+    }
+
+    public function getExceptionHandler() {
+        return $this->exceptionHandler;
+    }
+
 }

src/Pecee/SimpleRouter/RouterResource.php

@@ -20,9 +20,6 @@ class RouterResource extends RouterEntry {
     }
 
     public function renderRoute(Request $request) {
-        // Load middleware
-        $this->loadMiddleware($request);
-
         if(is_object($this->getCallback()) && is_callable($this->getCallback())) {
             // When the callback is a function
             call_user_func_array($this->getCallback(), $this->getParameters());
@@ -48,7 +45,7 @@ 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) {

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;
 
@@ -18,92 +18,37 @@ class RouterRoute extends RouterEntry {
         $this->settings['aliases'] = array();
     }
 
-    protected function parseParameters($url, $multiple = false, $regex = self::PARAMETERS_REGEX_MATCH) {
-        $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($request->getUri());
-        $url = $url['path'];
+        $url = rtrim($url['path'], '/') . '/';
 
-        $route = $this->url;
-
-        $routeMatch = preg_replace('/'.self::PARAMETERS_REGEX_MATCH.'/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 {
-
-                $url = explode('/', $url);
-                $route = explode('/', $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
-                        $parameters[$parameter] = $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;
     }
 
@@ -119,13 +64,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] = '';
             }
+            $this->parameters = $tmp;
         }
 
         $this->url = $url;
@@ -160,5 +111,4 @@ class RouterRoute extends RouterEntry {
         return parent::setSettings($settings);
     }
 
-
 }

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;
@@ -19,7 +19,7 @@ class SimpleRouter {
      * @throws RouterException
      */
     public static function start($defaultNamespace = null) {
-        $router = RouterBase::GetInstance();
+        $router = RouterBase::getInstance();
         $router->setDefaultNamespace($defaultNamespace);
         $router->routeRequest();
     }
@@ -57,7 +57,7 @@ class SimpleRouter {
     public static function put($url, $callback, array $settings = null) {
         $route = new RouterRoute($url, $callback);
         $route->addSettings($settings);
-        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_PUT));
+        $route->setRequestMethods(array(RouterRoute::REQUEST_TYPE_PUT, RouterRoute::REQUEST_TYPE_PATCH));
 
         $router = RouterBase::getInstance();
         $router->addRoute($route);
@@ -128,7 +128,7 @@ class SimpleRouter {
         return $route;
     }
 
-    public function getRoute($controller = null, $parameters = null, $getParams = null) {
+    public static function getRoute($controller = null, $parameters = null, $getParams = null) {
         return RouterBase::getInstance()->getRoute($controller, $parameters, $getParams);
     }