Merge pull request #66 from skipperbent/development

Development

README.md

@@ -1,8 +1,8 @@
 # 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.
 
 ## Installation
-Add the latest version pf Simple PHP Router to your ```composer.json```
+Add the latest version of Simple PHP Router to your ```composer.json```
 
 ```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 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,53 +147,64 @@ 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;
     }
 
 }
 ```
 
-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 +213,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 +270,24 @@ Register the new class in your ```routes.php```, custom ```Router``` class or wh
 SimpleRouter::csrfVerifier(new \Demo\Middleware\CsrfVerifier());
 ```
 
+## 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');
+```
+
 ## Documentation
 While I work on a better documentation, please refer to the Laravel 5 routing documentation here:
 
@@ -249,9 +296,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) 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

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
@@ -51,10 +45,18 @@ class CsrfToken {
      * @return string|null
      */
     public function getToken(){
-        if(isset($_COOKIE[self::CSRF_KEY])) {
+        if($this->hasToken()) {
             return $_COOKIE[self::CSRF_KEY];
         }
         return null;
     }
 
+    /**
+     * Returns whether the csrf token has been defined
+     * @return bool
+     */
+    public function hasToken() {
+        return isset($_COOKIE[self::CSRF_KEY]);
+    }
+
 }

src/Pecee/Http/Middleware/BaseCsrfVerifier.php

@@ -5,7 +5,7 @@ use Pecee\CsrfToken;
 use Pecee\Exception\TokenMismatchException;
 use Pecee\Http\Request;
 
-class BaseCsrfVerifier extends Middleware {
+class BaseCsrfVerifier implements IMiddleware {
 
     const POST_KEY = 'csrf-token';
     const HEADER_KEY = 'X-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

@@ -1,18 +1,50 @@
 <?php
 namespace Pecee\Http;
 
+use Pecee\SimpleRouter\RouterBase;
+
 class Request {
 
+    protected static $instance;
+
+    protected $data;
     protected $uri;
     protected $host;
     protected $method;
     protected $headers;
+    protected $loadedRoute;
+
+    /**
+     * 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 = $_SERVER['REQUEST_URI'];
         $this->method = (isset($_POST['_method'])) ? strtolower($_POST['_method']) : strtolower($_SERVER['REQUEST_METHOD']);
-        $this->headers = getallheaders();
+        $this->headers = $this->getAllHeaders();
+    }
+
+    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() {
+        return isset($_SERVER['HTTPS']) ? true : (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] === 443);
     }
 
     /**
@@ -90,7 +122,7 @@ class Request {
      * @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;
     }
 
     /**
@@ -103,4 +135,20 @@ class Request {
         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;
+    }
+
+    /**
+     * Get the currently loaded route.
+     * @return \Pecee\SimpleRouter\RouterEntry
+     */
+    public function getLoadedRoute() {
+        return $this->loadedRoute;
+    }
+
 }

src/Pecee/Http/Response.php

@@ -26,7 +26,7 @@ class Response {
     }
 
     public function refresh() {
-        $this->redirect(url());
+        $this->redirect(Request::getInstance()->getUri());
     }
 
     /**
@@ -42,12 +42,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/RouterBase.php

@@ -1,10 +1,9 @@
 <?php
 namespace Pecee\SimpleRouter;
 
-use Pecee\ArrayUtil;
+use Pecee\CsrfToken;
 use Pecee\Http\Middleware\BaseCsrfVerifier;
 use Pecee\Http\Request;
-use Pecee\Url;
 
 class RouterBase {
 
@@ -15,8 +14,7 @@ class RouterBase {
     protected $routes;
     protected $processedRoutes;
     protected $controllerUrlMap;
-    protected $backstack;
-    protected $loadedRoute;
+    protected $backStack;
     protected $defaultNamespace;
     protected $baseCsrfVerifier;
 
@@ -25,25 +23,40 @@ class RouterBase {
 
     public function __construct() {
         $this->routes = array();
-        $this->backstack = array();
+        $this->backStack = array();
         $this->controllerUrlMap = array();
-        $this->request = new Request();
         $this->baseCsrfVerifier = new BaseCsrfVerifier();
+        $this->request = Request::getInstance();
+
+        $csrf = new CsrfToken();
+        $token = ($csrf->hasToken()) ? $csrf->getToken() : $csrf->generateToken();
+        $csrf->setToken($token);
     }
 
     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;
@@ -57,32 +70,36 @@ class RouterBase {
             }
 
             $newPrefixes = $prefixes;
-            $mergedSettings = array_merge($settings, $route->getMergeableSettings());
+
             if($route->getPrefix()) {
                 array_push($newPrefixes, rtrim($route->getPrefix(), '/'));
             }
-            $route->addSettings($mergedSettings);
 
             if(!($route instanceof RouterGroup)) {
-                if(is_array($newPrefixes) && count($newPrefixes) && $backstack) {
+                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($route->getMergeableSettings(), $settings);
             }
+
             $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);
             }
         }
     }
@@ -102,11 +119,22 @@ class RouterBase {
 
         $routeNotAllowed = false;
 
+        $max = count($this->controllerUrlMap);
+
         /* @var $route RouterEntry */
-        foreach($this->controllerUrlMap as $route) {
+        for($i = 0; $i < $max; $i++) {
+
+            $route = $this->controllerUrlMap[$i];
+
+            if($route->getGroup() !== null) {
+                if($route->getGroup()->matchDomain($this->request) === false) {
+                    continue;
+                }
+            }
+
             $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;
@@ -115,9 +143,10 @@ class RouterBase {
 
                 $routeNotAllowed = false;
 
-                $this->loadedRoute = $routeMatch;
-                $routeMatch->loadMiddleware($this->request);
-                $routeMatch->renderRoute($this->request);
+                $this->request->loadedRoute = $route;
+                $route->loadMiddleware($this->request);
+
+                $this->request->loadedRoute->renderRoute($this->request);
                 break;
             }
         }
@@ -126,7 +155,7 @@ class RouterBase {
             throw 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);
         }
     }
@@ -149,8 +178,8 @@ class RouterBase {
      * @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;
     }
@@ -159,7 +188,7 @@ class RouterBase {
      * @return array
      */
     public function getBackstack() {
-        return $this->backstack;
+        return $this->backStack;
     }
 
     /**
@@ -204,9 +233,34 @@ class RouterBase {
         return $this;
     }
 
+    public function arrayToParams(array $getParams = null, $includeEmpty = true) {
+        if (is_array($getParams) && count($getParams) > 0) {
+            foreach ($getParams as $key => $val) {
+                if (!empty($val) || empty($val) && $includeEmpty) {
+                    $getParams[$key] = $key . '=' . $val;
+                }
+            }
+            return join('&', $getParams);
+        }
+        return '';
+    }
+
     protected function processUrl($route, $method = null, $parameters = null, $getParams = null) {
 
-        $url = '/' . trim($route->getUrl(), '/');
+        $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;
@@ -218,26 +272,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;
@@ -253,15 +313,33 @@ class RouterBase {
             throw new \InvalidArgumentException('Invalid type for getParams. Must be array or null');
         }
 
+        // Return current route if no options has been specified
         if($controller === null && $parameters === null) {
-            return $this->processUrl($this->loadedRoute, null, $getParams);
+            $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)) {
@@ -282,7 +360,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) {
@@ -304,10 +385,19 @@ 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($getParams !== null && count($getParams)) {
+            $url .= '?' . $this->arrayToParams($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['where'] = array();
+        $this->settings['parameters'] = array();
     }
 
     /**
@@ -78,6 +77,16 @@ 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
@@ -137,7 +146,7 @@ abstract class RouterEntry {
      * @return mixed
      */
     public function getParameters(){
-        return $this->parameters;
+        return ($this->parameters === null) ? array() : $this->parameters;
     }
 
     /**
@@ -156,7 +165,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 +188,6 @@ abstract class RouterEntry {
     public function getMergeableSettings() {
         $settings = $this->settings;
 
-        /*if(isset($settings['middleware'])) {
-            unset($settings['middleware']);
-        }*/
-
         if(isset($settings['prefix'])) {
             unset($settings['prefix']);
         }
@@ -208,7 +213,7 @@ abstract class RouterEntry {
     public function setSettings($settings) {
         $this->settings = $settings;
 
-        if($settings['prefix']) {
+        if(isset($settings['prefix'])) {
             $this->setPrefix($settings['prefix']);
         }
 
@@ -216,7 +221,7 @@ abstract class RouterEntry {
     }
 
     /**
-     * Dynamicially access settings value
+     * Dynamically access settings value
      *
      * @param $name
      * @return mixed|null
@@ -243,15 +248,113 @@ abstract class RouterEntry {
         return new $name();
     }
 
-    public 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 = '';
+
+        $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
+
+                // 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())) {
+                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);
+            }
         }
     }
 
@@ -305,6 +408,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,36 +10,76 @@ class RouterGroup extends RouterEntry {
         parent::__construct();
     }
 
-    public function renderRoute(Request $request) {
-        // Check if request method is allowed
+    public 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 false;
             }
 
-            if(!$hasAccess) {
-                throw new RouterException('Method not allowed');
+            $parameters = $this->parseParameters($this->domain, $request->getHost(), '[^.]*');
+
+            if ($parameters !== null) {
+                $this->parameters = $parameters;
+                return true;
             }
 
-            $this->loadMiddleware($request);
-
-            return parent::renderRoute($request);
+            return false;
         }
 
-        // No match here, move on...
-        return null;
+        return true;
+    }
+
+    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');
+        }
+
+        $this->matchDomain($request);
+
+        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;
+    }
+
+    public function getDomain() {
+        return $this->domain;
+    }
+
 }

src/Pecee/SimpleRouter/RouterResource.php

@@ -5,11 +5,8 @@ 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 +42,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 = 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;
@@ -135,18 +128,4 @@ class RouterResource extends RouterEntry {
         $this->controller = $controller;
     }
 
-    /**
-     * @return string
-     */
-    public function getMethod() {
-        return $this->method;
-    }
-
-    /**
-     * @param string $method
-     */
-    public function setMethod($method) {
-        $this->method = $method;
-    }
-
 }

src/Pecee/SimpleRouter/RouterRoute.php

@@ -2,11 +2,12 @@
 
 namespace Pecee\SimpleRouter;
 
+use Pecee\ArrayUtil;
 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,95 +19,31 @@ class RouterRoute extends RouterEntry {
         $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($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 {
-
-                $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) {
+            $this->parameters = $parameters;
+            return true;
         }
 
-        // No match here, move on...
         return null;
     }
 
@@ -122,13 +59,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;

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);
@@ -90,6 +90,18 @@ class SimpleRouter {
         return $group;
     }
 
+    /**
+     * Adds get + post route
+     *
+     * @param string $url
+     * @param function $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);