Merge pull request #494 from skipperbent/v4-development

Version 4.3.0.0

.codeclimate.yml

@@ -1,22 +0,0 @@
-engines:
-  phpmd:
-    enabled: true
-    checks:
-      Design/TooManyPublicMethods:
-        enabled: true
-      Naming/ShortVariable:
-        enabled: true
-      CleanCode/StaticAccess:
-        enabled: true
-      Controversial/CamelCaseMethodName:
-        enabled: true
-  fixme:
-    enabled: true
-  duplication:
-    enabled: true
-    config:
-      languages:
-      - php:
-ratings:
-  paths:
-  - src/**

.github/workflows/ci.yml

@@ -0,0 +1,59 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build-test:
+    runs-on: ${{ matrix.os }}
+
+    env:
+      PHP_EXTENSIONS: json
+      PHP_INI_VALUES: assert.exception=1, zend.assertions=1
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+        php-version:
+          - 7.1
+          - 7.4
+        phpunit-version:
+          - 7.5.20
+        dependencies:
+          - lowest
+          - highest
+    name: PHPUnit Tests
+    steps:
+      - name: Configure git to avoid issues with line endings
+        if: matrix.os == 'windows-latest'
+        run: git config --global core.autocrlf false
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php-version }}
+          tools: composer:v5, phpunit:${{ matrix.phpunit-versions }}
+          coverage: xdebug
+          extensions: ${{ env.PHP_EXTENSIONS }}
+          ini-values: ${{ env.PHP_INI_VALUES }}
+      - name: Get composer cache directory
+        id: composer-cache
+        run: echo "::set-output name=dir::$(composer config cache-files-dir)"
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.composer-cache.outputs.dir }}
+          key: php${{ matrix.php-version }}-composer-${{ matrix.dependencies }}-${{ hashFiles('**/composer.json') }}
+          restore-keys: |
+            php${{ matrix.php-version }}-composer-${{ matrix.dependencies }}-
+      - name: Install lowest dependencies with composer
+        if: matrix.dependencies == 'lowest'
+        run: composer update --no-ansi --no-interaction --no-progress --prefer-lowest
+      - name: Install highest dependencies with composer
+        if: matrix.dependencies == 'highest'
+        run: composer update --no-ansi --no-interaction --no-progress
+      - name: Run tests with phpunit
+        run: composer test

.gitignore

@@ -1,4 +1,4 @@
-.idea
 composer.lock
 vendor/
-tests/tmp/*
+.idea/
+.phpunit.result.cache

.scrutinizer.yml

@@ -1,13 +0,0 @@
-build:
-    tests:
-        override:
-            -
-                command: './vendor/bin/phpunit --coverage-clover=coverage.clover'
-                coverage:
-                    file: 'coverage.clover'
-                    format: 'clover'
-checks:
-    php:
-        code_rating: true
-        duplication: true
-

.travis.yml

@@ -1,13 +0,0 @@
-sudo: false
-
-language: php
-
-php:
-  - 7.1
-
-before_script:
-  - curl -sS http://getcomposer.org/installer | php
-  - php composer.phar install --prefer-source --no-interaction
-
-script:
-  - ./vendor/bin/phpunit

README.md

@@ -1,12 +1,20 @@
 # simple-router
 
-Simple, fast and yet powerful PHP router that is easy to get integrated and in any project. 
-Heavily inspired by the way Laravel handles routing, with both simplicity and expand-ability in mind.
+Simple, fast and yet powerful PHP router that is easy to get integrated and in any project. Heavily inspired by the way Laravel handles routing, with both simplicity and expand-ability in mind.
+
+With simple-router you can create a new project fast, without depending on a framework.
+
+**It only takes a few lines of code to get started:**
+
+```php
+SimpleRouter::get('/', function() {
+    return 'Hello world';
+});
+```
 
 ### Support the project
 
-If you like simple-router and wish to see the continued development and maintenance of the project,
-please consider showing your support by buying me a coffee. Supporters will be listed under the credits section of this documentation.
+If you like simple-router and wish to see the continued development and maintenance of the project, please consider showing your support by buying me a coffee. Supporters will be listed under the credits section of this documentation.
 
 You can donate any amount of your choice by [clicking here](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=NNX4D2RUSALCN).
 
@@ -24,6 +32,7 @@ You can donate any amount of your choice by [clicking here](https://www.paypal.c
 		- [Helper functions](#helper-functions)
 - [Routes](#routes)
 	- [Basic routing](#basic-routing)
+		- [Class hinting](#class-hinting)
 		- [Available methods](#available-methods)
 		- [Multiple HTTP-verbs](#multiple-http-verbs)
 	- [Route parameters](#route-parameters)
@@ -42,9 +51,6 @@ You can donate any amount of your choice by [clicking here](https://www.paypal.c
 	- [Partial groups](#partial-groups)
 	- [Form Method Spoofing](#form-method-spoofing)
 	- [Accessing The Current Route](#accessing-the-current-route)
-	- [Dependency injection](#dependency-injection)
-	    - [Enabling dependency injection](#enabling-dependency-injection)
-	    - [More reading](#more-reading)
 	- [Other examples](#other-examples)
 - [CSRF-protection](#csrf-protection)
 	- [Adding CSRF-verifier](#adding-csrf-verifier)
@@ -76,14 +82,20 @@ You can donate any amount of your choice by [clicking here](https://www.paypal.c
     - [Registering new event](#registering-new-event)
     - [Custom EventHandlers](#custom-eventhandlers)
 - [Advanced](#advanced)
+	- [Disable multiple route rendering](#disable-multiple-route-rendering)
 	- [Url rewriting](#url-rewriting)
 		- [Changing current route](#changing-current-route)
 		- [Bootmanager: loading routes dynamically](#bootmanager-loading-routes-dynamically)
 		- [Adding routes manually](#adding-routes-manually)
+	- [Custom class-loader](#custom-class-loader)
+	  - [Integrating with php-di](#Integrating-with-php-di)
 	- [Parameters](#parameters)
 	- [Extending](#extending)
 - [Help and support](#help-and-support)
     - [Common issues and fixes](#common-issues-and-fixes)
+        - [Multiple routes matches? Which one has the priority?](#multiple-routes-matches-which-one-has-the-priority)
+        - [Parameters won't match or route not working with special characters](#parameters-wont-match-or-route-not-working-with-special-characters)
+        - [Using the router on sub-paths](#using-the-router-on-sub-paths)
     - [Debugging](#debugging)
         - [Creating unit-tests](#creating-unit-tests) 
         - [Debug information](#debug-information)
@@ -111,7 +123,7 @@ composer require pecee/simple-router
 
 The goal of this project is to create a router that is more or less 100% compatible with the Laravel documentation, while remaining as simple as possible, and as easy to integrate and change without compromising either speed or complexity. Being lightweight is the #1 priority.
 
-We've included a simple demo project for the router which can be found in the `demo-project` folder. This project should give you a basic understanding of how to setup and use simple-php-router project.
+We've included a simple demo project for the router which can be found [here](https://github.com/skipperbent/simple-router-demo). This project should give you a basic understanding of how to setup and use simple-php-router project.
 
 Please note that the demo-project only covers how to integrate the `simple-php-router` in a project without an existing framework. If you are using a framework in your project, the implementation might vary.
 
@@ -132,6 +144,7 @@ You can find the demo-project here: [https://github.com/skipperbent/simple-route
 ## Requirements
 
 - PHP 7.1 or greater (version 3.x and below supports PHP 5.5+)
+- PHP JSON extension enabled.
 
 ## Features
 
@@ -229,17 +242,23 @@ Simply create a new `web.config` file in your projects `public` directory and pa
 #### Troubleshooting
 
 If you do not have a `favicon.ico` file in your project, you can get a `NotFoundHttpException` (404 - not found).
+
 To add `favicon.ico` to the IIS ignore-list, add the following line to the `<conditions>` group:
+
 ```
 <add input="{REQUEST_FILENAME}" negate="true" pattern="favicon.ico" ignoreCase="true" />
 ```
 
 You can also make one exception for files with some extensions:
+
 ```
 <add input="{REQUEST_FILENAME}" pattern="\.ico|\.png|\.css|\.jpg" negate="true" ignoreCase="true" />
 ```
 
-If you are using `$_SERVER['ORIG_PATH_INFO']`, you will get `\index.php\` as part of the returned value. For example:
+If you are using `$_SERVER['ORIG_PATH_INFO']`, you will get `\index.php\` as part of the returned value. 
+
+**Example:**
+
 ```
 /index.php/test/mypage.php
 ```
@@ -281,12 +300,10 @@ We recommend that you add these helper functions to your project. These will all
 To implement the functions below, simply copy the code to a new file and require the file before initializing the router or copy the `helpers.php` we've included in this library.
 
 ```php
-<?php
-
 use Pecee\SimpleRouter\SimpleRouter as Router;
-use \Pecee\Http\Url;
-use \Pecee\Http\Response;
-use \Pecee\Http\Request;
+use Pecee\Http\Url;
+use Pecee\Http\Response;
+use Pecee\Http\Request;
 
 /**
  * Get url for a route by using either name/alias, class or method name.
@@ -330,19 +347,14 @@ function request(): Request
 /**
  * Get input class
  * @param string|null $index Parameter index name
- * @param string|null $defaultValue Default return value
- * @param string|array|null $methods Default method
- * @return \Pecee\Http\Input\InputHandler|\Pecee\Http\Input\IInputItem|string
+ * @param string|mixed|null $defaultValue Default return value
+ * @param array ...$methods Default methods
+ * @return \Pecee\Http\Input\InputHandler|array|string|null
  */
-function input($index = null, $defaultValue = null, $methods = null)
+function input($index = null, $defaultValue = null, ...$methods)
 {
     if ($index !== null) {
-
-        if ($defaultValue !== null) {
-            return request()->getInputHandler()->getValue($index, $defaultValue, $methods);
-        }
-
-        return request()->getInputHandler()->get($index, $methods);
+        return request()->getInputHandler()->value($index, $defaultValue, ...$methods);
     }
 
     return request()->getInputHandler();
@@ -388,10 +400,18 @@ Below is a very basic example of setting up a route. First parameter is the url
 
 ```php
 SimpleRouter::get('/', function() {
-	return 'Hello world';
+    return 'Hello world';
 });
 ```
 
+### Class hinting
+
+You can use class hinting to load a class & method like this:
+
+```php
+SimpleRouter::get('/', [MyClass::class, 'myMethod']);
+```
+
 ### Available methods
 
 Here you can see a list over all available routes:
@@ -411,11 +431,11 @@ Sometimes you might need to create a route that accepts multiple HTTP-verbs. If
 
 ```php
 SimpleRouter::match(['get', 'post'], '/', function() {
-	// ...
+    // ...
 });
 
 SimpleRouter::any('foo', function() {
-	// ...
+    // ...
 });
 ```
 
@@ -423,7 +443,7 @@ We've created a simple method which matches `GET` and `POST` which is most commo
 
 ```php
 SimpleRouter::form('foo', function() {
-	// ...
+    // ...
 });
 ```
 
@@ -435,7 +455,7 @@ You'll properly wondering by know how you parse parameters from your urls. For e
 
 ```php
 SimpleRouter::get('/user/{id}', function ($userId) {
-	return 'User with id: ' . $userId;
+    return 'User with id: ' . $userId;
 });
 ```
 
@@ -443,7 +463,7 @@ You may define as many route parameters as required by your route:
 
 ```php
 SimpleRouter::get('/posts/{post}/comments/{comment}', function ($postId, $commentId) {
-	// ...
+    // ...
 });
 ```
 
@@ -455,11 +475,11 @@ Occasionally you may need to specify a route parameter, but make the presence of
 
 ```php
 SimpleRouter::get('/user/{name?}', function ($name = null) {
-	return $name;
+    return $name;
 });
 
 SimpleRouter::get('/user/{name?}', function ($name = 'Simon') {
-	return $name;
+    return $name;
 });
 ```
 
@@ -469,15 +489,21 @@ You may constrain the format of your route parameters using the where method on
 
 ```php
 SimpleRouter::get('/user/{name}', function ($name) {
-    //
-})->where('name', '[A-Za-z]+');
+    
+    // ... do stuff
+    
+})->where([ 'name' => '[A-Za-z]+' ]);
 
 SimpleRouter::get('/user/{id}', function ($id) {
-    //
-})->where('id', '[0-9]+');
+    
+    // ... do stuff
+    
+})->where([ 'id' => '[0-9]+' ]);
 
 SimpleRouter::get('/user/{id}/{name}', function ($id, $name) {
-    //
+    
+    // ... do stuff
+    
 })->where(['id' => '[0-9]+', 'name' => '[a-z]+']);
 ```
 
@@ -504,10 +530,12 @@ SimpleRouter::all('/ajax/abc/123', function($param1, $param2) {
 
 ### Custom regex for matching parameters
 
-By default simple-php-router uses the `\w` regular expression when matching parameters.
+By default simple-php-router uses the `[\w\-]+` regular expression. It will match `A-Z`, `a-z`, `0-9`, `-` and `_` characters in parameters.
 This decision was made with speed and reliability in mind, as this match will match both letters, number and most of the used symbols on the internet.
 
-However, sometimes it can be necessary to add a custom regular expression to match more advanced characters like `-` etc.
+However, sometimes it can be necessary to add a custom regular expression to match more advanced characters like foreign letters `æ ø å` etc.
+
+You can test your custom regular expression by using on the site [Regex101.com](https://www.regex101.com).
 
 Instead of adding a custom regular expression to all your parameters, you can simply add a global regular expression which will be used on all the parameters on the route.
 
@@ -515,16 +543,16 @@ Instead of adding a custom regular expression to all your parameters, you can si
 
 #### Example
 
-This example will ensure that all parameters use the `[\w\-]+` regular expression when parsing.
+This example will ensure that all parameters use the `[\w\-\æ\ø\å]+` (`a-z`, `A-Z`, `-`, `_`, `0-9`, `æ`, `ø`, `å`) regular expression when parsing.
 
 ```php
-SimpleRouter::get('/path/{parameter}', 'VideoController@home', ['defaultParameterRegex' => '[\w\-]+']);
+SimpleRouter::get('/path/{parameter}', 'VideoController@home', ['defaultParameterRegex' => '[\w\-\æ\ø\å]+']);
 ```
 
 You can also apply this setting to a group if you need multiple routes to use your custom regular expression when parsing parameters.
 
 ```php
-SimpleRouter::group(['defaultParameterRegex' => '[\w\-]+'], function() {
+SimpleRouter::group(['defaultParameterRegex' => '[\w\-\æ\ø\å]+'], function() {
 
     SimpleRouter::get('/path/{parameter}', 'VideoController@home');
 
@@ -630,6 +658,7 @@ SimpleRouter::group(['prefix' => '/admin'], function () {
 ## Partial groups
 
 Partial router groups has the same benefits as a normal group, but supports parameters and are only rendered once the url has matched.
+Partial groups will render once a part of the url has matched.
 
 This can be extremely useful in situations, where you only want special routes to be added, when a certain criteria or logic has been met.
 
@@ -638,11 +667,11 @@ This can be extremely useful in situations, where you only want special routes t
 **Example:**
 
 ```php
-SimpleRouter::partialGroup('/admin/{applicationId}', function ($applicationId) {
+SimpleRouter::partialGroup('/lang/{language}', function ($language) {
 
-    SimpleRouter::get('/', function($applicationId) {
+    SimpleRouter::get('/', function($language) {
 
-        // Matches The "/admin/applicationId" URL
+        // Matches The "/lang/da" URL
 
     });
 
@@ -667,88 +696,6 @@ SimpleRouter::request()->getLoadedRoute();
 request()->getLoadedRoute();
 ```
 
-## Dependency injection
-
-simple-router supports dependency injection using the [`php-di`](http://php-di.org/) library.
-
-Dependency injection allows the framework to automatically "inject" (load) classes added as parameters. This can simplify your code, as you can avoid creating new instances of objects you are using often in your `Controllers` etc.
-
-Here's a basic example of a controller class using dependency injection:
-
-```php
-namespace Demo\Controllers;
-
-class DefaultController {
-    
-    public function login(User $user): string 
-    {
-        // ...
-    }
-    
-}
-```
-
-The example above will automatically create a new instance of the `User` from the `$user` parameter. This means that the `$user` class contains a new instance of the `User` class and we won't need to create a new instance our self.
-
-**WARNING:** dependency injection can have some negative impact in performance. If you experience any performance issues, we recommend disabling this functionality.
-
-### Enabling dependency injection
-
-Dependency injection is disabled per default to avoid any performance issues.
-
-Before enabling dependency injection, we recommend that you read the [Container configuration](http://php-di.org/doc/container-configuration.html) section of the php-di documentation. This section covers how to configure php-di to different environments and speed-up the performance.
-
-#### Enabling for development environment
-
-The example below should ONLY be used on a development environment.
-
-```php
-// Create our new php-di container
-$container = (new \DI\ContainerBuilder())
-            ->useAutowiring(true)
-            ->build();
-
-// Add our container to simple-router and enable dependency injection
-SimpleRouter::enableDependencyInjection($container);
-```
-
-Please check the [More reading](#more-reading) section of the documentation for useful php-di links and tutorials.
-
-#### Enabling for production environment
-
-The example below compiles the injections, which can help speed up performance. 
-
-**Note:** You should change the `$cacheDir` to a cache-storage within your project.
-
-```php
-// Cache directory
-$cacheDir = sys_get_temp_dir('simple-router');
-
-// Create our new php-di container
-$container = (new \DI\ContainerBuilder())
-            ->enableCompilation($cacheDir)
-            ->writeProxiesToFile(true, $cacheDir . '/proxies')
-            ->useAutowiring(true)
-            ->build();
-
-// Add our container to simple-router and enable dependency injection
-SimpleRouter::enableDependencyInjection($container);
-```
-
-Please check the [More reading](#more-reading) section of the documentation for useful php-di links and tutorials.
-
-### More reading
-
-For more information about dependency injection, configuration and settings - we recommend that you check the php-di documentation or some of the useful links we've gathered below.
-
-#### Useful links
-
-- [php-di documentation](http://php-di.org/doc/)
-- [Understanding dependency injection](http://php-di.org/doc/understanding-di.html)
-- [Best practices guide](http://php-di.org/doc/best-practices.html)
-- [Configuring the container](http://php-di.org/doc/container-configuration.html)
-- [Definitions](http://php-di.org/doc/definition.html)
-
 ## Other examples
 
 You can find many more examples in the `routes.php` example-file below:
@@ -765,12 +712,17 @@ SimpleRouter::group(['middleware' => \Demo\Middlewares\Site::class, 'exceptionHa
 
     SimpleRouter::get('/answers/{id}', 'ControllerAnswers@show', ['where' => ['id' => '[0-9]+']]);
 
+	/**
+     * Class hinting is supported too
+     */
+     
+     SimpleRouter::get('/answers/{id}', [ControllerAnswers::class, 'show'], ['where' => ['id' => '[0-9]+']]);
 
     /**
      * Restful resource (see IRestController interface for available methods)
      */
 
-    SimpleRouter::resource('/rest', ControllerRessource::class);
+    SimpleRouter::resource('/rest', ControllerResource::class);
 
 
     /**
@@ -791,7 +743,6 @@ SimpleRouter::group(['middleware' => \Demo\Middlewares\Site::class, 'exceptionHa
 });
 
 SimpleRouter::get('/page/404', 'ControllerPage@notFound', ['as' => 'page.notfound']);
-
 ```
 
 ---
@@ -1141,9 +1092,7 @@ In the example below, we check if the current url contains the `/api` part.
 
 ```php
 if(url()->contains('/api')) {
-    
     // ... do stuff
-    
 }
 ```
 
@@ -1161,88 +1110,82 @@ For more available methods please check the `Pecee\Http\Url` class.
 
 # Input & parameters
 
+simple-router offers libraries and helpers that makes it easy to manage and manipulate input-parameters like `$_POST`, `$_GET` and `$_FILE`.
+
 ## Using the Input class to manage parameters
 
-We've added the `Input` class to easy access and manage parameters from your Controller-classes.
+You can use the `InputHandler` class to easily access and manage parameters from your request. The `InputHandler` class offers extended features such as copying/moving uploaded files directly on the object, getting file-extension, mime-type etc.
 
-### Get single parameter value:
+### Get single parameter value
 
-If items is grouped in the html, it will return an array of items.
+```input($index, $defaultValue, ...$methods);```
 
-**Note:** `get` will automatically trim the value and ensure that it's not empty. If it's empty the `$defaultValue` will be returned.
+To quickly get a value from a parameter, you can use the `input` helper function.
+
+This will automatically trim the value and ensure that it's not empty. If it's empty the `$defaultValue` will be returned instead.
+
+**Note:** 
+This function returns a `string` unless the parameters are grouped together, in that case it will return an `array` of values.
+
+**Example:**
+
+This example matches both POST and GET request-methods and if name is empty the default-value "Guest" will be returned. 
 
 ```php
-$value = input($index, $defaultValue, $methods);
+$name = input('name', 'Guest', 'post', 'get');
 ```
 
 ### Get parameter object
 
-Will return an instance of `InputItem` or `InputFile` depending on the type.
+When dealing with file-uploads it can be useful to retrieve the raw parameter object.
 
-You can use this in your html as it will render the value of the item.
-However if you want to compare value in your if statements, you have to use
-the `getValue` or use the `input()` instead.
+**Search for object with default-value across multiple or specific request-methods:**
 
-If items is grouped in the html, it will return an array of items.
-
-**Note:** `getObject` will only return `$defaultValue` if the item doesn't exist. If you want `$defaultValue` to be returned if the item is empty, please use `input()` instead.
+The example below will return an `InputItem` object if the parameter was found or return the `$defaultValue`. If parameters are grouped, it will return an array of `InputItem` objects.
 
 ```php
-$object = input()->getObject($index, $defaultValue = null, $methods = null);
+$object = input()->find($index, $defaultValue = null, ...$methods);
 ```
 
-### Return specific GET parameter (where name is the name of your parameter):
+**Getting specific `$_GET` parameter as `InputItem` object:**
+
+The example below will return an `InputItem` object if the parameter was found or return the `$defaultValue`. If parameters are grouped, it will return an array of `InputItem` objects.
 
 ```php
-# -- match any (default) --
+$object = input()->get($index, $defaultValue = null);
+```
 
-/*
- * This is the recommended way to go for normal usage
- * as it will strip empty values, ensuring that
- * $defaultValue is returned if the value is empty.
- */
+**Getting specific `$_POST` parameter as `InputItem` object:**
 
-$id = input()->getValue($index, $defaultValue, $method);
+The example below will return an `InputItem` object if the parameter was found or return the `$defaultValue`. If parameters are grouped, it will return an array of `InputItem` objects.
 
-# -- shortcut to above --
+```php
+$object = input()->post($index, $defaultValue = null);
+```
 
-$id = input($index, $defaultValue, $method);
+**Getting specific `$_FILE` parameter as `InputFile` object:**
 
-# -- match specific --
+The example below will return an `InputFile` object if the parameter was found or return the `$defaultValue`. If parameters are grouped, it will return an array of `InputFile` objects.
 
-$object = input($index, $defaultValue, 'get');
-$object = input($index, $defaultValue, 'post');
-$object = input($index, $defaultValue, 'file');
-
-# -- or --
-
-$object = input()->findGet($index, $defaultValue);
-$object = input()->findPost($index, $defaultValue);
-$object = input()->findFile($index, $defaultValue);
-
-# -- get the full object --
-
-$object = input()->get($index, 'post', 'get');
+```php
+$object = input()->file($index, $defaultValue = null);
 ```
 
 ### Managing files
 
 ```php
 /**
- * In this small example we loop through a collection of files
- * added on the page like this
+ * Loop through a collection of files uploaded from a form on the page like this
  * <input type="file" name="images[]" />
  */
 
 /* @var $image \Pecee\Http\Input\InputFile */
-foreach(input('images', []) as $image)
+foreach(input()->file('images', []) as $image)
 {
-    if($image->getMime() === 'image/jpeg') {
-
+    if($image->getMime() === 'image/jpeg') 
+    {
         $destinationFilname = sprintf('%s.%s', uniqid(), $image->getExtension());
-
-        $image->move('/uploads/' . $destinationFilename);
-
+        $image->move(sprintf('/uploads/%s', $destinationFilename));
     }
 }
 
@@ -1251,10 +1194,10 @@ foreach(input('images', []) as $image)
 ### Get all parameters
 
 ```php
-// Get all
+# Get all
 $values = input()->all();
 
-// Only match certain keys
+# Only match specific keys
 $values = input()->all([
     'company_name',
     'user_id'
@@ -1268,6 +1211,7 @@ All object implements the `IInputItem` interface and will always contain these m
 - `getValue()` - returns the value of the input.
 
 `InputFile` has the same methods as above along with some other file-specific methods like:
+
 - `getFilename` - get the filename.
 - `getTmpName()` - get file temporary name.
 - `getSize()` - get file size.
@@ -1275,16 +1219,9 @@ All object implements the `IInputItem` interface and will always contain these m
 - `getContents()` - get file content.
 - `getType()` - get mime-type for file.
 - `getError()` - get file upload error.
-- `hasError()` - returns `bool` if an error occurred while uploading (if getError is not 0).
+- `hasError()` - returns `bool` if an error occurred while uploading (if `getError` is not 0).
 - `toArray()` - returns raw array
 
-Below example requires you to have the helper functions added. Please refer to the helper functions section in the documentation.
-
-```php
-/* Get parameter site_id or default-value 2 from either post-value or query-string */
-$siteId = input('site_id', 2, ['post', 'get']);
-```
-
 ---
 
 # Events
@@ -1303,6 +1240,7 @@ All event callbacks will retrieve a `EventArgument` object as parameter. This ob
 | `EVENT_ALL`                 | - | Fires when a event is triggered. |
 | `EVENT_INIT`                | - | Fires when router is initializing and before routes are loaded. |
 | `EVENT_LOAD`                | `loadedRoutes` | Fires when all routes has been loaded and rendered, just before the output is returned. |
+| `EVENT_ADD_ROUTE`           | `route` | Fires when route is added to the router. |
 | `EVENT_REWRITE`             | `rewriteUrl`<br>`rewriteRoute` | Fires when a url-rewrite is and just before the routes are re-initialized. |
 | `EVENT_BOOT`                | `bootmanagers` | Fires when the router is booting. This happens just before boot-managers are rendered and before any routes has been loaded. |
 | `EVENT_RENDER_BOOTMANAGER`  | `bootmanagers`<br>`bootmanager` | Fires before a boot-manager is rendered. |
@@ -1424,6 +1362,12 @@ class DatabaseDebugHandler implements IEventHandler
 
 # Advanced
 
+## Disable multiple route rendering
+
+By default the router will try to execute all routes that matches a given url. To stop the router from executing any further routes any method can return a value.
+
+This behavior can be easily disabled by setting `SimpleRouter::enableMultiRouteRendering(false)` in your `routes.php` file. This is the same behavior as version 3 and below.
+
 ## Url rewriting
 
 ### Changing current route
@@ -1475,7 +1419,7 @@ class CustomRouterRules implement IRouterBootManager
 
             // If the current url matches the rewrite url, we use our custom route
 
-            if($request->getUrl()->getPath() === $url) {
+            if($request->getUrl()->contains($url)) {
                 $request->setRewriteUrl($rule);
             }
         }
@@ -1523,6 +1467,119 @@ $route->setPrefix('v1');
 $router->addRoute($route);
 ```
 
+## Custom class loader
+
+You can easily extend simple-router to support custom injection frameworks like php-di by taking advantage of the ability to add your custom class-loader.
+
+Class-loaders must inherit the `IClassLoader` interface.
+
+**Example:**
+
+```php
+class MyCustomClassLoader implements IClassLoader
+{
+    /**
+     * Load class
+     *
+     * @param string $class
+     * @return object
+     * @throws NotFoundHttpException
+     */
+    public function loadClass(string $class)
+    {
+        if (\class_exists($class) === false) {
+            throw new NotFoundHttpException(sprintf('Class "%s" does not exist', $class), 404);
+        }
+
+        return new $class();
+    }
+
+    /**
+     * Load closure
+     *
+     * @param Callable $closure
+     * @param array $parameters
+     * @return mixed
+     */
+    public function loadClosure(Callable $closure, array $parameters)
+    {
+        return \call_user_func_array($closure, $parameters);
+    }
+
+}
+```
+
+Next, we need to configure our `routes.php` so the router uses our `MyCustomClassLoader` class for loading classes. This can be done by adding the following line to your `routes.php` file.
+
+```php
+SimpleRouter::setCustomClassLoader(new MyCustomClassLoader());
+```
+
+### Integrating with php-di
+
+php-di support was discontinued by version 4.3, however you can easily add it again by creating your own class-loader like the example below:
+
+```php
+class MyCustomClassLoader implements IClassLoader
+{
+
+    protected $container;
+
+    public function __construct()
+    {
+        // Create our new php-di container
+        $container = (new \DI\ContainerBuilder())
+                    ->useAutowiring(true)
+                    ->build();
+    }
+
+    /**
+     * Load class
+     *
+     * @param string $class
+     * @return object
+     * @throws NotFoundHttpException
+     */
+    public function loadClass(string $class)
+    {
+        if (class_exists($class) === false) {
+            throw new NotFoundHttpException(sprintf('Class "%s" does not exist', $class), 404);
+        }
+
+        if ($this->container !== null) {
+            try {
+                return $this->container->get($class);
+            } catch (\Exception $e) {
+                throw new NotFoundHttpException($e->getMessage(), (int)$e->getCode(), $e->getPrevious());
+            }
+        }
+
+        return new $class();
+    }
+
+    /**
+     * Load closure
+     *
+     * @param Callable $closure
+     * @param array $parameters
+     * @return mixed
+     */
+    public function loadClosure(Callable $closure, array $parameters)
+    {
+        if ($this->container !== null) {
+            try {
+                return $this->container->call($closure, $parameters);
+            } catch (\Exception $e) {
+                throw new NotFoundHttpException($e->getMessage(), (int)$e->getCode(), $e->getPrevious());
+            }
+        }
+
+        return \call_user_func_array($closure, $parameters);
+    }
+
+}
+```
+
 ## Parameters
 
 This section contains advanced tips & tricks on extending the usage for parameters.
@@ -1566,6 +1623,51 @@ This section will go into details on how to debug the router and answer some of
 
 This section will go over common issues and how to resolve them.
 
+### Parameters won't match or route not working with special characters
+
+Often people experience this issue when one or more parameters contains special characters. The router uses a sparse regular-expression that matches letters from a-z along with numbers when matching parameters, to improve performance. 
+
+All other characters has to be defined via the `defaultParameterRegex` option on your route.
+
+You can read more about adding your own custom regular expression for matching parameters by [clicking here](#custom-regex-for-matching-parameters).
+
+### Multiple routes matches? Which one has the priority?
+
+The router will match routes in the order they're added.
+
+It's possible to render multiple routes.
+
+If you want the router to stop when a route is matched, you simply return a value in your callback or stop the execution manually (using `response()->json()` etc.). 
+
+Any returned objects that implements the `__toString()` magic method will also prevent other routes from being rendered. 
+
+### Using the router on sub-paths
+
+Using the library on a sub-path like `localhost/project/` is not officially supported, however it is possible to get it working quite easily.
+
+Add an event that appends your sub-path when a new loadable route is added.
+
+**Example:**
+
+```php
+// ... your routes.php file
+
+if($isRunningLocally) {
+
+    $eventHandler = new EventHandler();
+    $eventHandler->register(EventHandler::EVENT_ADD_ROUTE, function (EventArgument $arg) use (&$status) {
+
+        if ($arg->route instanceof \Pecee\SimpleRouter\Route\LoadableRoute) {
+            $arg->route->prependUrl('/local-path');
+        }
+
+    });
+
+    TestRouter::addEventHandler($eventHandler);
+
+}
+```
+
 ## Debugging
 
 This section will show you how to write unit-tests for the router, view useful debugging information and answer some of the frequently asked questions. 
@@ -1804,4 +1906,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

@@ -28,12 +28,17 @@
   ],
   "require": {
     "php": ">=7.1",
-    "php-di/php-di": "^6.0"
+    "ext-json": "*"
   },
   "require-dev": {
-    "phpunit/phpunit": "^6.0",
+    "phpunit/phpunit": "^7",
     "mockery/mockery": "^1"
   },
+  "scripts": {
+    "test": [
+      "phpunit tests"
+    ]
+  },
   "autoload": {
     "psr-4": {
       "Pecee\\": "src/Pecee/"

helpers.php

@@ -1,9 +1,9 @@
 <?php
 
 use Pecee\SimpleRouter\SimpleRouter as Router;
-use \Pecee\Http\Url;
-use \Pecee\Http\Response;
-use \Pecee\Http\Request;
+use Pecee\Http\Url;
+use Pecee\Http\Response;
+use Pecee\Http\Request;
 
 /**
  * Get url for a route by using either name/alias, class or method name.
@@ -47,19 +47,14 @@ function request(): Request
 /**
  * Get input class
  * @param string|null $index Parameter index name
- * @param string|null $defaultValue Default return value
- * @param string|array|null $methods Default method
- * @return \Pecee\Http\Input\InputHandler|\Pecee\Http\Input\IInputItem|string
+ * @param string|mixed|null $defaultValue Default return value
+ * @param array ...$methods Default methods
+ * @return \Pecee\Http\Input\InputHandler|array|string|null
  */
-function input($index = null, $defaultValue = null, $methods = null)
+function input($index = null, $defaultValue = null, ...$methods)
 {
     if ($index !== null) {
-
-        if ($defaultValue !== null) {
-            return request()->getInputHandler()->getValue($index, $defaultValue, $methods);
-        }
-
-        return request()->getInputHandler()->get($index, $methods);
+        return request()->getInputHandler()->value($index, $defaultValue, ...$methods);
     }
 
     return request()->getInputHandler();

phpunit.xml

@@ -9,15 +9,15 @@
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
         processIsolation="false"
-        stopOnFailure="false"
-        syntaxCheck="false">
+        stopOnFailure="false">
     <testsuites>
         <testsuite name="SimpleRouter Test Suite">
             <directory>tests/Pecee/SimpleRouter/</directory>
         </testsuite>
     </testsuites>
     <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
+        <whitelist addUncoveredFilesFromWhitelist="true"
+                   processUncoveredFilesFromWhitelist="true">
             <directory suffix=".php">src</directory>
         </whitelist>
     </filter>

src/Pecee/Http/Input/IInputItem.php

@@ -9,14 +9,14 @@ interface IInputItem
 
     public function setIndex(string $index): self;
 
-    public function getName(): string;
+    public function getName(): ?string;
 
     public function setName(string $name): self;
 
-    public function getValue(): string;
+    public function getValue();
 
-    public function setValue(string $value): self;
+    public function setValue($value): self;
 
-    public function __toString();
+    public function __toString(): string;
 
 }

src/Pecee/Http/Input/InputFile.php

@@ -49,7 +49,7 @@ class InputFile implements IInputItem
 
         return (new static($values['index']))
             ->setSize((int)$values['size'])
-            ->setError($values['error'])
+            ->setError((int)$values['error'])
             ->setType($values['type'])
             ->setTmpName($values['tmp_name'])
             ->setFilename($values['name']);
@@ -140,7 +140,7 @@ class InputFile implements IInputItem
      *
      * @return string
      */
-    public function getName(): string
+    public function getName(): ?string
     {
         return $this->name;
     }
@@ -177,7 +177,7 @@ class InputFile implements IInputItem
      *
      * @return string mixed
      */
-    public function getFilename(): string
+    public function getFilename(): ?string
     {
         return $this->filename;
     }
@@ -216,11 +216,11 @@ class InputFile implements IInputItem
     /**
      * Get upload-error code.
      *
-     * @return string
+     * @return int
      */
-    public function getError(): string
+    public function getError(): int
     {
-        return $this->errors;
+        return (int)$this->errors;
     }
 
     /**
@@ -256,21 +256,21 @@ class InputFile implements IInputItem
         return $this;
     }
 
-    public function __toString()
+    public function __toString(): string
     {
         return $this->getTmpName();
     }
 
-    public function getValue(): string
+    public function getValue()
     {
         return $this->getFilename();
     }
 
     /**
-     * @param string $value
+     * @param mixed $value
      * @return static
      */
-    public function setValue(string $value): IInputItem
+    public function setValue($value): IInputItem
     {
         $this->filename = $value;
 

src/Pecee/Http/Input/InputHandler.php

@@ -10,23 +10,41 @@ class InputHandler
     /**
      * @var array
      */
-    public $get = [];
+    protected $get = [];
 
     /**
      * @var array
      */
-    public $post = [];
+    protected $post = [];
 
     /**
      * @var array
      */
-    public $file = [];
+    protected $file = [];
 
     /**
      * @var Request
      */
     protected $request;
 
+    /**
+     * Original post variables
+     * @var array
+     */
+    protected $originalPost = [];
+
+    /**
+     * Original get/params variables
+     * @var array
+     */
+    protected $originalParams = [];
+
+    /**
+     * Get original file variables
+     * @var array
+     */
+    protected $originalFile = [];
+
     /**
      * Input constructor.
      * @param Request $request
@@ -46,38 +64,59 @@ class InputHandler
     {
         /* Parse get requests */
         if (\count($_GET) !== 0) {
-            $this->get = $this->handleGetPost($_GET);
+            $this->originalParams = $_GET;
+            $this->get = $this->parseInputItem($this->originalParams);
         }
 
         /* Parse post requests */
-        $postVars = $_POST;
+        $this->originalPost = $_POST;
 
-        if (\in_array($this->request->getMethod(), ['put', 'patch', 'delete'], false) === true) {
-            parse_str(file_get_contents('php://input'), $postVars);
+        if ($this->request->isPostBack() === true) {
+
+            $contents = file_get_contents('php://input');
+
+            // Append any PHP-input json
+            if (strpos(trim($contents), '{') === 0) {
+                $post = json_decode($contents, true);
+
+                if ($post !== false) {
+                    $this->originalPost += $post;
+                }
+            }
         }
 
-        if (\count($postVars) !== 0) {
-            $this->post = $this->handleGetPost($postVars);
+        if (\count($this->originalPost) !== 0) {
+            $this->post = $this->parseInputItem($this->originalPost);
         }
 
         /* Parse get requests */
         if (\count($_FILES) !== 0) {
-            $this->file = $this->parseFiles();
+            $this->originalFile = $_FILES;
+            $this->file = $this->parseFiles($this->originalFile);
         }
     }
 
     /**
+     * @param array $files Array with files to parse
+     * @param string|null $parentKey Key from parent (used when parsing nested array).
      * @return array
      */
-    public function parseFiles(): array
+    public function parseFiles(array $files, ?string $parentKey = null): array
     {
         $list = [];
 
-        foreach ((array)$_FILES as $key => $value) {
+        foreach ($files as $key => $value) {
+
+            // Parse multi dept file array
+            if(isset($value['name']) === false && \is_array($value) === true) {
+                $list[$key] = $this->parseFiles($value, $key);
+                continue;
+            }
 
             // Handle array input
             if (\is_array($value['name']) === false) {
-                $values['index'] = $key;
+                $values['index'] = $parentKey ?? $key;
+
                 try {
                     $list[$key] = InputFile::createFromArray($values + $value);
                 } catch (InvalidArgumentException $e) {
@@ -87,7 +126,7 @@ class InputHandler
             }
 
             $keys = [$key];
-            $files = $this->rearrangeFiles($value['name'], $keys, $value);
+            $files = $this->rearrangeFile($value['name'], $keys, $value);
 
             if (isset($list[$key]) === true) {
                 $list[$key][] = $files;
@@ -100,9 +139,16 @@ class InputHandler
         return $list;
     }
 
-    protected function rearrangeFiles(array $values, &$index, $original): array
+    /**
+     * Rearrange multi-dimensional file object created by PHP.
+     *
+     * @param array $values
+     * @param array $index
+     * @param array|null $original
+     * @return array
+     */
+    protected function rearrangeFile(array $values, &$index, $original): array
     {
-
         $originalIndex = $index[0];
         array_shift($index);
 
@@ -138,7 +184,7 @@ class InputHandler
 
             $index[] = $key;
 
-            $files = $this->rearrangeFiles($value, $index, $original);
+            $files = $this->rearrangeFile($value, $index, $original);
 
             if (isset($output[$key]) === true) {
                 $output[$key][] = $files;
@@ -151,34 +197,117 @@ class InputHandler
         return $output;
     }
 
-    protected function handleGetPost(array $array): array
+    /**
+     * Parse input item from array
+     *
+     * @param array $array
+     * @return array
+     */
+    protected function parseInputItem(array $array): array
     {
         $list = [];
 
         foreach ($array as $key => $value) {
 
             // Handle array input
-            if (\is_array($value) === false) {
-                $list[$key] = new InputItem($key, $value);
-                continue;
+            if (\is_array($value) === true) {
+                $value = $this->parseInputItem($value);
             }
 
-            $output = $this->handleGetPost($value);
-
-            $list[$key] = $output;
+            $list[$key] = new InputItem($key, $value);
         }
 
         return $list;
     }
 
+    /**
+     * Find input object
+     *
+     * @param string $index
+     * @param array ...$methods
+     * @return IInputItem|array|null
+     */
+    public function find(string $index, ...$methods)
+    {
+        $element = null;
+
+        if (\count($methods) === 0 || \in_array(Request::REQUEST_TYPE_GET, $methods, true) === true) {
+            $element = $this->get($index);
+        }
+
+        if (($element === null && \count($methods) === 0) || (\count($methods) !== 0 && \in_array(Request::REQUEST_TYPE_POST, $methods, true) === true)) {
+            $element = $this->post($index);
+        }
+
+        if (($element === null && \count($methods) === 0) || (\count($methods) !== 0 && \in_array('file', $methods, true) === true)) {
+            $element = $this->file($index);
+        }
+
+        return $element;
+    }
+
+    protected function getValueFromArray(array $array): array
+    {
+        $output = [];
+        /* @var $item InputItem */
+        foreach ($array as $key => $item) {
+
+            if ($item instanceof IInputItem) {
+                $item = $item->getValue();
+            }
+
+            $output[$key] = \is_array($item) ? $this->getValueFromArray($item) : $item;
+        }
+
+        return $output;
+    }
+
+    /**
+     * Get input element value matching index
+     *
+     * @param string $index
+     * @param string|mixed|null $defaultValue
+     * @param array ...$methods
+     * @return string|array
+     */
+    public function value(string $index, $defaultValue = null, ...$methods)
+    {
+        $input = $this->find($index, ...$methods);
+
+        if ($input instanceof IInputItem) {
+            $input = $input->getValue();
+        }
+
+        /* Handle collection */
+        if (\is_array($input) === true) {
+            $output = $this->getValueFromArray($input);
+
+            return (\count($output) === 0) ? $defaultValue : $output;
+        }
+
+        return ($input === null || (\is_string($input) && trim($input) === '')) ? $defaultValue : $input;
+    }
+
+    /**
+     * Check if a input-item exist
+     *
+     * @param string $index
+     * @param array ...$methods
+     * @return bool
+     */
+    public function exists(string $index, ...$methods): bool
+    {
+        return $this->value($index, null, ...$methods) !== null;
+    }
+
     /**
      * Find post-value by index or return default value.
      *
      * @param string $index
      * @param string|null $defaultValue
-     * @return InputItem|string
+     * @return InputItem|array|string|null
      */
-    public function findPost(string $index, ?string $defaultValue = null)
+    public function post(string $index, ?string $defaultValue = null)
     {
         return $this->post[$index] ?? $defaultValue;
     }
@@ -188,9 +317,9 @@ class InputHandler
      *
      * @param string $index
      * @param string|null $defaultValue
-     * @return InputFile|string
+     * @return InputFile|array|string|null
      */
-    public function findFile(string $index, ?string $defaultValue = null)
+    public function file(string $index, ?string $defaultValue = null)
     {
         return $this->file[$index] ?? $defaultValue;
     }
@@ -200,96 +329,126 @@ class InputHandler
      *
      * @param string $index
      * @param string|null $defaultValue
-     * @return InputItem|string
+     * @return InputItem|array|string|null
      */
-    public function findGet(string $index, ?string $defaultValue = null)
+    public function get(string $index, ?string $defaultValue = null)
     {
         return $this->get[$index] ?? $defaultValue;
     }
 
-    /**
-     * Get input object
-     *
-     * @param string $index
-     * @param array ...$methods
-     * @return IInputItem|null
-     */
-    public function get(string $index, ...$methods): ?IInputItem
-    {
-        $element = null;
-
-        if (\count($methods) === 0 || \in_array('get', $methods, true) === true) {
-            $element = $this->findGet($index);
-        }
-
-        if (($element === null && \count($methods) === 0) || (\count($methods) === 0 && \in_array('post', $methods, true) === true)) {
-            $element = $this->findPost($index);
-        }
-
-        if (($element === null && \count($methods) === 0) || (\count($methods) === 0 && \in_array('file', $methods, true) === true)) {
-            $element = $this->findFile($index);
-        }
-
-        return $element;
-    }
-
-    /**
-     * Get input element value matching index
-     *
-     * @param string $index
-     * @param string|null $defaultValue
-     * @param array ...$methods
-     * @return string
-     */
-    public function getValue(string $index, ?string $defaultValue = null, ...$methods): ?string
-    {
-        $input = $this->get($index, $methods);
-
-        if ($input !== null) {
-            return (trim($input->getValue()) === '') ? $defaultValue : $input->getValue();
-        }
-
-        return $input;
-    }
-
-    /**
-     * Check if a input-item exist
-     *
-     * @param string $index
-     * @param array ...$method
-     * @return bool
-     */
-    public function exists(string $index, ...$method): bool
-    {
-        return $this->get($index, $method) !== null;
-    }
-
     /**
      * Get all get/post items
-     * @param array|null $filter Only take items in filter
+     * @param array $filter Only take items in filter
      * @return array
      */
-    public function all(array $filter = null): array
+    public function all(array $filter = []): array
     {
-        $output = $_GET;
+        $output = $this->originalParams + $this->originalPost + $this->originalFile;
+        $output = (\count($filter) > 0) ? \array_intersect_key($output, \array_flip($filter)) : $output;
 
-        if ($this->request->getMethod() === 'post') {
-
-            // Append POST data
-            $output += $_POST;
-
-            $contents = file_get_contents('php://input');
-
-            // Append any PHP-input json
-            if (strpos(trim($contents), '{') === 0) {
-                $post = json_decode($contents, true);
-                if ($post !== false) {
-                    $output += $post;
-                }
+        foreach ($filter as $filterKey) {
+            if (array_key_exists($filterKey, $output) === false) {
+                $output[$filterKey] = null;
             }
         }
 
-        return ($filter !== null) ? array_intersect_key($output, array_flip($filter)) : $output;
+        return $output;
+    }
+
+    /**
+     * Add GET parameter
+     *
+     * @param string $key
+     * @param InputItem $item
+     */
+    public function addGet(string $key, InputItem $item): void
+    {
+        $this->get[$key] = $item;
+    }
+
+    /**
+     * Add POST parameter
+     *
+     * @param string $key
+     * @param InputItem $item
+     */
+    public function addPost(string $key, InputItem $item): void
+    {
+        $this->post[$key] = $item;
+    }
+
+    /**
+     * Add FILE parameter
+     *
+     * @param string $key
+     * @param InputFile $item
+     */
+    public function addFile(string $key, InputFile $item): void
+    {
+        $this->file[$key] = $item;
+    }
+
+    /**
+     * Get original post variables
+     * @return array
+     */
+    public function getOriginalPost(): array
+    {
+        return $this->originalPost;
+    }
+
+    /**
+     * Set original post variables
+     * @param array $post
+     * @return static $this
+     */
+    public function setOriginalPost(array $post): self
+    {
+        $this->originalPost = $post;
+
+        return $this;
+    }
+
+    /**
+     * Get original get variables
+     * @return array
+     */
+    public function getOriginalParams(): array
+    {
+        return $this->originalParams;
+    }
+
+    /**
+     * Set original get-variables
+     * @param array $params
+     * @return static $this
+     */
+    public function setOriginalParams(array $params): self
+    {
+        $this->originalParams = $params;
+
+        return $this;
+    }
+
+    /**
+     * Get original file variables
+     * @return array
+     */
+    public function getOriginalFile(): array
+    {
+        return $this->originalFile;
+    }
+
+    /**
+     * Set original file posts variables
+     * @param array $file
+     * @return static $this
+     */
+    public function setOriginalFile(array $file): self
+    {
+        $this->originalFile = $file;
+
+        return $this;
     }
 
 }

src/Pecee/Http/Input/InputItem.php

@@ -2,13 +2,13 @@
 
 namespace Pecee\Http\Input;
 
-class InputItem implements IInputItem
+class InputItem implements IInputItem, \IteratorAggregate
 {
     public $index;
     public $name;
     public $value;
 
-    public function __construct(string $index, ?string $value = null)
+    public function __construct(string $index, $value = null)
     {
         $this->index = $index;
         $this->value = $value;
@@ -35,7 +35,7 @@ class InputItem implements IInputItem
     /**
      * @return string
      */
-    public function getName(): string
+    public function getName(): ?string
     {
         return $this->name;
     }
@@ -53,28 +53,33 @@ class InputItem implements IInputItem
     }
 
     /**
-     * @return string
+     * @return mixed
      */
-    public function getValue(): string
+    public function getValue()
     {
         return $this->value;
     }
 
     /**
      * Set input value
-     * @param string $value
+     * @param mixed $value
      * @return static
      */
-    public function setValue(string $value): IInputItem
+    public function setValue($value): IInputItem
     {
         $this->value = $value;
 
         return $this;
     }
 
-    public function __toString()
+    public function __toString(): string
     {
-        return (string)$this->value;
+        $value = $this->getValue();
+        return (\is_array($value) === true) ? json_encode($value) : $value;
     }
 
+    public function getIterator(): \ArrayIterator
+    {
+        return new \ArrayIterator($this->getValue());
+    }
 }

src/Pecee/Http/Middleware/BaseCsrfVerifier.php

@@ -9,7 +9,7 @@ use Pecee\Http\Security\ITokenProvider;
 
 class BaseCsrfVerifier implements IMiddleware
 {
-    public const POST_KEY = 'csrf-token';
+    public const POST_KEY = 'csrf_token';
     public const HEADER_KEY = 'X-CSRF-TOKEN';
 
     protected $except;
@@ -17,7 +17,6 @@ class BaseCsrfVerifier implements IMiddleware
 
     /**
      * BaseCsrfVerifier constructor.
-     * @throws \Pecee\Http\Security\Exceptions\SecurityException
      */
     public function __construct()
     {
@@ -64,13 +63,12 @@ class BaseCsrfVerifier implements IMiddleware
      */
     public function handle(Request $request): void
     {
+        if ($this->skip($request) === false && $request->isPostBack() === true) {
 
-        if ($this->skip($request) === false && \in_array($request->getMethod(), ['post', 'put', 'delete'], true) === true) {
-
-            $token = $request->getInputHandler()->getValue(
+            $token = $request->getInputHandler()->value(
                 static::POST_KEY,
                 $request->getHeader(static::HEADER_KEY),
-                'post'
+                Request::$requestTypesPost
             );
 
             if ($this->tokenProvider->validate((string)$token) === false) {
@@ -81,7 +79,6 @@ class BaseCsrfVerifier implements IMiddleware
 
         // Refresh existing token
         $this->tokenProvider->refresh();
-
     }
 
     public function getTokenProvider(): ITokenProvider

src/Pecee/Http/Request.php

@@ -4,12 +4,52 @@ namespace Pecee\Http;
 
 use Pecee\Http\Exceptions\MalformedUrlException;
 use Pecee\Http\Input\InputHandler;
+use Pecee\Http\Middleware\BaseCsrfVerifier;
 use Pecee\SimpleRouter\Route\ILoadableRoute;
 use Pecee\SimpleRouter\Route\RouteUrl;
 use Pecee\SimpleRouter\SimpleRouter;
 
 class Request
 {
+    public const REQUEST_TYPE_GET = 'get';
+    public const REQUEST_TYPE_POST = 'post';
+    public const REQUEST_TYPE_PUT = 'put';
+    public const REQUEST_TYPE_PATCH = 'patch';
+    public const REQUEST_TYPE_OPTIONS = 'options';
+    public const REQUEST_TYPE_DELETE = 'delete';
+    public const REQUEST_TYPE_HEAD = 'head';
+
+    public const CONTENT_TYPE_JSON = 'application/json';
+    public const CONTENT_TYPE_FORM_DATA = 'multipart/form-data';
+    public const CONTENT_TYPE_X_FORM_ENCODED = 'application/x-www-form-urlencoded';
+
+    public const FORCE_METHOD_KEY = '_method';
+
+    /**
+     * All request-types
+     * @var string[]
+     */
+    public static $requestTypes = [
+        self::REQUEST_TYPE_GET,
+        self::REQUEST_TYPE_POST,
+        self::REQUEST_TYPE_PUT,
+        self::REQUEST_TYPE_PATCH,
+        self::REQUEST_TYPE_OPTIONS,
+        self::REQUEST_TYPE_DELETE,
+        self::REQUEST_TYPE_HEAD,
+    ];
+
+    /**
+     * Post request-types.
+     * @var string[]
+     */
+    public static $requestTypesPost = [
+        self::REQUEST_TYPE_POST,
+        self::REQUEST_TYPE_PUT,
+        self::REQUEST_TYPE_PATCH,
+        self::REQUEST_TYPE_DELETE,
+    ];
+
     /**
      * Additional data
      *
@@ -23,6 +63,12 @@ class Request
      */
     protected $headers = [];
 
+    /**
+     * Request ContentType
+     * @var string
+     */
+    protected $contentType;
+
     /**
      * Request host
      * @var string
@@ -77,16 +123,16 @@ class Request
     {
         foreach ($_SERVER as $key => $value) {
             $this->headers[strtolower($key)] = $value;
-            $this->headers[strtolower(str_replace('_', '-', $key))] = $value;
+            $this->headers[str_replace('_', '-', strtolower($key))] = $value;
         }
 
         $this->setHost($this->getHeader('http-host'));
 
         // Check if special IIS header exist, otherwise use default.
-        $this->setUrl(new Url($this->getHeader('unencoded-url', $this->getHeader('request-uri'))));
-
+        $this->setUrl(new Url($this->getFirstHeader(['unencoded-url', 'request-uri'])));
+        $this->setContentType((string)$this->getHeader('content-type'));
+        $this->setMethod((string)($_POST[static::FORCE_METHOD_KEY] ?? $this->getHeader('request-method')));
         $this->inputHandler = new InputHandler($this);
-        $this->method = strtolower($this->inputHandler->getValue('_method', $this->getHeader('request-method')));
     }
 
     public function isSecure(): bool
@@ -146,6 +192,15 @@ class Request
         return $this->getHeader('php-auth-pw');
     }
 
+    /**
+     * Get the csrf token
+     * @return string|null
+     */
+    public function getCsrfToken(): ?string
+    {
+        return $this->getHeader(BaseCsrfVerifier::HEADER_KEY);
+    }
+
     /**
      * Get all headers
      * @return array
@@ -157,19 +212,23 @@ class Request
 
     /**
      * Get id address
+     * If $safe is false, this function will detect Proxys. But the user can edit this header to whatever he wants!
+     * https://stackoverflow.com/questions/3003145/how-to-get-the-client-ip-address-in-php#comment-25086804
+     * @param bool $safeMode When enabled, only safe non-spoofable headers will be returned. Note this can cause issues when using proxy.
      * @return string|null
      */
-    public function getIp(): ?string
+    public function getIp(bool $safeMode = false): ?string
     {
-        if ($this->getHeader('http-cf-connecting-ip') !== null) {
-            return $this->getHeader('http-cf-connecting-ip');
+        $headers = ['remote-addr'];
+        if($safeMode === false) {
+            $headers = array_merge($headers, [
+                'http-cf-connecting-ip',
+                'http-client-ip',
+                'http-x-forwarded-for',
+            ]);
         }
 
-        if ($this->getHeader('http-x-forwarded-for') !== null) {
-            return $this->getHeader('http-x-forwarded_for');
-        }
-
-        return $this->getHeader('remote-addr');
+        return $this->getFirstHeader($headers);
     }
 
     /**
@@ -204,14 +263,72 @@ class Request
     /**
      * Get header value by name
      *
-     * @param string $name
-     * @param string|null $defaultValue
+     * @param string $name Name of the header.
+     * @param string|null $defaultValue Value to be returned if header is not found.
+     * @param bool $tryParse When enabled the method will try to find the header from both from client (http) and server-side variants, if the header is not found.
      *
      * @return string|null
      */
-    public function getHeader($name, $defaultValue = null): ?string
+    public function getHeader(string $name, $defaultValue = null, $tryParse = true): ?string
     {
-        return $this->headers[strtolower($name)] ?? $defaultValue;
+        $name = strtolower($name);
+        $header = $this->headers[$name] ?? null;
+
+        if ($tryParse === true && $header === null) {
+            if (strpos($name, 'http-') === 0) {
+                // Trying to find client header variant which was not found, searching for header variant without http- prefix.
+                $header = $this->headers[str_replace('http-', '', $name)] ?? null;
+            } else {
+                // Trying to find server variant which was not found, searching for client variant with http- prefix.
+                $header = $this->headers['http-' . $name] ?? null;
+            }
+        }
+
+        return $header ?? $defaultValue;
+    }
+
+    /**
+     * Will try to find first header from list of headers.
+     *
+     * @param array $headers
+     * @param mixed|null $defaultValue
+     * @return mixed|null
+     */
+    public function getFirstHeader(array $headers, $defaultValue = null)
+    {
+        foreach($headers as $header) {
+            $header = $this->getHeader($header);
+            if($header !== null) {
+                return $header;
+            }
+        }
+
+        return $defaultValue;
+    }
+
+    /**
+     * Get request content-type
+     * @return string|null
+     */
+    public function getContentType(): ?string
+    {
+        return $this->contentType;
+    }
+
+    /**
+     * Set request content-type
+     * @param string $contentType
+     * @return $this
+     */
+    protected function setContentType(string $contentType): self
+    {
+        if(strpos($contentType, ';') > 0) {
+            $this->contentType = strtolower(substr($contentType, 0, strpos($contentType, ';')));
+        } else {
+            $this->contentType = strtolower($contentType);
+        }
+
+        return $this;
     }
 
     /**
@@ -230,7 +347,7 @@ class Request
      *
      * @return bool
      */
-    public function isFormatAccepted($format): bool
+    public function isFormatAccepted(string $format): bool
     {
         return ($this->getHeader('http-accept') !== null && stripos($this->getHeader('http-accept'), $format) !== false);
     }
@@ -245,6 +362,16 @@ class Request
         return (strtolower($this->getHeader('http-x-requested-with')) === 'xmlhttprequest');
     }
 
+    /**
+     * Returns true when request-method is type that could contain data in the page body.
+     * 
+     * @return bool
+     */
+    public function isPostBack(): bool
+    {
+        return \in_array($this->getMethod(), static::$requestTypesPost, true);
+    }
+
     /**
      * Get accept formats
      * @return array
@@ -279,7 +406,7 @@ class Request
      */
     public function setMethod(string $method): void
     {
-        $this->method = $method;
+        $this->method = strtolower($method);
     }
 
     /**
@@ -370,7 +497,6 @@ class Request
     public function setLoadedRoutes(array $routes): self
     {
         $this->loadedRoutes = $routes;
-
         return $this;
     }
 
@@ -383,7 +509,6 @@ class Request
     public function addLoadedRoute(ILoadableRoute $route): self
     {
         $this->loadedRoutes[] = $route;
-
         return $this;
     }
 
@@ -406,11 +531,10 @@ class Request
     public function setHasPendingRewrite(bool $boolean): self
     {
         $this->hasPendingRewrite = $boolean;
-
         return $this;
     }
 
-    public function __isset($name)
+    public function __isset($name): bool
     {
         return array_key_exists($name, $this->data) === true;
     }

src/Pecee/Http/Response.php

@@ -30,7 +30,7 @@ class Response
      * Redirect the response
      *
      * @param string $url
-     * @param int $httpCode
+     * @param ?int $httpCode
      */
     public function redirect(string $url, ?int $httpCode = null): void
     {
@@ -86,7 +86,7 @@ class Response
     /**
      * Json encode
      * @param array|\JsonSerializable $value
-     * @param int $options JSON options Bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_PRESERVE_ZERO_FRACTION, JSON_UNESCAPED_UNICODE, JSON_PARTIAL_OUTPUT_ON_ERROR.
+     * @param ?int $options JSON options Bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_PRESERVE_ZERO_FRACTION, JSON_UNESCAPED_UNICODE, JSON_PARTIAL_OUTPUT_ON_ERROR.
      * @param int $dept JSON debt.
      * @throws InvalidArgumentException
      */

src/Pecee/Http/Security/CookieTokenProvider.php

@@ -17,7 +17,7 @@ class CookieTokenProvider implements ITokenProvider
      */
     public function __construct()
     {
-        $this->token = $this->getToken();
+        $this->token = ($this->hasToken() === true) ? $_COOKIE[static::CSRF_KEY] : null;
 
         if ($this->token === null) {
             $this->token = $this->generateToken();
@@ -63,7 +63,7 @@ class CookieTokenProvider implements ITokenProvider
     public function setToken(string $token): void
     {
         $this->token = $token;
-        setcookie(static::CSRF_KEY, $token, (int)((time() + 60) * $this->cookieTimeoutMinutes), '/', ini_get('session.cookie_domain'), ini_get('session.cookie_secure'), ini_get('session.cookie_httponly'));
+        setcookie(static::CSRF_KEY, $token, time() + (60 * $this->cookieTimeoutMinutes), '/', ini_get('session.cookie_domain'), ini_get('session.cookie_secure'), ini_get('session.cookie_httponly'));
     }
 
     /**
@@ -73,8 +73,6 @@ class CookieTokenProvider implements ITokenProvider
      */
     public function getToken(?string $defaultValue = null): ?string
     {
-        $this->token = ($this->hasToken() === true) ? $_COOKIE[static::CSRF_KEY] : null;
-
         return $this->token ?? $defaultValue;
     }
 

src/Pecee/Http/Url.php

@@ -4,7 +4,7 @@ namespace Pecee\Http;
 
 use Pecee\Http\Exceptions\MalformedUrlException;
 
-class Url
+class Url implements \JsonSerializable
 {
     private $originalUrl;
 
@@ -14,13 +14,13 @@ class Url
     private $username;
     private $password;
     private $path;
-    private $params;
+    private $params = [];
     private $fragment;
 
     /**
      * Url constructor.
      *
-     * @param string $url
+     * @param ?string $url
      * @throws MalformedUrlException
      */
     public function __construct(?string $url)
@@ -43,9 +43,7 @@ class Url
             $this->fragment = $data['fragment'] ?? null;
 
             if (isset($data['query']) === true) {
-                $params = [];
-                parse_str($data['query'], $params);
-                $this->setParams($params);
+                $this->setQueryString($data['query']);
             }
         }
     }
@@ -240,6 +238,23 @@ class Url
         return $this;
     }
 
+    /**
+     * Set raw query-string parameters as string
+     *
+     * @param string $queryString
+     * @return static
+     */
+    public function setQueryString(string $queryString): self
+    {
+        $params = [];
+
+        if(parse_str($queryString, $params) !== false) {
+            return $this->setParams($params);
+        }
+
+        return $this;
+    }
+
     /**
      * Get query-string params as string
      *
@@ -314,25 +329,36 @@ class Url
      */
     public function hasParam(string $name): bool
     {
-        return \in_array($name, $this->getParams(), true);
+        return array_key_exists($name, $this->getParams());
     }
 
     /**
-     * Removes parameter from query-string
+     * Removes multiple parameters from the query-string
+     *
+     * @param array ...$names
+     * @return static
+     */
+    public function removeParams(...$names): self
+    {
+        $params = array_diff_key($this->getParams(), array_flip($names));
+        $this->setParams($params);
+
+        return $this;
+    }
+
+    /**
+     * Removes parameter from the query-string
      *
      * @param string $name
+     * @return static
      */
-    public function removeParam(string $name): void
+    public function removeParam(string $name): self
     {
-        if ($this->hasParam($name) === true) {
-            $params = $this->getParams();
-            $key = \array_search($name, $params, true);
+        $params = $this->getParams();
+        unset($params[$name]);
+        $this->setParams($params);
 
-            if ($key === true) {
-                unset($params[$key]);
-                $this->setParams($params);
-            }
-        }
+        return $this;
     }
 
     /**
@@ -345,18 +371,7 @@ class Url
      */
     public function getParam(string $name, ?string $defaultValue = null): ?string
     {
-        $output = null;
-
-        if ($this->hasParam($name) === true) {
-            $params = $this->getParams();
-            $key = \array_search($name, $params, true);
-
-            if ($key === true) {
-                $output = $params[$key];
-            }
-        }
-
-        return $output ?? $defaultValue;
+        return (isset($this->getParams()[$name]) === true) ? $this->getParams()[$name] : $defaultValue;
     }
 
     /**
@@ -370,7 +385,7 @@ class Url
     {
         $encodedUrl = preg_replace_callback(
             '/[^:\/@?&=#]+/u',
-            function ($matches) {
+            static function ($matches) {
                 return urlencode($matches[0]);
             },
             $url
@@ -397,7 +412,7 @@ class Url
         if (\count($getParams) !== 0) {
 
             if ($includeEmpty === false) {
-                $getParams = array_filter($getParams, function ($item) {
+                $getParams = array_filter($getParams, static function ($item) {
                     return (trim($item) !== '');
                 });
             }
@@ -441,7 +456,19 @@ class Url
         return $scheme . $user . $pass . $host . $port . $this->getRelativeUrl();
     }
 
-    public function __toString()
+    /**
+     * Specify data which should be serialized to JSON
+     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return mixed data which can be serialized by <b>json_encode</b>,
+     * which is a value of any type other than a resource.
+     * @since 5.4.0
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->getRelativeUrl();
+    }
+
+    public function __toString(): string
     {
         return $this->getRelativeUrl();
     }

src/Pecee/SimpleRouter/ClassLoader/ClassLoader.php

@@ -2,44 +2,21 @@
 
 namespace Pecee\SimpleRouter\ClassLoader;
 
-use DI\Container;
-use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
+use Pecee\SimpleRouter\Exceptions\ClassNotFoundHttpException;
 
 class ClassLoader implements IClassLoader
 {
-    /**
-     * Dependency injection enabled
-     * @var bool
-     */
-    protected $useDependencyInjection = false;
-
-    /**
-     * @var Container|null
-     */
-    protected $container;
-
     /**
      * Load class
      *
      * @param string $class
-     * @return mixed
-     * @throws NotFoundHttpException
+     * @return object
+     * @throws ClassNotFoundHttpException
      */
     public function loadClass(string $class)
     {
         if (class_exists($class) === false) {
-            throw new NotFoundHttpException(sprintf('Class "%s" does not exist', $class), 404);
-        }
-
-        if ($this->useDependencyInjection === true) {
-            $container = $this->getContainer();
-            if ($container !== null) {
-                try {
-                    return $container->get($class);
-                } catch (\Exception $e) {
-                    throw new NotFoundHttpException($e->getMessage(), (int)$e->getCode(), $e->getPrevious());
-                }
-            }
+            throw new ClassNotFoundHttpException($class, null, sprintf('Class "%s" does not exist', $class), 404, null);
         }
 
         return new $class();
@@ -48,71 +25,13 @@ class ClassLoader implements IClassLoader
     /**
      * Load closure
      *
-     * @param \Closure $closure
+     * @param Callable $closure
      * @param array $parameters
      * @return mixed
-     * @throws NotFoundHttpException
      */
-    public function loadClosure(\Closure $closure, array $parameters)
+    public function loadClosure(Callable $closure, array $parameters)
     {
-        if ($this->useDependencyInjection === true) {
-            $container = $this->getContainer();
-            if ($container !== null) {
-                try {
-                    return $container->call($closure, $parameters);
-                } catch (\Exception $e) {
-                    throw new NotFoundHttpException($e->getMessage(), (int)$e->getCode(), $e->getPrevious());
-                }
-            }
-        }
-
         return \call_user_func_array($closure, $parameters);
     }
 
-    /**
-     * Get dependency injector container.
-     *
-     * @return Container|null
-     */
-    public function getContainer(): ?Container
-    {
-        return $this->container;
-    }
-
-    /**
-     * Set the dependency-injector container.
-     *
-     * @param Container $container
-     * @return ClassLoader
-     */
-    public function setContainer(Container $container): self
-    {
-        $this->container = $container;
-
-        return $this;
-    }
-
-    /**
-     * Enable or disable dependency injection.
-     *
-     * @param bool $enabled
-     * @return static
-     */
-    public function useDependencyInjection(bool $enabled): self
-    {
-        $this->useDependencyInjection = $enabled;
-
-        return $this;
-    }
-
-    /**
-     * Return true if dependency injection is enabled.
-     *
-     * @return bool
-     */
-    public function isDependencyInjectionEnabled(): bool
-    {
-        return $this->useDependencyInjection;
-    }
-
 }

src/Pecee/SimpleRouter/ClassLoader/IClassLoader.php

@@ -5,8 +5,20 @@ namespace Pecee\SimpleRouter\ClassLoader;
 interface IClassLoader
 {
 
+    /**
+     * Called when loading class
+     * @param string $class
+     * @return object
+     */
     public function loadClass(string $class);
 
-    public function loadClosure(\Closure $closure, array $parameters);
+    /**
+     * Called when loading method
+     *
+     * @param callable $closure
+     * @param array $parameters
+     * @return mixed
+     */
+    public function loadClosure(Callable $closure, array $parameters);
 
-}
+}

src/Pecee/SimpleRouter/Event/EventArgument.php

@@ -74,7 +74,7 @@ class EventArgument implements IEventArgument
      * @param string $name
      * @return mixed
      */
-    public function __get($name)
+    public function __get(string $name)
     {
         return $this->arguments[$name] ?? null;
     }
@@ -83,7 +83,7 @@ class EventArgument implements IEventArgument
      * @param string $name
      * @return bool
      */
-    public function __isset($name)
+    public function __isset(string $name): bool
     {
         return array_key_exists($name, $this->arguments);
     }
@@ -93,7 +93,7 @@ class EventArgument implements IEventArgument
      * @param mixed $value
      * @throws \InvalidArgumentException
      */
-    public function __set($name, $value)
+    public function __set(string $name, $value)
     {
         throw new \InvalidArgumentException('Not supported');
     }

src/Pecee/SimpleRouter/Exceptions/ClassNotFoundHttpException.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Pecee\SimpleRouter\Exceptions;
+
+use Throwable;
+
+class ClassNotFoundHttpException extends NotFoundHttpException
+{
+    protected $class;
+    protected $method;
+
+    public function __construct(string $class, ?string $method = null, $message = "", $code = 0, Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+
+        $this->class = $class;
+        $this->method = $method;
+    }
+
+    /**
+     * Get class name
+     * @return string
+     */
+    public function getClass(): string
+    {
+        return $this->class;
+    }
+
+    /**
+     * Get method
+     * @return string|null
+     */
+    public function getMethod(): ?string
+    {
+        return $this->method;
+    }
+
+}

src/Pecee/SimpleRouter/Handlers/DebugEventHandler.php

@@ -16,7 +16,7 @@ class DebugEventHandler implements IEventHandler
 
     public function __construct()
     {
-        $this->callback = function (EventArgument $argument) {
+        $this->callback = static function (EventArgument $argument) {
             // todo: log in database
         };
     }

src/Pecee/SimpleRouter/Handlers/EventHandler.php

@@ -22,6 +22,11 @@ class EventHandler implements IEventHandler
      */
     public const EVENT_LOAD = 'onLoad';
 
+    /**
+     * Fires when route is added to the router
+     */
+    public const EVENT_ADD_ROUTE = 'onAddRoute';
+
     /**
      * Fires when a url-rewrite is and just before the routes are re-initialized.
      */
@@ -95,6 +100,7 @@ class EventHandler implements IEventHandler
         self::EVENT_ALL,
         self::EVENT_INIT,
         self::EVENT_LOAD,
+        self::EVENT_ADD_ROUTE,
         self::EVENT_REWRITE,
         self::EVENT_BOOT,
         self::EVENT_RENDER_BOOTMANAGER,
@@ -137,7 +143,7 @@ class EventHandler implements IEventHandler
      * Get events.
      *
      * @param string|null $name Filter events by name.
-     * @param array ...$names Add multiple names...
+     * @param array|string ...$names Add multiple names...
      * @return array
      */
     public function getEvents(?string $name, ...$names): array

src/Pecee/SimpleRouter/Route/IGroupRoute.php

@@ -29,7 +29,7 @@ interface IGroupRoute extends IRoute
      * @param array $handlers
      * @return static
      */
-    public function setExceptionHandlers(array $handlers);
+    public function setExceptionHandlers(array $handlers): self;
 
     /**
      * Get exception-handlers for group
@@ -59,7 +59,7 @@ interface IGroupRoute extends IRoute
      * @param string $prefix
      * @return static
      */
-    public function setPrefix($prefix): self;
+    public function setPrefix(string $prefix): self;
 
     /**
      * Get prefix.

src/Pecee/SimpleRouter/Route/ILoadableRoute.php

@@ -39,6 +39,13 @@ interface ILoadableRoute extends IRoute
      */
     public function setUrl(string $url): self;
 
+    /**
+     * Prepend url
+     * @param string $url
+     * @return ILoadableRoute
+     */
+    public function prependUrl(string $url): self;
+
     /**
      * Returns the provided name for the router.
      *
@@ -75,6 +82,6 @@ interface ILoadableRoute extends IRoute
      * @param string $regex
      * @return static
      */
-    public function setMatch($regex): self;
+    public function setMatch(string $regex): self;
 
 }

src/Pecee/SimpleRouter/Route/IRoute.php

@@ -10,11 +10,11 @@ interface IRoute
     /**
      * Method called to check if a domain matches
      *
-     * @param string $route
+     * @param string $url
      * @param Request $request
      * @return bool
      */
-    public function matchRoute($route, Request $request): bool;
+    public function matchRoute(string $url, Request $request): bool;
 
     /**
      * Called when route is matched.
@@ -22,8 +22,8 @@ interface IRoute
      *
      * @param Request $request
      * @param Router $router
-     * @throws \Pecee\SimpleRouter\Exceptions\NotFoundHttpException
      * @return string
+     * @throws \Pecee\SimpleRouter\Exceptions\NotFoundHttpException
      */
     public function renderRoute(Request $request, Router $router): ?string;
 
@@ -82,7 +82,7 @@ interface IRoute
     /**
      * Set callback
      *
-     * @param string $callback
+     * @param string|array|\Closure $callback
      * @return static
      */
     public function setCallback($callback): self;
@@ -129,7 +129,7 @@ interface IRoute
      * @param string $namespace
      * @return static
      */
-    public function setDefaultNamespace($namespace): IRoute;
+    public function setDefaultNamespace(string $namespace): IRoute;
 
     /**
      * Get default namespace
@@ -196,7 +196,7 @@ interface IRoute
      * @param string $middleware
      * @return static
      */
-    public function addMiddleware($middleware): self;
+    public function addMiddleware(string $middleware): self;
 
     /**
      * Set middlewares array
@@ -206,4 +206,18 @@ interface IRoute
      */
     public function setMiddlewares(array $middlewares): self;
 
+    /**
+     * If enabled parameters containing null-value will not be passed along to the callback.
+     *
+     * @param bool $enabled
+     * @return static $this
+     */
+    public function setFilterEmptyParams(bool $enabled): self;
+
+    /**
+     * Status if filtering of empty params is enabled or disabled
+     * @return bool
+     */
+    public function getFilterEmptyParams(): bool;
+
 }

src/Pecee/SimpleRouter/Route/LoadableRoute.php

@@ -60,7 +60,7 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
             return null;
         }
 
-        return ((bool)preg_match($this->regex, $request->getHost() . $url) !== false);
+        return ((bool)preg_match($this->regex, $url) !== false);
     }
 
     /**
@@ -85,6 +85,17 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
         return $this;
     }
 
+    /**
+     * Prepend url
+     *
+     * @param string $url
+     * @return ILoadableRoute
+     */
+    public function prependUrl(string $url): ILoadableRoute
+    {
+        return $this->setUrl(rtrim($url, '/') . $this->url);
+    }
+
     public function getUrl(): string
     {
         return $this->url;
@@ -109,9 +120,6 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
             $url = '//' . $group->getDomains()[0] . $url;
         }
 
-        /* Contains parameters that aren't recognized and will be appended at the end of the url */
-        $unknownParams = [];
-
         /* Create the param string - {parameter} */
         $param1 = $this->paramModifiers[0] . '%s' . $this->paramModifiers[1];
 
@@ -131,7 +139,7 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
                 $value = array_key_exists($param, $p) ? $p[$param] : $params[$param];
 
                 /* If parameter is specifically set to null - use the original-defined value */
-                if ($value === null && isset($this->originalParameters[$param])) {
+                if ($value === null && isset($this->originalParameters[$param]) === true) {
                     $value = $this->originalParameters[$param];
                 }
             }
@@ -140,13 +148,12 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
                 /* Add parameter to the correct position */
                 $url = str_ireplace([sprintf($param1, $param), sprintf($param2, $param)], $value, $url);
             } else {
-                $unknownParams[$param] = $value;
+                /* Parameter aren't recognized and will be appended at the end of the url */
+                $url .= $value . '/';
             }
         }
 
-        $url = '/' . ltrim($url, '/') . implode('/', $unknownParams);
-
-        return rtrim($url, '/') . '/';
+        return rtrim('/' . ltrim($url, '/'), '/') . '/';
     }
 
     /**
@@ -154,7 +161,7 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
      *
      * @return string
      */
-    public function getName(): string
+    public function getName(): ?string
     {
         return $this->name;
     }
@@ -176,7 +183,7 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
      * @param string $regex
      * @return static
      */
-    public function setMatch($regex): ILoadableRoute
+    public function setMatch(string $regex): ILoadableRoute
     {
         $this->regex = $regex;
 
@@ -222,15 +229,15 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
     /**
      * Merge with information from another route.
      *
-     * @param array $values
+     * @param array $settings
      * @param bool $merge
      * @return static
      */
-    public function setSettings(array $values, bool $merge = false): IRoute
+    public function setSettings(array $settings, bool $merge = false): IRoute
     {
-        if (isset($values['as']) === true) {
+        if (isset($settings['as']) === true) {
 
-            $name = $values['as'];
+            $name = $settings['as'];
 
             if ($this->name !== null && $merge !== false) {
                 $name .= '.' . $this->name;
@@ -239,13 +246,11 @@ abstract class LoadableRoute extends Route implements ILoadableRoute
             $this->setName($name);
         }
 
-        if (isset($values['prefix']) === true) {
-            $this->setUrl($values['prefix'] . $this->getUrl());
+        if (isset($settings['prefix']) === true) {
+            $this->prependUrl($settings['prefix']);
         }
 
-        parent::setSettings($values, $merge);
-
-        return $this;
+        return parent::setSettings($settings, $merge);
     }
 
 }

src/Pecee/SimpleRouter/Route/Route.php

@@ -4,29 +4,14 @@ namespace Pecee\SimpleRouter\Route;
 
 use Pecee\Http\Middleware\IMiddleware;
 use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\ClassNotFoundHttpException;
 use Pecee\SimpleRouter\Exceptions\NotFoundHttpException;
 use Pecee\SimpleRouter\Router;
 
 abstract class Route implements IRoute
 {
     protected const PARAMETERS_REGEX_FORMAT = '%s([\w]+)(\%s?)%s';
-    protected const PARAMETERS_DEFAULT_REGEX = '[\w]+';
-
-    public const REQUEST_TYPE_GET = 'get';
-    public const REQUEST_TYPE_POST = 'post';
-    public const REQUEST_TYPE_PUT = 'put';
-    public const REQUEST_TYPE_PATCH = 'patch';
-    public const REQUEST_TYPE_OPTIONS = 'options';
-    public const REQUEST_TYPE_DELETE = 'delete';
-
-    public static $requestTypes = [
-        self::REQUEST_TYPE_GET,
-        self::REQUEST_TYPE_POST,
-        self::REQUEST_TYPE_PUT,
-        self::REQUEST_TYPE_PATCH,
-        self::REQUEST_TYPE_OPTIONS,
-        self::REQUEST_TYPE_DELETE,
-    ];
+    protected const PARAMETERS_DEFAULT_REGEX = '[\w-]+';
 
     /**
      * If enabled parameters containing null-value
@@ -76,12 +61,14 @@ abstract class Route implements IRoute
         }
 
         $router->debug('Parsing parameters');
+
         $parameters = $this->getParameters();
+
         $router->debug('Finished parsing parameters');
 
         /* Filter parameters with null-value */
         if ($this->filterEmptyParams === true) {
-            $parameters = array_filter($parameters, function ($var) {
+            $parameters = array_filter($parameters, static function ($var) {
                 return ($var !== null);
             });
         }
@@ -91,24 +78,24 @@ abstract class Route implements IRoute
             $router->debug('Executing callback');
 
             /* When the callback is a function */
-
             return $router->getClassLoader()->loadClosure($callback, $parameters);
         }
 
-        /* When the callback is a class + method */
-        $controller = explode('@', $callback);
+        $controller = $this->getClass();
+        $method = $this->getMethod();
 
         $namespace = $this->getNamespace();
-
-        $className = ($namespace !== null && $controller[0][0] !== '\\') ? $namespace . '\\' . $controller[0] : $controller[0];
+        $className = ($namespace !== null && $controller[0] !== '\\') ? $namespace . '\\' . $controller : $controller;
 
         $router->debug('Loading class %s', $className);
         $class = $router->getClassLoader()->loadClass($className);
 
-        $method = $controller[1];
+        if ($method === null) {
+            $controller[1] = '__invoke';
+        }
 
         if (method_exists($class, $method) === false) {
-            throw new NotFoundHttpException(sprintf('Method "%s" does not exist in class "%s"', $method, $className), 404);
+            throw new ClassNotFoundHttpException($className, $method, sprintf('Method "%s" does not exist in class "%s"', $method, $className), 404, null);
         }
 
         $router->debug('Executing callback');
@@ -116,22 +103,27 @@ abstract class Route implements IRoute
         return \call_user_func_array([$class, $method], $parameters);
     }
 
-    protected function parseParameters($route, $url, $parameterRegex = null)
+    protected function parseParameters($route, $url, $parameterRegex = null): ?array
     {
-        $regex = sprintf(static::PARAMETERS_REGEX_FORMAT, $this->paramModifiers[0], $this->paramOptionalSymbol, $this->paramModifiers[1]);
-
-        $parameters = [];
+        $regex = (strpos($route, $this->paramModifiers[0]) === false) ? null :
+            sprintf
+            (
+                static::PARAMETERS_REGEX_FORMAT,
+                $this->paramModifiers[0],
+                $this->paramOptionalSymbol,
+                $this->paramModifiers[1]
+            );
 
         // Ensures that host names/domains will work with parameters
         $url = '/' . ltrim($url, '/');
+        $urlRegex = '';
+        $parameters = [];
 
-        if ((bool)preg_match_all('/' . $regex . '/u', $route, $parameters) === false) {
+        if ($regex === null || (bool)preg_match_all('/' . $regex . '/u', $route, $parameters) === false) {
             $urlRegex = preg_quote($route, '/');
         } else {
 
-            $urlParts = preg_split('/((\-?\/?)\{[^}]+\})/', $route);
-
-            foreach ($urlParts as $key => $t) {
+            foreach (preg_split('/((-?\/?){[^}]+})/', $route) as $key => $t) {
 
                 $regex = '';
 
@@ -143,26 +135,17 @@ abstract class Route implements IRoute
                     if (isset($this->where[$name]) === true) {
                         $regex = $this->where[$name];
                     } else {
-
-                        /* If method specific regex is defined use that, otherwise use the default parameter regex */
-                        if ($parameterRegex !== null) {
-                            $regex = $parameterRegex;
-                        } else {
-                            $regex = $this->defaultParameterRegex ?? static::PARAMETERS_DEFAULT_REGEX;
-                        }
+                        $regex = $parameterRegex ?? $this->defaultParameterRegex ?? static::PARAMETERS_DEFAULT_REGEX;
                     }
 
-                    $regex = sprintf('(?:\/|\-)%1$s(?P<%2$s>%3$s)%1$s', $parameters[2][$key], $name, $regex);
+                    $regex = sprintf('((\/|-)(?P<%2$s>%3$s))%1$s', $parameters[2][$key], $name, $regex);
                 }
 
-                $urlParts[$key] = preg_quote($t, '/') . $regex;
+                $urlRegex .= preg_quote($t, '/') . $regex;
             }
-
-            $urlRegex = implode('', $urlParts);
-
         }
 
-        if ((bool)preg_match(sprintf($this->urlRegex, $urlRegex), $url, $matches) === false) {
+        if (trim($urlRegex) === '' || (bool)preg_match(sprintf($this->urlRegex, $urlRegex), $url, $matches) === false) {
             return null;
         }
 
@@ -172,7 +155,7 @@ abstract class Route implements IRoute
 
             /* Only take matched parameters with name */
             foreach ((array)$parameters[1] as $name) {
-                $values[$name] = (isset($matches[$name]) && $matches[$name] !== '') ? $matches[$name] : null;
+                $values[$name] = (isset($matches[$name]) === true && $matches[$name] !== '') ? $matches[$name] : null;
             }
         }
 
@@ -192,7 +175,7 @@ abstract class Route implements IRoute
             return $this->callback;
         }
 
-        return 'function_' . md5($this->callback);
+        return 'function:' . md5($this->callback);
     }
 
     /**
@@ -247,9 +230,8 @@ abstract class Route implements IRoute
         $this->group = $group;
 
         /* Add/merge parent settings with child */
-        $this->setSettings($group->toArray(), true);
 
-        return $this;
+        return $this->setSettings($group->toArray(), true);
     }
 
     /**
@@ -268,7 +250,7 @@ abstract class Route implements IRoute
     /**
      * Set callback
      *
-     * @param string $callback
+     * @param string|array|\Closure $callback
      * @return static
      */
     public function setCallback($callback): IRoute
@@ -288,6 +270,10 @@ abstract class Route implements IRoute
 
     public function getMethod(): ?string
     {
+        if (\is_array($this->callback) === true && \count($this->callback) > 1) {
+            return $this->callback[1];
+        }
+
         if (\is_string($this->callback) === true && strpos($this->callback, '@') !== false) {
             $tmp = explode('@', $this->callback);
 
@@ -299,6 +285,10 @@ abstract class Route implements IRoute
 
     public function getClass(): ?string
     {
+        if (\is_array($this->callback) === true && \count($this->callback) > 0) {
+            return $this->callback[0];
+        }
+
         if (\is_string($this->callback) === true && strpos($this->callback, '@') !== false) {
             $tmp = explode('@', $this->callback);
 
@@ -310,14 +300,14 @@ abstract class Route implements IRoute
 
     public function setMethod(string $method): IRoute
     {
-        $this->callback = sprintf('%s@%s', $this->getClass(), $method);
+        $this->callback = [$this->getClass(), $method];
 
         return $this;
     }
 
     public function setClass(string $class): IRoute
     {
-        $this->callback = sprintf('%s@%s', $class, $this->getMethod());
+        $this->callback = [$class, $this->getMethod()];
 
         return $this;
     }
@@ -337,7 +327,7 @@ abstract class Route implements IRoute
      * @param string $namespace
      * @return static
      */
-    public function setDefaultNamespace($namespace): IRoute
+    public function setDefaultNamespace(string $namespace): IRoute
     {
         $this->defaultNamespace = $namespace;
 
@@ -392,35 +382,35 @@ abstract class Route implements IRoute
     /**
      * Merge with information from another route.
      *
-     * @param array $values
+     * @param array $settings
      * @param bool $merge
      * @return static
      */
-    public function setSettings(array $values, bool $merge = false): IRoute
+    public function setSettings(array $settings, bool $merge = false): IRoute
     {
-        if ($this->namespace === null && isset($values['namespace']) === true) {
-            $this->setNamespace($values['namespace']);
+        if ($this->namespace === null && isset($settings['namespace']) === true) {
+            $this->setNamespace($settings['namespace']);
         }
 
-        if (isset($values['method']) === true) {
-            $this->setRequestMethods(array_merge($this->requestMethods, (array)$values['method']));
+        if (isset($settings['method']) === true) {
+            $this->setRequestMethods(array_merge($this->requestMethods, (array)$settings['method']));
         }
 
-        if (isset($values['where']) === true) {
-            $this->setWhere(array_merge($this->where, (array)$values['where']));
+        if (isset($settings['where']) === true) {
+            $this->setWhere(array_merge($this->where, (array)$settings['where']));
         }
 
-        if (isset($values['parameters']) === true) {
-            $this->setParameters(array_merge($this->parameters, (array)$values['parameters']));
+        if (isset($settings['parameters']) === true) {
+            $this->setParameters(array_merge($this->parameters, (array)$settings['parameters']));
         }
 
         // Push middleware if multiple
-        if (isset($values['middleware']) === true) {
-            $this->setMiddlewares(array_merge((array)$values['middleware'], $this->middlewares));
+        if (isset($settings['middleware']) === true) {
+            $this->setMiddlewares(array_merge((array)$settings['middleware'], $this->middlewares));
         }
 
-        if (isset($values['defaultParameterRegex']) === true) {
-            $this->setDefaultParameterRegex($values['defaultParameterRegex']);
+        if (isset($settings['defaultParameterRegex']) === true) {
+            $this->setDefaultParameterRegex($settings['defaultParameterRegex']);
         }
 
         return $this;
@@ -453,9 +443,9 @@ abstract class Route implements IRoute
      * Add regular expression parameter match.
      * Alias for LoadableRoute::where()
      *
-     * @see LoadableRoute::where()
      * @param array $options
      * @return static
+     * @see LoadableRoute::where()
      */
     public function where(array $options)
     {
@@ -503,11 +493,11 @@ abstract class Route implements IRoute
     /**
      * Add middleware class-name
      *
-     * @deprecated This method is deprecated and will be removed in the near future.
-     * @param IMiddleware|string $middleware
+     * @param string $middleware
      * @return static
+     * @deprecated This method is deprecated and will be removed in the near future.
      */
-    public function setMiddleware($middleware)
+    public function setMiddleware(string $middleware): self
     {
         $this->middlewares[] = $middleware;
 
@@ -517,10 +507,10 @@ abstract class Route implements IRoute
     /**
      * Add middleware class-name
      *
-     * @param IMiddleware|string $middleware
+     * @param string $middleware
      * @return static
      */
-    public function addMiddleware($middleware): IRoute
+    public function addMiddleware(string $middleware): IRoute
     {
         $this->middlewares[] = $middleware;
 
@@ -555,7 +545,7 @@ abstract class Route implements IRoute
      * @param string $regex
      * @return static
      */
-    public function setDefaultParameterRegex($regex)
+    public function setDefaultParameterRegex(string $regex): self
     {
         $this->defaultParameterRegex = $regex;
 
@@ -572,4 +562,25 @@ abstract class Route implements IRoute
         return $this->defaultParameterRegex;
     }
 
+    /**
+     * If enabled parameters containing null-value will not be passed along to the callback.
+     *
+     * @param bool $enabled
+     * @return static $this
+     */
+    public function setFilterEmptyParams(bool $enabled): IRoute
+    {
+        $this->filterEmptyParams = $enabled;
+        return $this;
+    }
+
+    /**
+     * Status if filtering of empty params is enabled or disabled
+     * @return bool
+     */
+    public function getFilterEmptyParams(): bool
+    {
+        return $this->filterEmptyParams;
+    }
+
 }

src/Pecee/SimpleRouter/Route/RouteController.php

@@ -64,7 +64,7 @@ class RouteController extends LoadableRoute implements IControllerRoute
         if ($method !== null) {
 
             /* Remove requestType from method-name, if it exists */
-            foreach (static::$requestTypes as $requestType) {
+            foreach (Request::$requestTypes as $requestType) {
 
                 if (stripos($method, $requestType) === 0) {
                     $method = (string)substr($method, \strlen($requestType));
@@ -86,7 +86,7 @@ class RouteController extends LoadableRoute implements IControllerRoute
         return '/' . trim($url, '/') . '/';
     }
 
-    public function matchRoute($url, Request $request): bool
+    public function matchRoute(string $url, Request $request): bool
     {
         if ($this->getGroup() !== null && $this->getGroup()->matchRoute($url, $request) === false) {
             return false;
@@ -95,7 +95,7 @@ class RouteController extends LoadableRoute implements IControllerRoute
         /* Match global regular-expression for route */
         $regexMatch = $this->matchRegex($request, $url);
 
-        if ($regexMatch === false || (stripos($url, $this->url) !== 0 && strtolower($url) !== strtolower($this->url))) {
+        if ($regexMatch === false || (stripos($url, $this->url) !== 0 && strtoupper($url) !== strtoupper($this->url))) {
             return false;
         }
 
@@ -110,7 +110,7 @@ class RouteController extends LoadableRoute implements IControllerRoute
             $this->parameters = \array_slice($path, 1);
 
             // Set callback
-            $this->setCallback($this->controller . '@' . $this->method);
+            $this->setCallback([$this->controller, $this->method]);
 
             return true;
         }
@@ -167,19 +167,17 @@ class RouteController extends LoadableRoute implements IControllerRoute
     /**
      * Merge with information from another route.
      *
-     * @param array $values
+     * @param array $settings
      * @param bool $merge
      * @return static
      */
-    public function setSettings(array $values, bool $merge = false): IRoute
+    public function setSettings(array $settings, bool $merge = false): IRoute
     {
-        if (isset($values['names']) === true) {
-            $this->names = $values['names'];
+        if (isset($settings['names']) === true) {
+            $this->names = $settings['names'];
         }
 
-        parent::setSettings($values, $merge);
-
-        return $this;
+        return parent::setSettings($settings, $merge);
     }
 
 }

src/Pecee/SimpleRouter/Route/RouteGroup.php

@@ -26,12 +26,15 @@ class RouteGroup extends Route implements IGroupRoute
 
         foreach ($this->domains as $domain) {
 
+            // If domain has no parameters but matches
+            if ($domain === $request->getHost()) {
+                return true;
+            }
+
             $parameters = $this->parseParameters($domain, $request->getHost(), '.*');
 
             if ($parameters !== null && \count($parameters) !== 0) {
-
                 $this->parameters = $parameters;
-
                 return true;
             }
         }
@@ -46,14 +49,22 @@ class RouteGroup extends Route implements IGroupRoute
      * @param Request $request
      * @return bool
      */
-    public function matchRoute($url, Request $request): bool
+    public function matchRoute(string $url, Request $request): bool
     {
         if ($this->getGroup() !== null && $this->getGroup()->matchRoute($url, $request) === false) {
             return false;
         }
 
+        // Parse parameter
+
+        $prefix = $this->prefix;
+
+        foreach ($this->getParameters() as $parameter => $value) {
+            $prefix = str_ireplace('{' . $parameter . '}', $value, $prefix);
+        }
+
         /* Skip if prefix doesn't match */
-        if ($this->prefix !== null && stripos($url, $this->prefix) === false) {
+        if ($this->prefix !== null && stripos($url, $prefix) === false) {
             return false;
         }
 
@@ -123,7 +134,7 @@ class RouteGroup extends Route implements IGroupRoute
      * @param string $prefix
      * @return static
      */
-    public function setPrefix($prefix): IGroupRoute
+    public function setPrefix(string $prefix): IGroupRoute
     {
         $this->prefix = '/' . trim($prefix, '/');
 
@@ -143,28 +154,28 @@ class RouteGroup extends Route implements IGroupRoute
     /**
      * Merge with information from another route.
      *
-     * @param array $values
+     * @param array $settings
      * @param bool $merge
      * @return static
      */
-    public function setSettings(array $values, bool $merge = false): IRoute
+    public function setSettings(array $settings, bool $merge = false): IRoute
     {
 
-        if (isset($values['prefix']) === true) {
-            $this->setPrefix($values['prefix'] . $this->prefix);
+        if (isset($settings['prefix']) === true) {
+            $this->setPrefix($settings['prefix'] . $this->prefix);
         }
 
-        if ($merge === false && isset($values['exceptionHandler']) === true) {
-            $this->setExceptionHandlers((array)$values['exceptionHandler']);
+        if ($merge === false && isset($settings['exceptionHandler']) === true) {
+            $this->setExceptionHandlers((array)$settings['exceptionHandler']);
         }
 
-        if ($merge === false && isset($values['domain']) === true) {
-            $this->setDomains((array)$values['domain']);
+        if ($merge === false && isset($settings['domain']) === true) {
+            $this->setDomains((array)$settings['domain']);
         }
 
-        if (isset($values['as']) === true) {
+        if (isset($settings['as']) === true) {
 
-            $name = $values['as'];
+            $name = $settings['as'];
 
             if ($this->name !== null && $merge !== false) {
                 $name .= '.' . $this->name;
@@ -173,9 +184,7 @@ class RouteGroup extends Route implements IGroupRoute
             $this->name = $name;
         }
 
-        parent::setSettings($values, $merge);
-
-        return $this;
+        return parent::setSettings($settings, $merge);
     }
 
     /**

src/Pecee/SimpleRouter/Route/RoutePartialGroup.php

@@ -22,7 +22,7 @@ class RoutePartialGroup extends RouteGroup implements IPartialGroupRoute
      * @param Request $request
      * @return bool
      */
-    public function matchRoute($url, Request $request): bool
+    public function matchRoute(string $url, Request $request): bool
     {
         if ($this->getGroup() !== null && $this->getGroup()->matchRoute($url, $request) === false) {
             return false;
@@ -38,7 +38,7 @@ class RoutePartialGroup extends RouteGroup implements IPartialGroupRoute
             }
 
             /* Set the parameters */
-            $this->setParameters((array)$parameters);
+            $this->setParameters($parameters);
         }
 
         return $this->matchDomain($request);

src/Pecee/SimpleRouter/Route/RouteResource.php

@@ -76,14 +76,14 @@ class RouteResource extends LoadableRoute implements IControllerRoute
         return $this->url;
     }
 
-    protected function call($method)
+    protected function call($method): bool
     {
-        $this->setCallback($this->controller . '@' . $method);
+        $this->setCallback([$this->controller, $method]);
 
         return true;
     }
 
-    public function matchRoute($url, Request $request): bool
+    public function matchRoute(string $url, Request $request): bool
     {
         if ($this->getGroup() !== null && $this->getGroup()->matchRoute($url, $request) === false) {
             return false;
@@ -92,7 +92,7 @@ class RouteResource extends LoadableRoute implements IControllerRoute
         /* Match global regular-expression for route */
         $regexMatch = $this->matchRegex($request, $url);
 
-        if ($regexMatch === false || (stripos($url, $this->url) !== 0 && strtolower($url) !== strtolower($this->url))) {
+        if ($regexMatch === false || (stripos($url, $this->url) !== 0 && strtoupper($url) !== strtoupper($this->url))) {
             return false;
         }
 
@@ -115,32 +115,32 @@ class RouteResource extends LoadableRoute implements IControllerRoute
         $method = $request->getMethod();
 
         // Delete
-        if ($method === static::REQUEST_TYPE_DELETE && $id !== null) {
+        if ($method === Request::REQUEST_TYPE_DELETE && $id !== null) {
             return $this->call($this->methodNames['destroy']);
         }
 
         // Update
-        if ($id !== null && \in_array($method, [static::REQUEST_TYPE_PATCH, static::REQUEST_TYPE_PUT], true) === true) {
+        if ($id !== null && \in_array($method, [Request::REQUEST_TYPE_PATCH, Request::REQUEST_TYPE_PUT], true) === true) {
             return $this->call($this->methodNames['update']);
         }
 
         // Edit
-        if ($method === static::REQUEST_TYPE_GET && $id !== null && $action === 'edit') {
+        if ($method === Request::REQUEST_TYPE_GET && $id !== null && $action === 'edit') {
             return $this->call($this->methodNames['edit']);
         }
 
         // Create
-        if ($method === static::REQUEST_TYPE_GET && $id === 'create') {
+        if ($method === Request::REQUEST_TYPE_GET && $id === 'create') {
             return $this->call($this->methodNames['create']);
         }
 
         // Save
-        if ($method === static::REQUEST_TYPE_POST) {
+        if ($method === Request::REQUEST_TYPE_POST) {
             return $this->call($this->methodNames['store']);
         }
 
         // Show
-        if ($method === static::REQUEST_TYPE_GET && $id !== null) {
+        if ($method === Request::REQUEST_TYPE_GET && $id !== null) {
             return $this->call($this->methodNames['show']);
         }
 
@@ -190,7 +190,7 @@ class RouteResource extends LoadableRoute implements IControllerRoute
      * @param array $names
      * @return static $this
      */
-    public function setMethodNames(array $names)
+    public function setMethodNames(array $names): RouteResource
     {
         $this->methodNames = $names;
 
@@ -210,23 +210,21 @@ class RouteResource extends LoadableRoute implements IControllerRoute
     /**
      * Merge with information from another route.
      *
-     * @param array $values
+     * @param array $settings
      * @param bool $merge
      * @return static
      */
-    public function setSettings(array $values, bool $merge = false): IRoute
+    public function setSettings(array $settings, bool $merge = false): IRoute
     {
-        if (isset($values['names']) === true) {
-            $this->names = $values['names'];
+        if (isset($settings['names']) === true) {
+            $this->names = $settings['names'];
         }
 
-        if (isset($values['methods']) === true) {
-            $this->methodNames = $values['methods'];
+        if (isset($settings['methods']) === true) {
+            $this->methodNames = $settings['methods'];
         }
 
-        parent::setSettings($values, $merge);
-
-        return $this;
+        return parent::setSettings($settings, $merge);
     }
 
 }

src/Pecee/SimpleRouter/Route/RouteUrl.php

@@ -12,7 +12,7 @@ class RouteUrl extends LoadableRoute
         $this->setCallback($callback);
     }
 
-    public function matchRoute($url, Request $request): bool
+    public function matchRoute(string $url, Request $request): bool
     {
         if ($this->getGroup() !== null && $this->getGroup()->matchRoute($url, $request) === false) {
             return false;

src/Pecee/SimpleRouter/Router.php

@@ -110,6 +110,13 @@ class Router
      */
     protected $classLoader;
 
+    /**
+     * When enabled the router will render all routes that matches.
+     * When disabled the router will stop execution when first route is found.
+     * @var bool
+     */
+    protected $renderMultipleRoutes = true;
+
     /**
      * Router constructor.
      */
@@ -151,18 +158,20 @@ class Router
      */
     public function addRoute(IRoute $route): IRoute
     {
+        $this->fireEvents(EventHandler::EVENT_ADD_ROUTE, [
+            'route' => $route,
+        ]);
+
         /*
          * If a route is currently being processed, that means that the route being added are rendered from the parent
          * routes callback, so we add them to the stack instead.
          */
         if ($this->isProcessingRoute === true) {
             $this->routeStack[] = $route;
-
-            return $route;
+        } else {
+            $this->routes[] = $route;
         }
 
-        $this->routes[] = $route;
-
         return $route;
     }
 
@@ -186,7 +195,7 @@ class Router
             $this->routeStack = [];
 
             /* Route any routes added to the stack */
-            $this->processRoutes($stack, $route);
+            $this->processRoutes($stack, ($route instanceof IGroupRoute) ? $route : null);
         }
     }
 
@@ -260,13 +269,20 @@ class Router
 
     /**
      * Load routes
-     * @throws NotFoundHttpException
      * @return void
+     * @throws NotFoundHttpException
      */
     public function loadRoutes(): void
     {
         $this->debug('Loading routes');
 
+        $this->fireEvents(EventHandler::EVENT_LOAD_ROUTES, [
+            'routes' => $this->routes,
+        ]);
+
+        /* Loop through each route-request */
+        $this->processRoutes($this->routes);
+
         $this->fireEvents(EventHandler::EVENT_BOOT, [
             'bootmanagers' => $this->bootManagers,
         ]);
@@ -289,13 +305,6 @@ class Router
             $this->debug('Finished rendering bootmanager "%s"', $className);
         }
 
-        $this->fireEvents(EventHandler::EVENT_LOAD_ROUTES, [
-            'routes' => $this->routes,
-        ]);
-
-        /* Loop through each route-request */
-        $this->processRoutes($this->routes);
-
         $this->debug('Finished loading routes');
     }
 
@@ -303,7 +312,7 @@ class Router
      * Start the routing
      *
      * @return string|null
-     * @throws \Pecee\SimpleRouter\Exceptions\NotFoundHttpException
+     * @throws NotFoundHttpException
      * @throws \Pecee\Http\Middleware\Exceptions\TokenMismatchException
      * @throws HttpException
      * @throws \Exception
@@ -348,7 +357,7 @@ class Router
     {
         $this->debug('Routing request');
 
-        $methodNotAllowed = false;
+        $methodNotAllowed = null;
 
         try {
             $url = $this->request->getRewriteUrl() ?? $this->request->getUrl()->getPath();
@@ -368,7 +377,12 @@ class Router
                     /* Check if request method matches */
                     if (\count($route->getRequestMethods()) !== 0 && \in_array($this->request->getMethod(), $route->getRequestMethods(), true) === false) {
                         $this->debug('Method "%s" not allowed', $this->request->getMethod());
-                        $methodNotAllowed = true;
+
+                        // Only set method not allowed is not already set
+                        if ($methodNotAllowed === null) {
+                            $methodNotAllowed = true;
+                        }
+
                         continue;
                     }
 
@@ -392,14 +406,21 @@ class Router
                         'route' => $route,
                     ]);
 
-                    $output = $route->renderRoute($this->request, $this);
-                    if ($output !== null) {
-                        return $output;
-                    }
+                    $routeOutput = $route->renderRoute($this->request, $this);
 
-                    $output = $this->handleRouteRewrite($key, $url);
-                    if ($output !== null) {
-                        return $output;
+                    if ($this->renderMultipleRoutes === true) {
+                        if ($routeOutput !== null) {
+                            return $routeOutput;
+                        }
+
+                        $output = $this->handleRouteRewrite($key, $url);
+                        if ($output !== null) {
+                            return $output;
+                        }
+                    } else {
+                        $output = $this->handleRouteRewrite($key, $url);
+
+                        return $output ?? $routeOutput;
                     }
                 }
             }
@@ -410,7 +431,7 @@ class Router
 
         if ($methodNotAllowed === true) {
             $message = sprintf('Route "%s" or method "%s" not allowed.', $this->request->getUrl()->getPath(), $this->request->getMethod());
-            $this->handleException(new HttpException($message, 403));
+            $this->handleException(new NotFoundHttpException($message, 403));
         }
 
         if (\count($this->request->getLoadedRoutes()) === 0) {
@@ -440,7 +461,7 @@ class Router
      * @throws HttpException
      * @throws \Exception
      */
-    protected function handleRouteRewrite($key, string $url): ?string
+    protected function handleRouteRewrite(string $key, string $url): ?string
     {
         /* If the request has changed */
         if ($this->request->hasPendingRewrite() === false) {
@@ -455,7 +476,9 @@ class Router
         }
 
         if ($this->request->getRewriteUrl() !== $url) {
+
             unset($this->processedRoutes[$key]);
+
             $this->request->setHasPendingRewrite(false);
 
             $this->fireEvents(EventHandler::EVENT_REWRITE, [
@@ -471,9 +494,9 @@ class Router
 
     /**
      * @param \Exception $e
-     * @throws HttpException
-     * @throws \Exception
      * @return string|null
+     * @throws \Exception
+     * @throws HttpException
      */
     protected function handleException(\Exception $e): ?string
     {
@@ -504,12 +527,12 @@ class Router
             }
 
             try {
-
                 $this->debug('Start rendering exception handler');
                 $handler->handleError($this->request, $e);
                 $this->debug('Finished rendering exception-handler');
 
                 if (isset($this->loadedExceptionHandlers[$key]) === false && $this->request->hasPendingRewrite() === true) {
+
                     $this->loadedExceptionHandlers[$key] = $handler;
 
                     $this->debug('Exception handler contains rewrite, reloading routes');
@@ -519,6 +542,10 @@ class Router
                         'rewriteRoute' => $this->request->getRewriteRoute(),
                     ]);
 
+                    if ($this->request->getRewriteRoute() !== null) {
+                        $this->processedRoutes[] = $this->request->getRewriteRoute();
+                    }
+
                     return $this->routeRequest();
                 }
 
@@ -558,7 +585,7 @@ class Router
             }
 
             /* Direct match to controller */
-            if ($route instanceof IControllerRoute && strtolower($route->getController()) === strtolower($name)) {
+            if ($route instanceof IControllerRoute && strtoupper($route->getController()) === strtoupper($name)) {
                 $this->debug('Found route "%s" by controller "%s"', $route->getUrl(), $name);
 
                 return $route;
@@ -577,7 +604,7 @@ class Router
 
             /* Check if callback matches (if it's not a function) */
             $callback = $route->getCallback();
-            if (\is_string($name) === true && \is_string($callback) === true && strpos($name, '@') !== false && strpos($callback, '@') !== false && \is_callable($callback) === false) {
+            if (\is_string($name) === true && \is_string($callback) === true && \is_callable($callback) === false && strpos($name, '@') !== false && strpos($callback, '@') !== false) {
 
                 /* Check if the entire callback is matching */
                 if (strpos($callback, $name) === 0 || strtolower($callback) === strtolower($name)) {
@@ -617,7 +644,6 @@ class Router
      * @param array|null $getParams
      * @return Url
      * @throws InvalidArgumentException
-     * @throws \Pecee\Http\Exceptions\MalformedUrlException
      */
     public function getUrl(?string $name = null, $parameters = null, ?array $getParams = null): Url
     {
@@ -638,11 +664,7 @@ class Router
         }
 
         /* Only merge $_GET when all parameters are null */
-        if ($name === null && $parameters === null && $getParams === null) {
-            $getParams = $_GET;
-        } else {
-            $getParams = (array)$getParams;
-        }
+        $getParams = ($name === null && $parameters === null && $getParams === null) ? $_GET : (array)$getParams;
 
         /* Return current route if no options has been specified */
         if ($name === null && $parameters === null) {
@@ -661,14 +683,16 @@ class Router
                 ->setParams($getParams);
         }
 
-        /* We try to find a match on the given name */
-        $route = $this->findRoute($name);
+        if($name !== null) {
+            /* We try to find a match on the given name */
+            $route = $this->findRoute($name);
 
-        if ($route !== null) {
-            return $this->request
-                ->getUrlCopy()
-                ->setPath($route->findUrl($route->getMethod(), $parameters, $name))
-                ->setParams($getParams);
+            if ($route !== null) {
+                return $this->request
+                    ->getUrlCopy()
+                    ->setPath($route->findUrl($route->getMethod(), $parameters, $name))
+                    ->setParams($getParams);
+            }
         }
 
         /* Using @ is most definitely a controller@method or alias@method */
@@ -798,26 +822,20 @@ class Router
      * Set csrf verifier class
      *
      * @param BaseCsrfVerifier $csrfVerifier
-     * @return static
      */
-    public function setCsrfVerifier(BaseCsrfVerifier $csrfVerifier): self
+    public function setCsrfVerifier(BaseCsrfVerifier $csrfVerifier): void
     {
         $this->csrfVerifier = $csrfVerifier;
-
-        return $this;
     }
 
     /**
      * Set class loader
      *
      * @param IClassLoader $loader
-     * @return static
      */
-    public function setClassLoader(IClassLoader $loader)
+    public function setClassLoader(IClassLoader $loader): void
     {
         $this->classLoader = $loader;
-
-        return $this;
     }
 
     /**
@@ -834,13 +852,10 @@ class Router
      * Register event handler
      *
      * @param IEventHandler $handler
-     * @return static
      */
-    public function addEventHandler(IEventHandler $handler): self
+    public function addEventHandler(IEventHandler $handler): void
     {
         $this->eventHandlers[] = $handler;
-
-        return $this;
     }
 
     /**
@@ -859,7 +874,7 @@ class Router
      * @param string $name
      * @param array $arguments
      */
-    protected function fireEvents($name, array $arguments = []): void
+    protected function fireEvents(string $name, array $arguments = []): void
     {
         if (\count($this->eventHandlers) === 0) {
             return;
@@ -913,4 +928,19 @@ class Router
         return $this->debugList;
     }
 
+    /**
+     * Changes the rendering behavior of the router.
+     * When enabled the router will render all routes that matches.
+     * When disabled the router will stop rendering at the first route that matches.
+     *
+     * @param bool $bool
+     * @return $this
+     */
+    public function setRenderMultipleRoutes(bool $bool): self
+    {
+        $this->renderMultipleRoutes = $bool;
+
+        return $this;
+    }
+
 }

src/Pecee/SimpleRouter/SimpleRouter.php

@@ -10,9 +10,7 @@
 
 namespace Pecee\SimpleRouter;
 
-use DI\Container;
 use Pecee\Exceptions\InvalidArgumentException;
-use Pecee\Http\Exceptions\MalformedUrlException;
 use Pecee\Http\Middleware\BaseCsrfVerifier;
 use Pecee\Http\Request;
 use Pecee\Http\Response;
@@ -60,6 +58,11 @@ class SimpleRouter
      */
     public static function start(): void
     {
+        // Set default namespaces
+        foreach (static::router()->getRoutes() as $route) {
+            static::addDefaultNamespace($route);
+        }
+
         echo static::router()->start();
     }
 
@@ -74,10 +77,8 @@ class SimpleRouter
 
         try {
             ob_start();
-            static::router()->setDebugEnabled(true);
-            static::start();
-            $routerOutput = ob_get_contents();
-            ob_end_clean();
+            static::router()->setDebugEnabled(true)->start();
+            $routerOutput = ob_get_clean();
         } catch (\Exception $e) {
 
         }
@@ -160,83 +161,98 @@ class SimpleRouter
         static::router()->addBootManager($bootManager);
     }
 
+    /**
+     * Redirect to when route matches.
+     *
+     * @param string $where
+     * @param string $to
+     * @param int $httpCode
+     * @return IRoute
+     */
+    public static function redirect(string $where, string $to, int $httpCode = 301): IRoute
+    {
+        return static::get($where, function () use ($to, $httpCode) {
+            static::response()->redirect($to, $httpCode);
+        });
+    }
+
     /**
      * Route the given url to your callback on GET request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      *
      * @return RouteUrl
      */
     public static function get(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['get'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_GET], $url, $callback, $settings);
     }
 
     /**
      * Route the given url to your callback on POST request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl
      */
     public static function post(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['post'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_POST], $url, $callback, $settings);
     }
 
     /**
      * Route the given url to your callback on PUT request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl
      */
     public static function put(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['put'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_PUT], $url, $callback, $settings);
     }
 
     /**
      * Route the given url to your callback on PATCH request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl
      */
     public static function patch(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['patch'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_PATCH], $url, $callback, $settings);
     }
 
     /**
      * Route the given url to your callback on OPTIONS request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl
      */
     public static function options(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['options'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_OPTIONS], $url, $callback, $settings);
     }
 
     /**
      * Route the given url to your callback on DELETE request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl
      */
     public static function delete(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['delete'], $url, $callback, $settings);
+        return static::match([Request::REQUEST_TYPE_DELETE], $url, $callback, $settings);
     }
 
     /**
@@ -247,7 +263,7 @@ class SimpleRouter
      * @return RouteGroup
      * @throws InvalidArgumentException
      */
-    public static function group(array $settings = [], \Closure $callback): IGroupRoute
+    public static function group(array $settings, \Closure $callback): IGroupRoute
     {
         if (\is_callable($callback) === false) {
             throw new InvalidArgumentException('Invalid callback provided. Only functions or methods supported');
@@ -293,14 +309,14 @@ class SimpleRouter
      * Alias for the form method
      *
      * @param string $url
-     * @param callable $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
-     * @see SimpleRouter::form
      * @return RouteUrl
+     * @see SimpleRouter::form
      */
     public static function basic(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['get', 'post'], $url, $callback, $settings);
+        return static::form($url, $callback, $settings);
     }
 
     /**
@@ -308,14 +324,17 @@ class SimpleRouter
      * Route the given url to your callback on POST and GET request method.
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
-     * @see SimpleRouter::form
      * @return RouteUrl
+     * @see SimpleRouter::form
      */
     public static function form(string $url, $callback, array $settings = null): IRoute
     {
-        return static::match(['get', 'post'], $url, $callback, $settings);
+        return static::match([
+            Request::REQUEST_TYPE_GET,
+            Request::REQUEST_TYPE_POST,
+        ], $url, $callback, $settings);
     }
 
     /**
@@ -323,7 +342,7 @@ class SimpleRouter
      *
      * @param array $requestMethods
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl|IRoute
      */
@@ -331,37 +350,31 @@ class SimpleRouter
     {
         $route = new RouteUrl($url, $callback);
         $route->setRequestMethods($requestMethods);
-        $route = static::addDefaultNamespace($route);
 
         if ($settings !== null) {
             $route->setSettings($settings);
         }
 
-        static::router()->addRoute($route);
-
-        return $route;
+        return static::router()->addRoute($route);
     }
 
     /**
      * This type will route the given url to your callback and allow any type of request method
      *
      * @param string $url
-     * @param string|\Closure $callback
+     * @param string|array|\Closure $callback
      * @param array|null $settings
      * @return RouteUrl|IRoute
      */
     public static function all(string $url, $callback, array $settings = null)
     {
         $route = new RouteUrl($url, $callback);
-        $route = static::addDefaultNamespace($route);
 
         if ($settings !== null) {
             $route->setSettings($settings);
         }
 
-        static::router()->addRoute($route);
-
-        return $route;
+        return static::router()->addRoute($route);
     }
 
     /**
@@ -372,18 +385,15 @@ class SimpleRouter
      * @param array|null $settings
      * @return RouteController|IRoute
      */
-    public static function controller(string $url, $controller, array $settings = null)
+    public static function controller(string $url, string $controller, array $settings = null)
     {
         $route = new RouteController($url, $controller);
-        $route = static::addDefaultNamespace($route);
 
         if ($settings !== null) {
             $route->setSettings($settings);
         }
 
-        static::router()->addRoute($route);
-
-        return $route;
+        return static::router()->addRoute($route);
     }
 
     /**
@@ -394,18 +404,15 @@ class SimpleRouter
      * @param array|null $settings
      * @return RouteResource|IRoute
      */
-    public static function resource(string $url, $controller, array $settings = null)
+    public static function resource(string $url, string $controller, array $settings = null)
     {
         $route = new RouteResource($url, $controller);
-        $route = static::addDefaultNamespace($route);
 
         if ($settings !== null) {
             $route->setSettings($settings);
         }
 
-        static::router()->addRoute($route);
-
-        return $route;
+        return static::router()->addRoute($route);
     }
 
     /**
@@ -447,26 +454,19 @@ class SimpleRouter
      * @param array|null $getParams
      * @return Url
      */
-    public static function getUrl(?string $name = null, $parameters = null, $getParams = null): Url
+    public static function getUrl(?string $name = null, $parameters = null, ?array $getParams = null): Url
     {
         try {
             return static::router()->getUrl($name, $parameters, $getParams);
         } catch (\Exception $e) {
-            try {
-                return new Url('/');
-            } catch (MalformedUrlException $e) {
-
-            }
+            return new Url('/');
         }
-
-        // This will never happen...
-        return null;
     }
 
     /**
      * Get the request
      *
-     * @return \Pecee\Http\Request
+     * @return Request
      */
     public static function request(): Request
     {
@@ -511,39 +511,43 @@ class SimpleRouter
     {
         if (static::$defaultNamespace !== null) {
 
-            $callback = $route->getCallback();
+            $ns = static::$defaultNamespace;
+            $namespace = $route->getNamespace();
 
-            /* Only add default namespace on relative callbacks */
-            if ($callback === null || (\is_string($callback) === true && $callback[0] !== '\\')) {
-
-                $namespace = static::$defaultNamespace;
-
-                $currentNamespace = $route->getNamespace();
-
-                if ($currentNamespace !== null) {
-                    $namespace .= '\\' . $currentNamespace;
+            if ($namespace !== null) {
+                // Don't overwrite namespaces that starts with \
+                if ($namespace[0] !== '\\') {
+                    $ns .= '\\' . $namespace;
+                } else {
+                    $ns = $namespace;
                 }
-
-                $route->setDefaultNamespace($namespace);
-
             }
+
+            $route->setNamespace($ns);
         }
 
         return $route;
     }
 
     /**
-     * Enable or disable dependency injection
+     * Changes the rendering behavior of the router.
+     * When enabled the router will render all routes that matches.
+     * When disabled the router will stop rendering at the first route that matches.
      *
-     * @param Container $container
-     * @return IClassLoader
+     * @param bool $bool
      */
-    public static function enableDependencyInjection(Container $container): IClassLoader
+    public static function enableMultiRouteRendering(bool $bool): void
     {
-        return static::router()
-            ->getClassLoader()
-            ->useDependencyInjection(true)
-            ->setContainer($container);
+        static::router()->setRenderMultipleRoutes($bool);
+    }
+
+    /**
+     * Set custom class-loader class used.
+     * @param IClassLoader $classLoader
+     */
+    public static function setCustomClassLoader(IClassLoader $classLoader): void
+    {
+        static::router()->setClassLoader($classLoader);
     }
 
     /**

tests/Pecee/SimpleRouter/BootManagerTest.php

@@ -0,0 +1,49 @@
+<?php
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+require_once 'Dummy/Handler/ExceptionHandler.php';
+require_once 'Dummy/Managers/TestBootManager.php';
+require_once 'Dummy/Managers/FindUrlBootManager.php';
+
+class BootManagerTest extends \PHPUnit\Framework\TestCase
+{
+
+    public function testBootManagerRoutes()
+    {
+        $result = false;
+
+        TestRouter::get('/', function () use (&$result) {
+            $result = true;
+        });
+        TestRouter::get('/about', 'DummyController@method2');
+        TestRouter::get('/contact', 'DummyController@method3');
+
+        // Add boot-manager
+        TestRouter::addBootManager(new TestBootManager([
+            '/con'     => '/about',
+            '/contact' => '/',
+        ]));
+
+        TestRouter::debug('/contact');
+
+        $this->assertTrue($result);
+    }
+
+    public function testFindUrlFromBootManager()
+    {
+        TestRouter::get('/', 'DummyController@method1');
+        TestRouter::get('/about', 'DummyController@method2')->name('about');
+        TestRouter::get('/contact', 'DummyController@method3')->name('contact');
+
+        $result = false;
+
+        // Add boot-manager
+        TestRouter::addBootManager(new FindUrlBootManager($result));
+
+        TestRouter::debug('/');
+
+        $this->assertTrue($result);
+    }
+
+}

tests/Pecee/SimpleRouter/ClassLoaderTest.php

@@ -0,0 +1,30 @@
+<?php
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+require_once 'Dummy/ClassLoader/CustomClassLoader.php';
+
+class ClassLoaderTest extends \PHPUnit\Framework\TestCase
+{
+
+    public function testCustomClassLoader()
+    {
+        $result = false;
+
+        TestRouter::setCustomClassLoader(new CustomClassLoader());
+
+        TestRouter::get('/', 'NonExistingClass@method3');
+        TestRouter::get('/test-closure', function($status) use(&$result) {
+            $result = $status;
+        });
+
+        $classLoaderClass = TestRouter::debugOutput('/', 'get', false);
+        TestRouter::debugOutput('/test-closure');
+
+        $this->assertEquals('method3', $classLoaderClass);
+        $this->assertTrue($result);
+
+        TestRouter::router()->reset();
+    }
+
+}

tests/Pecee/SimpleRouter/DependencyInjectionTest.php

@@ -1,53 +0,0 @@
-<?php
-
-require_once 'Dummy/DummyMiddleware.php';
-
-class DependencyInjectionTest extends \PHPUnit\Framework\TestCase
-{
-    public function testDependencyInjectionDevelopment()
-    {
-        $builder = new \DI\ContainerBuilder();
-        $container = $builder
-            ->useAutowiring(true)
-            ->ignorePhpDocErrors(true)
-            ->build();
-
-        TestRouter::enableDependencyInjection($container);
-
-        $className = null;
-
-        TestRouter::get('/', function (DummyMiddleware $url) use (&$className) {
-            $className = \get_class($url);
-        });
-
-        TestRouter::debug('/');
-
-        $this->assertEquals(DummyMiddleware::class, $className);
-    }
-
-    public function testDependencyInjectionProduction()
-    {
-        $cacheDir = dirname(__DIR__, 2) . '/tmp';
-
-        $builder = new \DI\ContainerBuilder();
-        $builder
-            ->enableCompilation($cacheDir)
-            ->writeProxiesToFile(true, $cacheDir . '/proxies')
-            ->ignorePhpDocErrors(true)
-            ->useAutowiring(true);
-
-        $container = $builder->build();
-
-        TestRouter::enableDependencyInjection($container);
-
-        $className = null;
-
-        TestRouter::get('/', function (DummyMiddleware $url) use (&$className) {
-            $className = \get_class($url);
-        });
-
-        TestRouter::debug('/');
-
-        $this->assertEquals(DummyMiddleware::class, $className);
-    }
-}

tests/Pecee/SimpleRouter/Dummy/ClassLoader/CustomClassLoader.php

@@ -0,0 +1,14 @@
+<?php
+
+class CustomClassLoader implements \Pecee\SimpleRouter\ClassLoader\IClassLoader
+{
+    public function loadClass(string $class)
+    {
+        return new DummyController();
+    }
+
+    public function loadClosure(callable $closure, array $parameters)
+    {
+        return \call_user_func_array($closure, ['result' => true]);
+    }
+}

tests/Pecee/SimpleRouter/Dummy/DummyController.php

@@ -2,6 +2,12 @@
 
 class DummyController
 {
+    public function index()
+    {
+
+    }
+
+
 	public function method1()
 	{
 
@@ -10,6 +16,11 @@ class DummyController
     public function method2()
     {
 
+    }
+
+    public function method3()
+    {
+        return 'method3';
     }
 
 	public function param($params = null)

tests/Pecee/SimpleRouter/Dummy/Managers/FindUrlBootManager.php

@@ -0,0 +1,26 @@
+<?php
+
+class FindUrlBootManager implements \Pecee\SimpleRouter\IRouterBootManager
+{
+    protected $result;
+
+    public function __construct(&$result)
+    {
+        $this->result = &$result;
+    }
+
+    /**
+     * Called when router loads it's routes
+     *
+     * @param \Pecee\SimpleRouter\Router $router
+     * @param \Pecee\Http\Request $request
+     */
+    public function boot(\Pecee\SimpleRouter\Router $router, \Pecee\Http\Request $request): void
+    {
+        $contact = $router->findRoute('contact');
+
+        if($contact !== null) {
+            $this->result = true;
+        }
+    }
+}

tests/Pecee/SimpleRouter/Dummy/Managers/TestBootManager.php

@@ -3,13 +3,11 @@
 class TestBootManager implements \Pecee\SimpleRouter\IRouterBootManager
 {
 
-    protected $routes;
-    protected $aliasUrl;
+    protected $rewrite;
 
-    public function __construct(array $routes, string $aliasUrl)
+    public function __construct(array $rewrite)
     {
-        $this->routes = $routes;
-        $this->aliasUrl = $aliasUrl;
+        $this->rewrite = $rewrite;
     }
 
     /**
@@ -20,11 +18,11 @@ class TestBootManager implements \Pecee\SimpleRouter\IRouterBootManager
      */
     public function boot(\Pecee\SimpleRouter\Router $router, \Pecee\Http\Request $request): void
     {
-        foreach ($this->routes as $url) {
+        foreach ($this->rewrite as $url => $rewrite) {
             // If the current url matches the rewrite url, we use our custom route
 
             if ($request->getUrl()->contains($url) === true) {
-                $request->setRewriteUrl($this->aliasUrl);
+                $request->setRewriteUrl($rewrite);
             }
 
         }

tests/Pecee/SimpleRouter/Dummy/ResourceController.php

@@ -4,43 +4,36 @@ class ResourceController implements \Pecee\Controllers\IResourceController
 
     public function index() : ?string
     {
-        echo 'index';
-        return null;
+        return 'index';
     }
 
     public function show($id) : ?string
     {
-        echo 'show ' . $id;
-        return null;
+        return 'show ' . $id;
     }
 
     public function store() : ?string
     {
-        echo 'store';
-        return null;
+        return 'store';
     }
 
     public function create() : ?string
     {
-        echo 'create';
-        return null;
+        return 'create';
     }
 
     public function edit($id) : ?string
     {
-        echo 'edit ' . $id;
-        return null;
+        return 'edit ' . $id;
     }
 
     public function update($id) : ?string
     {
-        echo 'update ' . $id;
-        return null;
+        return 'update ' . $id;
     }
 
     public function destroy($id) : ?string
     {
-        echo 'destroy ' . $id;
-        return null;
+        return 'destroy ' . $id;
     }
 }

tests/Pecee/SimpleRouter/EventHandlerTest.php

@@ -6,8 +6,8 @@ require_once 'Dummy/Handler/ExceptionHandler.php';
 require_once 'Dummy/Security/SilentTokenProvider.php';
 require_once 'Dummy/Managers/TestBootManager.php';
 
-use \Pecee\SimpleRouter\Handlers\EventHandler;
-use \Pecee\SimpleRouter\Event\EventArgument;
+use Pecee\SimpleRouter\Event\EventArgument;
+use Pecee\SimpleRouter\Handlers\EventHandler;
 
 class EventHandlerTest extends \PHPUnit\Framework\TestCase
 {
@@ -50,8 +50,8 @@ class EventHandlerTest extends \PHPUnit\Framework\TestCase
 
         // Add boot-manager
         TestRouter::addBootManager(new TestBootManager([
-            '/test',
-        ], '/'));
+            '/test' => '/',
+        ]));
 
         // Start router
         TestRouter::debug('/non-existing');
@@ -61,7 +61,6 @@ class EventHandlerTest extends \PHPUnit\Framework\TestCase
 
     public function testAllEvent()
     {
-
         $status = false;
 
         $eventHandler = new EventHandler();
@@ -78,4 +77,30 @@ class EventHandlerTest extends \PHPUnit\Framework\TestCase
         $this->assertEquals(true, $status);
     }
 
+    public function testPrefixEvent()
+    {
+
+        $eventHandler = new EventHandler();
+        $eventHandler->register(EventHandler::EVENT_ADD_ROUTE, function (EventArgument $arg) use (&$status) {
+
+            if ($arg->route instanceof \Pecee\SimpleRouter\Route\LoadableRoute) {
+                $arg->route->prependUrl('/local-path');
+            }
+
+        });
+
+        TestRouter::addEventHandler($eventHandler);
+
+        $status = false;
+
+        TestRouter::get('/', function () use (&$status) {
+            $status = true;
+        });
+
+        TestRouter::debug('/local-path');
+
+        $this->assertTrue($status);
+
+    }
+
 }

tests/Pecee/SimpleRouter/InputHandlerTest.php

@@ -1,35 +1,274 @@
 <?php
 
+use Pecee\Http\Input\InputFile;
+
 require_once 'Dummy/DummyMiddleware.php';
 require_once 'Dummy/DummyController.php';
 require_once 'Dummy/Handler/ExceptionHandler.php';
 
 class InputHandlerTest extends \PHPUnit\Framework\TestCase
 {
+    protected $names = [
+        'Lester',
+        'Michael',
+        'Franklin',
+        'Trevor',
+    ];
 
-    public function testGet()
-    {
-        $this->assertEquals(true, true);
-    }
+    protected $brands = [
+        'Samsung',
+        'Apple',
+        'HP',
+        'Canon',
+    ];
+
+    protected $sodas = [
+        0 => 'Pepsi',
+        1 => 'Coca Cola',
+        2 => 'Harboe',
+        3 => 'Mountain Dew',
+    ];
+
+    protected $day = 'monday';
 
     public function testPost()
     {
-        $this->assertEquals(true, true);
+        global $_POST;
+
+        $_POST = [
+            'names' => $this->names,
+            'day' => $this->day,
+            'sodas' => $this->sodas,
+        ];
+
+        $router = TestRouter::router();
+        $router->reset();
+        $router->getRequest()->setMethod('post');
+
+        $handler = TestRouter::request()->getInputHandler();
+
+        $this->assertEquals($this->names, $handler->value('names'));
+        $this->assertEquals($this->names, $handler->all(['names'])['names']);
+        $this->assertEquals($this->day, $handler->value('day'));
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $handler->find('day'));
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $handler->post('day'));
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $handler->find('day', 'post'));
+
+        // Check non-existing and wrong request-type
+        $this->assertCount(1, $handler->all(['non-existing']));
+        $this->assertEmpty($handler->all(['non-existing'])['non-existing']);
+        $this->assertNull($handler->value('non-existing'));
+        $this->assertNull($handler->find('non-existing'));
+        $this->assertNull($handler->value('names', null, 'get'));
+        $this->assertNull($handler->find('names', 'get'));
+        $this->assertEquals($this->sodas, $handler->value('sodas'));
+
+        $objects = $handler->find('names');
+
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $objects);
+        $this->assertCount(4, $objects);
+
+        /* @var $object \Pecee\Http\Input\InputItem */
+        foreach($objects as $i => $object) {
+            $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $object);
+            $this->assertEquals($this->names[$i], $object->getValue());
+        }
+
+        // Reset
+        $_POST = [];
     }
 
+    public function testGet()
+    {
+        global $_GET;
+
+        $_GET = [
+            'names' => $this->names,
+            'day' => $this->day,
+        ];
+
+        $router = TestRouter::router();
+        $router->reset();
+        $router->getRequest()->setMethod('get');
+
+        $handler = TestRouter::request()->getInputHandler();
+
+        $this->assertEquals($this->names, $handler->value('names'));
+        $this->assertEquals($this->names, $handler->all(['names'])['names']);
+        $this->assertEquals($this->day, $handler->value('day'));
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $handler->find('day'));
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $handler->get('day'));
+
+        // Check non-existing and wrong request-type
+        $this->assertCount(1, $handler->all(['non-existing']));
+        $this->assertEmpty($handler->all(['non-existing'])['non-existing']);
+        $this->assertNull($handler->value('non-existing'));
+        $this->assertNull($handler->find('non-existing'));
+        $this->assertNull($handler->value('names', null, 'post'));
+        $this->assertNull($handler->find('names', 'post'));
+
+        $objects = $handler->find('names');
+
+        $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $objects);
+        $this->assertCount(4, $objects);
+
+        /* @var $object \Pecee\Http\Input\InputItem */
+        foreach($objects as $i => $object) {
+            $this->assertInstanceOf(\Pecee\Http\Input\InputItem::class, $object);
+            $this->assertEquals($this->names[$i], $object->getValue());
+        }
+
+        // Reset
+        $_GET = [];
+    }
+
+
+
     public function testFile()
     {
-        $this->assertEquals(true, true);
+        global $_FILES;
+
+        $testFile = $this->generateFile();
+
+        $_FILES = [
+            'test_input' => $testFile,
+        ];
+
+        $router = TestRouter::router();
+        $router->reset();
+        $router->getRequest()->setMethod('post');
+        $inputHandler = TestRouter::request()->getInputHandler();
+
+        $testFileContent = md5(uniqid('test', false));
+
+        $file = $inputHandler->file('test_input');
+
+        $this->assertInstanceOf(InputFile::class, $file);
+        $this->assertEquals($testFile['name'], $file->getFilename());
+        $this->assertEquals($testFile['type'], $file->getType());
+        $this->assertEquals($testFile['tmp_name'], $file->getTmpName());
+        $this->assertEquals($testFile['error'], $file->getError());
+        $this->assertEquals($testFile['size'], $file->getSize());
+        $this->assertEquals(pathinfo($testFile['name'], PATHINFO_EXTENSION), $file->getExtension());
+
+        file_put_contents($testFile['tmp_name'], $testFileContent);
+        $this->assertEquals($testFileContent, $file->getContents());
+
+        // Cleanup
+        unlink($testFile['tmp_name']);
     }
 
-    public function testFiles()
+    public function testFilesArray()
     {
-        $this->assertEquals(true, true);
+        global $_FILES;
+
+        $testFiles = [
+            $file = $this->generateFile(),
+            $file = $this->generateFile(),
+            $file = $this->generateFile(),
+            $file = $this->generateFile(),
+            $file = $this->generateFile(),
+        ];
+
+        $_FILES = [
+            'my_files' => $testFiles,
+        ];
+
+        $router = TestRouter::router();
+        $router->reset();
+        $router->getRequest()->setMethod('post');
+        $inputHandler = TestRouter::request()->getInputHandler();
+
+        $files = $inputHandler->file('my_files');
+        $this->assertCount(5, $files);
+
+        /* @var $file InputFile */
+        foreach ($files as $key => $file) {
+
+            $testFileContent = md5(uniqid('test', false));
+
+            $this->assertInstanceOf(InputFile::class, $file);
+            $this->assertEquals($testFiles[$key]['name'], $file->getFilename());
+            $this->assertEquals($testFiles[$key]['type'], $file->getType());
+            $this->assertEquals($testFiles[$key]['tmp_name'], $file->getTmpName());
+            $this->assertEquals($testFiles[$key]['error'], $file->getError());
+            $this->assertEquals($testFiles[$key]['size'], $file->getSize());
+            $this->assertEquals(pathinfo($testFiles[$key]['name'], PATHINFO_EXTENSION), $file->getExtension());
+
+            file_put_contents($testFiles[$key]['tmp_name'], $testFileContent);
+
+            $this->assertEquals($testFileContent, $file->getContents());
+
+            // Cleanup
+            unlink($testFiles[$key]['tmp_name']);
+        }
+
     }
 
     public function testAll()
     {
-        $this->assertEquals(true, true);
+        global $_POST;
+        global $_GET;
+
+        $_POST = [
+            'names' => $this->names,
+            'is_sad' => true,
+        ];
+
+        $_GET = [
+            'brands' => $this->brands,
+            'is_happy' => true,
+        ];
+
+        $router = TestRouter::router();
+        $router->reset();
+        $router->getRequest()->setMethod('post');
+
+        $handler = TestRouter::request()->getInputHandler();
+
+        // GET
+        $brandsFound = $handler->all(['brands', 'nothing']);
+
+        $this->assertArrayHasKey('brands', $brandsFound);
+        $this->assertArrayHasKey('nothing', $brandsFound);
+        $this->assertEquals($this->brands, $brandsFound['brands']);
+        $this->assertNull($brandsFound['nothing']);
+
+        // POST
+        $namesFound = $handler->all(['names', 'nothing']);
+
+        $this->assertArrayHasKey('names', $namesFound);
+        $this->assertArrayHasKey('nothing', $namesFound);
+        $this->assertEquals($this->names, $namesFound['names']);
+        $this->assertNull($namesFound['nothing']);
+
+        // DEFAULT VALUE
+        $nonExisting = $handler->all([
+            'non-existing'
+        ]);
+
+        $this->assertArrayHasKey('non-existing', $nonExisting);
+        $this->assertNull($nonExisting['non-existing']);
+
+        // Reset
+        $_GET = [];
+        $_POST = [];
+    }
+
+    protected function generateFile()
+    {
+        return [
+            'name'     => uniqid('', false) . '.txt',
+            'type'     => 'text/plain',
+            'tmp_name' => sys_get_temp_dir() . '/phpYfWUiw',
+            'error'    => 0,
+            'size'     => rand(3, 40),
+        ];
+    }
+
+    protected function generateFileContent()
+    {
+        return md5(uniqid('', false));
     }
 
 }

tests/Pecee/SimpleRouter/RequestTest.php

@@ -0,0 +1,84 @@
+<?php
+
+use Pecee\Http\Input\InputFile;
+
+require_once 'Dummy/DummyMiddleware.php';
+require_once 'Dummy/DummyController.php';
+require_once 'Dummy/Handler/ExceptionHandler.php';
+
+class RequestTest extends \PHPUnit\Framework\TestCase
+{
+
+    protected function processHeader($name, $value, callable $callback)
+    {
+        global $_SERVER;
+
+        $_SERVER[$name] = $value;
+
+        $router = TestRouter::router();
+        $router->reset();
+
+        $request = $router->getRequest();
+
+        $callback($request);
+
+        // Reset everything
+        $_SERVER[$name] = null;
+        $router->reset();
+    }
+
+    public function testContentTypeParse()
+    {
+        global $_SERVER;
+
+        // Test normal content-type
+
+        $contentType = 'application/x-www-form-urlencoded';
+
+        $this->processHeader('content_type', $contentType, function(\Pecee\Http\Request $request) use($contentType) {
+            $this->assertEquals($contentType, $request->getContentType());
+        });
+
+        // Test special content-type with encoding
+
+        $contentTypeWithEncoding = 'application/x-www-form-urlencoded; charset=UTF-8';
+
+        $this->processHeader('content_type', $contentTypeWithEncoding, function(\Pecee\Http\Request $request) use($contentType) {
+            $this->assertEquals($contentType, $request->getContentType());
+        });
+    }
+
+    public function testGetIp()
+    {
+        $ip = '1.1.1.1';
+        $this->processHeader('remote_addr', $ip, function(\Pecee\Http\Request  $request) use($ip) {
+            $this->assertEquals($ip, $request->getIp());
+        });
+
+        $ip = '2.2.2.2';
+        $this->processHeader('http-cf-connecting-ip', $ip, function(\Pecee\Http\Request  $request) use($ip) {
+            $this->assertEquals($ip, $request->getIp());
+        });
+
+        $ip = '3.3.3.3';
+        $this->processHeader('http-client-ip', $ip, function(\Pecee\Http\Request  $request) use($ip) {
+            $this->assertEquals($ip, $request->getIp());
+        });
+
+        $ip = '4.4.4.4';
+        $this->processHeader('http-x-forwarded-for', $ip, function(\Pecee\Http\Request  $request) use($ip) {
+            $this->assertEquals($ip, $request->getIp());
+        });
+
+        // Test safe
+
+        $ip = '5.5.5.5';
+        $this->processHeader('http-x-forwarded-for', $ip, function(\Pecee\Http\Request  $request) {
+            $this->assertEquals(null, $request->getIp(true));
+        });
+
+    }
+
+    // TODO: implement more test-cases
+
+}

tests/Pecee/SimpleRouter/RouterPartialGroupTest.php

@@ -25,4 +25,49 @@ class RouterPartialGroupTest extends \PHPUnit\Framework\TestCase
         $this->assertEquals('param2', $result2);
     }
 
+    /**
+     * Fixed issue with partial routes not loading child groups.
+     * Reported in issue: #456
+     */
+    public function testPartialGroupWithGroup() {
+
+        $lang = null;
+
+        $route1 = '/lang/da/test/';
+        $route2 = '/lang/da/auth';
+        $route3 = '/lang/da/auth/test';
+
+        TestRouter::partialGroup(
+            '/lang/{test}/',
+            function ($lang = 'en') use($route1, $route2, $route3) {
+
+                TestRouter::get('/test/', function () use($route1) {
+                    return $route1;
+                });
+
+                TestRouter::group(['prefix' => '/auth/'], function () use($route2, $route3) {
+
+                    TestRouter::get('/', function() use($route2) {
+                        return $route2;
+                    });
+
+                    TestRouter::get('/test', function () use($route3){
+                        return $route3;
+                    });
+
+                });
+
+            }
+        );
+
+        $test1 = TestRouter::debugOutput('/lang/da/test', 'get', false);
+        $test2 = TestRouter::debugOutput('/lang/da/auth', 'get', false);
+        $test3 = TestRouter::debugOutput('/lang/da/auth/test', 'get', false);
+
+        $this->assertEquals($test1, $route1);
+        $this->assertEquals($test2, $route2);
+        $this->assertEquals($test3, $route3);
+
+    }
+
 }

tests/Pecee/SimpleRouter/RouterRewriteTest.php

@@ -6,7 +6,7 @@ require_once 'Dummy/Handler/ExceptionHandlerSecond.php';
 require_once 'Dummy/Handler/ExceptionHandlerThird.php';
 require_once 'Dummy/Middleware/RewriteMiddleware.php';
 
-class RouteRewriteTest extends \PHPUnit\Framework\TestCase
+class RouterRewriteTest extends \PHPUnit\Framework\TestCase
 {
 
     /**

tests/Pecee/SimpleRouter/RouterRouteTest.php

@@ -6,10 +6,28 @@ require_once 'Dummy/Exception/ExceptionHandlerException.php';
 
 class RouterRouteTest extends \PHPUnit\Framework\TestCase
 {
+
+    /**
+     * Issue #421: Incorrectly optional character in route
+     *
+     * @throws Exception
+     */
+    public function testOptionalCharacterRoute()
+    {
+        $result = false;
+        TestRouter::get('/api/v1/users/{userid}/projects/{id}/pages/{pageid?}', function () use (&$result) {
+            $result = true;
+        });
+
+        TestRouter::debug('/api/v1/users/1/projects/8399421535/pages/43/', 'get');
+
+        $this->assertTrue($result);
+    }
+
     public function testMultiParam()
     {
         $result = false;
-        TestRouter::get('/test-{param1}-{param2}', function ($param1, $param2) use(&$result) {
+        TestRouter::get('/test-{param1}-{param2}', function ($param1, $param2) use (&$result) {
 
             if ($param1 === 'param1' && $param2 === 'param2') {
                 $result = true;
@@ -83,24 +101,59 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
 
     public function testPathParamRegex()
     {
-        TestRouter::get('/{lang}/productscategories/{name}', 'DummyController@param', ['where' => ['lang' => '[a-z]+', 'name' => '[A-Za-z0-9\-]+']]);
+        TestRouter::get('/{lang}/productscategories/{name}', 'DummyController@param', ['where' => ['lang' => '[a-z]+', 'name' => '[A-Za-z0-9-]+']]);
         $response = TestRouter::debugOutput('/it/productscategories/system', 'get');
 
         $this->assertEquals('it, system', $response);
     }
 
+    public function testFixedDomain()
+    {
+        $result = false;
+        TestRouter::request()->setHost('admin.world.com');
+
+        TestRouter::group(['domain' => 'admin.world.com'], function () use (&$result) {
+            TestRouter::get('/test', function ($subdomain = null) use (&$result) {
+                $result = true;
+            });
+        });
+
+        TestRouter::debug('/test', 'get');
+
+        $this->assertTrue($result);
+    }
+
+    public function testFixedNotAllowedDomain()
+    {
+        $result = false;
+        TestRouter::request()->setHost('other.world.com');
+
+        TestRouter::group(['domain' => 'admin.world.com'], function () use (&$result) {
+            TestRouter::get('/', function ($subdomain = null) use (&$result) {
+                $result = true;
+            });
+        });
+
+        try {
+            TestRouter::debug('/', 'get');
+        } catch(\Exception $e) {
+
+        }
+
+        $this->assertFalse($result);
+    }
+
     public function testDomainAllowedRoute()
     {
         $result = false;
         TestRouter::request()->setHost('hello.world.com');
 
-        TestRouter::group(['domain' => '{subdomain}.world.com'], function () use(&$result) {
-            TestRouter::get('/test', function ($subdomain = null) use(&$result) {
+        TestRouter::group(['domain' => '{subdomain}.world.com'], function () use (&$result) {
+            TestRouter::get('/test', function ($subdomain = null) use (&$result) {
                 $result = ($subdomain === 'hello');
             });
         });
 
-
         TestRouter::debug('/test', 'get');
 
         $this->assertTrue($result);
@@ -113,8 +166,8 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
 
         $result = false;
 
-        TestRouter::group(['domain' => '{subdomain}.world.com'], function () use(&$result) {
-            TestRouter::get('/test', function ($subdomain = null) use(&$result) {
+        TestRouter::group(['domain' => '{subdomain}.world.com'], function () use (&$result) {
+            TestRouter::get('/test', function ($subdomain = null) use (&$result) {
                 $result = ($subdomain === 'hello');
             });
         });
@@ -127,17 +180,33 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
 
     public function testRegEx()
     {
-        TestRouter::get('/my/{path}', 'DummyController@method1')->where(['path' => '[a-zA-Z\-]+']);
+        TestRouter::get('/my/{path}', 'DummyController@method1')->where(['path' => '[a-zA-Z-]+']);
         TestRouter::debug('/my/custom-path', 'get');
 
         $this->assertTrue(true);
     }
 
-    public function testParameterDefaultValue() {
+    public function testParametersWithDashes()
+    {
 
         $defaultVariable = null;
 
-        TestRouter::get('/my/{path?}', function($path = 'working') use(&$defaultVariable) {
+        TestRouter::get('/my/{path}', function ($path = 'working') use (&$defaultVariable) {
+            $defaultVariable = $path;
+        });
+
+        TestRouter::debug('/my/hello-motto-man');
+
+        $this->assertEquals('hello-motto-man', $defaultVariable);
+
+    }
+
+    public function testParameterDefaultValue()
+    {
+
+        $defaultVariable = null;
+
+        TestRouter::get('/my/{path?}', function ($path = 'working') use (&$defaultVariable) {
             $defaultVariable = $path;
         });
 
@@ -149,7 +218,7 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
 
     public function testDefaultParameterRegex()
     {
-        TestRouter::get('/my/{path}', 'DummyController@param', ['defaultParameterRegex' => '[\w\-]+']);
+        TestRouter::get('/my/{path}', 'DummyController@param', ['defaultParameterRegex' => '[\w-]+']);
         $output = TestRouter::debugOutput('/my/custom-regex', 'get');
 
         $this->assertEquals('custom-regex', $output);
@@ -157,7 +226,7 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
 
     public function testDefaultParameterRegexGroup()
     {
-        TestRouter::group(['defaultParameterRegex' => '[\w\-]+'], function() {
+        TestRouter::group(['defaultParameterRegex' => '[\w-]+'], function () {
             TestRouter::get('/my/{path}', 'DummyController@param');
         });
 
@@ -166,4 +235,26 @@ class RouterRouteTest extends \PHPUnit\Framework\TestCase
         $this->assertEquals('custom-regex', $output);
     }
 
+    public function testClassHint()
+    {
+        TestRouter::get('/my/test/url', ['DummyController', 'method1']);
+        TestRouter::all('/my/test/url', ['DummyController', 'method1']);
+        TestRouter::match(['put', 'get', 'post'], '/my/test/url', ['DummyController', 'method1']);
+
+        TestRouter::debug('/my/test/url', 'get');
+
+        $this->assertTrue(true);
+    }
+
+    public function testSameRoutes()
+    {
+        TestRouter::get('/recipe', 'DummyController@method1')->name('add');
+        TestRouter::post('/recipe', 'DummyController@method2')->name('edit');
+
+        TestRouter::debugNoReset('/recipe', 'post');
+        TestRouter::debug('/recipe', 'get');
+
+        $this->assertTrue(true);
+    }
+
 }

tests/Pecee/SimpleRouter/RouterUrlTest.php

@@ -11,7 +11,7 @@ class RouterUrlTest extends \PHPUnit\Framework\TestCase
     {
         TestRouter::get('/', 'DummyController@method1');
         TestRouter::get('/page/{id?}', 'DummyController@method1');
-        TestRouter::get('/test-output', function() {
+        TestRouter::get('/test-output', function () {
             return 'return value';
         });
 
@@ -30,8 +30,8 @@ class RouterUrlTest extends \PHPUnit\Framework\TestCase
     public function testUnicodeCharacters()
     {
         // Test spanish characters
-        TestRouter::get('/cursos/listado/{listado?}/{category?}', 'DummyController@method1', ['defaultParameterRegex' => '[\w\p{L}\s-]+']);
-        TestRouter::get('/test/{param}', 'DummyController@method1', ['defaultParameterRegex' => '[\w\p{L}\s-\í]+']);
+        TestRouter::get('/cursos/listado/{listado?}/{category?}', 'DummyController@method1', ['defaultParameterRegex' => '[\w\p{L}\s\-]+']);
+        TestRouter::get('/test/{param}', 'DummyController@method1', ['defaultParameterRegex' => '[\w\p{L}\s\-\í]+']);
         TestRouter::debugNoReset('/cursos/listado/especialidad/cirugía local', 'get');
 
         $this->assertEquals('/cursos/listado/{listado?}/{category?}/', TestRouter::router()->getRequest()->getLoadedRoute()->getUrl());
@@ -78,10 +78,11 @@ class RouterUrlTest extends \PHPUnit\Framework\TestCase
     public function testSimilarUrls()
     {
         // Match normal route on alias
-        TestRouter::resource('/url11', 'DummyController@method1');
-        TestRouter::resource('/url1', 'DummyController@method1', ['as' => 'match']);
+        TestRouter::get('/url11', 'DummyController@method1');
+        TestRouter::get('/url22', 'DummyController@method2');
+        TestRouter::get('/url33', 'DummyController@method2')->name('match');
 
-        TestRouter::debugNoReset('/url1', 'get');
+        TestRouter::debugNoReset('/url33', 'get');
 
         $this->assertEquals(TestRouter::getUrl('match'), TestRouter::getUrl());
 
@@ -170,4 +171,104 @@ class RouterUrlTest extends \PHPUnit\Framework\TestCase
 
     }
 
+    public function testCustomRegex()
+    {
+        TestRouter::request()->setHost('google.com');
+
+        TestRouter::get('/admin/', function () {
+            return 'match';
+        })->setMatch('/^\/admin\/?(.*)/i');
+
+        $output = TestRouter::debugOutput('/admin/asd/bec/123', 'get');
+        $this->assertEquals('match', $output);
+    }
+
+    public function testRenderMultipleRoutesDisabled()
+    {
+        TestRouter::router()->setRenderMultipleRoutes(false);
+
+        $result = false;
+
+        TestRouter::get('/', function () use (&$result) {
+            $result = true;
+        });
+
+        TestRouter::get('/', function () use (&$result) {
+            $result = false;
+        });
+
+        TestRouter::debug('/');
+
+        $this->assertTrue($result);
+    }
+
+    public function testRenderMultipleRoutesEnabled()
+    {
+        TestRouter::router()->setRenderMultipleRoutes(true);
+
+        $result = [];
+
+        TestRouter::get('/', function () use (&$result) {
+            $result[] = 'route1';
+        });
+
+        TestRouter::get('/', function () use (&$result) {
+            $result[] = 'route2';
+        });
+
+        TestRouter::debug('/');
+
+        $this->assertCount(2, $result);    
+    }
+  
+    public function testDefaultNamespace()
+    {
+        TestRouter::setDefaultNamespace('\\Default\\Namespace');
+
+        TestRouter::get('/', 'DummyController@method1', ['as' => 'home']);
+
+        TestRouter::group([
+            'namespace' => 'Appended\Namespace',
+            'prefix'    => '/horses',
+        ], function () {
+
+            TestRouter::get('/', 'DummyController@method1');
+
+            TestRouter::group([
+                'namespace' => '\\New\\Namespace',
+                'prefix'    => '/race',
+            ], function () {
+
+                TestRouter::get('/', 'DummyController@method1');
+
+            });
+        });
+
+        // Test appended namespace
+
+        $class = null;
+
+        try {
+            TestRouter::debugNoReset('/horses/');
+        } catch (\Pecee\SimpleRouter\Exceptions\ClassNotFoundHttpException $e) {
+            $class = $e->getClass();
+        }
+
+        $this->assertEquals('\\Default\\Namespace\\Appended\Namespace\\DummyController', $class);
+
+        // Test overwritten namespace
+
+        $class = null;
+
+        try {
+            TestRouter::debugNoReset('/horses/race');
+        } catch (\Pecee\SimpleRouter\Exceptions\ClassNotFoundHttpException $e) {
+            $class = $e->getClass();
+        }
+
+        $this->assertEquals('\\New\\Namespace\\DummyController', $class);
+
+        TestRouter::router()->reset();
+    }
+
 }

tests/TestRouter.php

@@ -3,6 +3,11 @@
 class TestRouter extends \Pecee\SimpleRouter\SimpleRouter
 {
 
+    public function __construct()
+    {
+        static::request()->setHost('testhost.com');
+    }
+
     public static function debugNoReset($testUrl, $testMethod = 'get')
     {
         $request = static::request();
@@ -13,7 +18,7 @@ class TestRouter extends \Pecee\SimpleRouter\SimpleRouter
         static::start();
     }
 
-    public static function debug($testUrl, $testMethod = 'get')
+    public static function debug($testUrl, $testMethod = 'get', bool $reset = true)
     {
         try {
             static::debugNoReset($testUrl, $testMethod);
@@ -22,19 +27,20 @@ class TestRouter extends \Pecee\SimpleRouter\SimpleRouter
             throw $e;
         }
 
-        static::router()->reset();
+        if($reset === true) {
+            static::router()->reset();
+        }
 
     }
 
-    public static function debugOutput($testUrl, $testMethod = 'get')
+    public static function debugOutput($testUrl, $testMethod = 'get', bool $reset = true)
     {
         $response = null;
 
         // Route request
         ob_start();
-        static::debug($testUrl, $testMethod);
-        $response = ob_get_contents();
-        ob_end_clean();
+        static::debug($testUrl, $testMethod, $reset);
+        $response = ob_get_clean();
 
         // Return response
         return $response;