sunrise-php / http-router

tests/RouterTest.php

Indentation +341 added lines, -341 removed lines

@@ -28,345 +28,345 @@
 class RouterTest extends TestCase
 {
 
-    /**
-     * @return void
-     */
-    public function testConstructor() : void
-    {
-        $router = new Router();
-
-        $this->assertInstanceOf(RouteCollection::class, $router);
-        $this->assertInstanceOf(MiddlewareInterface::class, $router);
-        $this->assertInstanceOf(RequestHandlerInterface::class, $router);
-    }
-
-    /**
-     * @return void
-     */
-    public function testGetRoute() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $this->assertSame($routes[0], $router->getRoute($routes[0]->getName()));
-        $this->assertSame($routes[1], $router->getRoute($routes[1]->getName()));
-        $this->assertSame($routes[2], $router->getRoute($routes[2]->getName()));
-    }
-
-    /**
-     * @return void
-     */
-    public function testGetUndefinedRoute() : void
-    {
-        $router = new Router();
-
-        $this->expectException(RouteNotFoundException::class);
-        $router->getRoute('foo');
-    }
-
-    /**
-     * @return void
-     */
-    public function testMatch() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest(
-                $routes[2]->getMethods()[1],
-                $routes[2]->getPath()
-            );
-
-        $foundRoute = $router->match($request);
-
-        $this->assertSame($routes[2]->getName(), $foundRoute->getName());
-    }
-
-    /**
-     * @return void
-     */
-    public function testMatchForUnallowedMethod() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest('GET', '/');
-
-        $this->expectException(MethodNotAllowedException::class);
-
-        try {
-            $router->match($request);
-        } catch (MethodNotAllowedException $e) {
-            $allowedMethods = array_merge(
-                $routes[0]->getMethods(),
-                $routes[1]->getMethods(),
-                $routes[2]->getMethods()
-            );
-
-            $this->assertSame($allowedMethods, $e->getAllowedMethods());
-
-            throw $e;
-        }
-    }
-
-    /**
-     * @return void
-     */
-    public function testMatchForUndefinedRoute() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest($routes[0]->getMethods()[0], '/');
-
-        $this->expectException(RouteNotFoundException::class);
-        $router->match($request);
-    }
-
-    /**
-     * @return void
-     */
-    public function testHandle() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest(
-                $routes[2]->getMethods()[1],
-                $routes[2]->getPath()
-            );
-
-        $router->handle($request);
-
-        $this->assertTrue($routes[2]->getRequestHandler()->isRunned());
-    }
-
-    /**
-     * @return void
-     */
-    public function testHandleForUnallowedMethod() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest('GET', '/');
-
-        $this->expectException(MethodNotAllowedException::class);
-
-        try {
-            $router->handle($request);
-        } catch (MethodNotAllowedException $e) {
-            $allowedMethods = array_merge(
-                $routes[0]->getMethods(),
-                $routes[1]->getMethods(),
-                $routes[2]->getMethods()
-            );
-
-            $this->assertSame($allowedMethods, $e->getAllowedMethods());
-
-            throw $e;
-        }
-    }
-
-    /**
-     * @return void
-     */
-    public function testHandleForUndefinedRoute() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest($routes[0]->getMethods()[0], '/');
-
-        $this->expectException(RouteNotFoundException::class);
-        $router->handle($request);
-    }
-
-    /**
-     * @return void
-     */
-    public function testProcess() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest(
-                $routes[2]->getMethods()[1],
-                $routes[2]->getPath()
-            );
-
-        $fallback = new Fixture\BlankRequestHandler();
-
-        $router->process($request, $fallback);
-
-        $this->assertTrue($routes[2]->getRequestHandler()->isRunned());
-        $this->assertFalse($fallback->isRunned());
-    }
-
-    /**
-     * @return void
-     */
-    public function testProcessForUnallowedMethod() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest('GET', '/');
-
-        $fallback = new Fixture\BlankRequestHandler();
-
-        $router->process($request, $fallback);
-
-        $this->assertInstanceOf(
-            MethodNotAllowedException::class,
-            $fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
-        );
-
-        $this->assertTrue($fallback->isRunned());
-    }
-
-    /**
-     * @return void
-     */
-    public function testProcessForUndefinedRoute() : void
-    {
-        $routes = [
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-            new Fixture\TestRoute(),
-        ];
-
-        $router = new Router();
-        $router->addRoutes(...$routes);
-
-        $request = (new ServerRequestFactory)
-            ->createServerRequest($routes[0]->getMethods()[0], '/');
-
-        $fallback = new Fixture\BlankRequestHandler();
-
-        $router->process($request, $fallback);
-
-        $this->assertInstanceOf(
-            RouteNotFoundException::class,
-            $fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
-        );
-
-        $this->assertTrue($fallback->isRunned());
-    }
-
-    /**
-     * @return void
-     */
-    public function testMatchPatterns() : void
-    {
-        $router = new Router();
-        $router->get('test', '/{foo<[0-9]+>}/{bar<[a-zA-Z]+>}(/{baz<.*?>})', new Fixture\BlankRequestHandler());
-
-        $route = $this->discoverRoute($router, 'GET', '/1990/Surgut/Tyumen');
-        $this->assertEquals($route->getAttributes(), [
-            'foo' => '1990',
-            'bar' => 'Surgut',
-            'baz' => 'Tyumen',
-        ]);
-
-        $route = $this->discoverRoute($router, 'GET', '/1990/Surgut/Tyumen/Moscow');
-        $this->assertEquals($route->getAttributes(), [
-            'foo' => '1990',
-            'bar' => 'Surgut',
-            'baz' => 'Tyumen/Moscow',
-        ]);
-
-        $route = $this->discoverRoute($router, 'GET', '/Oops/Surgut/Tyumen/Moscow');
-        $this->assertNull($route);
-
-        $route = $this->discoverRoute($router, 'GET', '/1990/2018/Moscow');
-        $this->assertNull($route);
-    }
-
-    /**
-     * @param Router $router
-     * @param string $method
-     * @param string $uri
-     *
-     * @return null|RouteInterface
-     */
-    private function discoverRoute(Router $router, string $method, string $uri) : ?RouteInterface
-    {
-        $request = (new ServerRequestFactory)
-        ->createServerRequest($method, $uri);
-
-        try {
-            return $router->match($request);
-        } catch (ExceptionInterface $e) {
-            return null;
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function testConstructor() : void
+	{
+		$router = new Router();
+
+		$this->assertInstanceOf(RouteCollection::class, $router);
+		$this->assertInstanceOf(MiddlewareInterface::class, $router);
+		$this->assertInstanceOf(RequestHandlerInterface::class, $router);
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testGetRoute() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$this->assertSame($routes[0], $router->getRoute($routes[0]->getName()));
+		$this->assertSame($routes[1], $router->getRoute($routes[1]->getName()));
+		$this->assertSame($routes[2], $router->getRoute($routes[2]->getName()));
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testGetUndefinedRoute() : void
+	{
+		$router = new Router();
+
+		$this->expectException(RouteNotFoundException::class);
+		$router->getRoute('foo');
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testMatch() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest(
+				$routes[2]->getMethods()[1],
+				$routes[2]->getPath()
+			);
+
+		$foundRoute = $router->match($request);
+
+		$this->assertSame($routes[2]->getName(), $foundRoute->getName());
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testMatchForUnallowedMethod() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest('GET', '/');
+
+		$this->expectException(MethodNotAllowedException::class);
+
+		try {
+			$router->match($request);
+		} catch (MethodNotAllowedException $e) {
+			$allowedMethods = array_merge(
+				$routes[0]->getMethods(),
+				$routes[1]->getMethods(),
+				$routes[2]->getMethods()
+			);
+
+			$this->assertSame($allowedMethods, $e->getAllowedMethods());
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testMatchForUndefinedRoute() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest($routes[0]->getMethods()[0], '/');
+
+		$this->expectException(RouteNotFoundException::class);
+		$router->match($request);
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testHandle() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest(
+				$routes[2]->getMethods()[1],
+				$routes[2]->getPath()
+			);
+
+		$router->handle($request);
+
+		$this->assertTrue($routes[2]->getRequestHandler()->isRunned());
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testHandleForUnallowedMethod() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest('GET', '/');
+
+		$this->expectException(MethodNotAllowedException::class);
+
+		try {
+			$router->handle($request);
+		} catch (MethodNotAllowedException $e) {
+			$allowedMethods = array_merge(
+				$routes[0]->getMethods(),
+				$routes[1]->getMethods(),
+				$routes[2]->getMethods()
+			);
+
+			$this->assertSame($allowedMethods, $e->getAllowedMethods());
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testHandleForUndefinedRoute() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest($routes[0]->getMethods()[0], '/');
+
+		$this->expectException(RouteNotFoundException::class);
+		$router->handle($request);
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testProcess() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest(
+				$routes[2]->getMethods()[1],
+				$routes[2]->getPath()
+			);
+
+		$fallback = new Fixture\BlankRequestHandler();
+
+		$router->process($request, $fallback);
+
+		$this->assertTrue($routes[2]->getRequestHandler()->isRunned());
+		$this->assertFalse($fallback->isRunned());
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testProcessForUnallowedMethod() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest('GET', '/');
+
+		$fallback = new Fixture\BlankRequestHandler();
+
+		$router->process($request, $fallback);
+
+		$this->assertInstanceOf(
+			MethodNotAllowedException::class,
+			$fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
+		);
+
+		$this->assertTrue($fallback->isRunned());
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testProcessForUndefinedRoute() : void
+	{
+		$routes = [
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+			new Fixture\TestRoute(),
+		];
+
+		$router = new Router();
+		$router->addRoutes(...$routes);
+
+		$request = (new ServerRequestFactory)
+			->createServerRequest($routes[0]->getMethods()[0], '/');
+
+		$fallback = new Fixture\BlankRequestHandler();
+
+		$router->process($request, $fallback);
+
+		$this->assertInstanceOf(
+			RouteNotFoundException::class,
+			$fallback->getAttribute(Router::ATTR_NAME_FOR_ROUTING_ERROR)
+		);
+
+		$this->assertTrue($fallback->isRunned());
+	}
+
+	/**
+	 * @return void
+	 */
+	public function testMatchPatterns() : void
+	{
+		$router = new Router();
+		$router->get('test', '/{foo<[0-9]+>}/{bar<[a-zA-Z]+>}(/{baz<.*?>})', new Fixture\BlankRequestHandler());
+
+		$route = $this->discoverRoute($router, 'GET', '/1990/Surgut/Tyumen');
+		$this->assertEquals($route->getAttributes(), [
+			'foo' => '1990',
+			'bar' => 'Surgut',
+			'baz' => 'Tyumen',
+		]);
+
+		$route = $this->discoverRoute($router, 'GET', '/1990/Surgut/Tyumen/Moscow');
+		$this->assertEquals($route->getAttributes(), [
+			'foo' => '1990',
+			'bar' => 'Surgut',
+			'baz' => 'Tyumen/Moscow',
+		]);
+
+		$route = $this->discoverRoute($router, 'GET', '/Oops/Surgut/Tyumen/Moscow');
+		$this->assertNull($route);
+
+		$route = $this->discoverRoute($router, 'GET', '/1990/2018/Moscow');
+		$this->assertNull($route);
+	}
+
+	/**
+	 * @param Router $router
+	 * @param string $method
+	 * @param string $uri
+	 *
+	 * @return null|RouteInterface
+	 */
+	private function discoverRoute(Router $router, string $method, string $uri) : ?RouteInterface
+	{
+		$request = (new ServerRequestFactory)
+		->createServerRequest($method, $uri);
+
+		try {
+			return $router->match($request);
+		} catch (ExceptionInterface $e) {
+			return null;
+		}
+	}
 }

src/RouteInterface.php

Indentation +123 added lines, -123 removed lines

@@ -23,127 +23,127 @@
 interface RouteInterface
 {
 
-    /**
-     * Gets the route name
-     *
-     * @return string
-     */
-    public function getName() : string;
-
-    /**
-     * Gets the route path
-     *
-     * @return string
-     */
-    public function getPath() : string;
-
-    /**
-     * Gets the route methods
-     *
-     * @return string[]
-     */
-    public function getMethods() : array;
-
-    /**
-     * Gets the route request handler
-     *
-     * @return RequestHandlerInterface
-     */
-    public function getRequestHandler() : RequestHandlerInterface;
-
-    /**
-     * Gets the route middlewares
-     *
-     * @return MiddlewareInterface[]
-     */
-    public function getMiddlewares() : array;
-
-    /**
-     * Gets the route attributes
-     *
-     * @return array
-     */
-    public function getAttributes() : array;
-
-    /**
-     * Sets the given name to the route
-     *
-     * @param string $name
-     *
-     * @return RouteInterface
-     */
-    public function setName(string $name) : RouteInterface;
-
-    /**
-     * Sets the given path to the route
-     *
-     * @param string $path
-     *
-     * @return RouteInterface
-     */
-    public function setPath(string $path) : RouteInterface;
-
-    /**
-     * Sets the given method(s) to the route
-     *
-     * @param string ...$methods
-     *
-     * @return RouteInterface
-     */
-    public function setMethods(string ...$methods) : RouteInterface;
-
-    /**
-     * Sets the given request handler to the route
-     *
-     * @param RequestHandlerInterface $requestHandler
-     *
-     * @return RouteInterface
-     */
-    public function setRequestHandler(RequestHandlerInterface $requestHandler) : RouteInterface;
-
-    /**
-     * Sets the given middleware(s) to the route
-     *
-     * @param MiddlewareInterface ...$middlewares
-     *
-     * @return RouteInterface
-     */
-    public function setMiddlewares(MiddlewareInterface ...$middlewares) : RouteInterface;
-
-    /**
-     * Sets the given attributes to the route
-     *
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function setAttributes(array $attributes) : RouteInterface;
-
-    /**
-     * Returns the route clone with the given attributes
-     *
-     * This method MUST NOT change the state of the object.
-     *
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function withAddedAttributes(array $attributes) : RouteInterface;
-
-    /**
-     * Builds the route path
-     *
-     * @param array $attributes
-     * @param bool $strict
-     *
-     * @return string
-     */
-    public function buildPath(array $attributes, bool $strict) : string;
-
-    /**
-     * Builds the route regex
-     *
-     * @return string
-     */
-    public function buildRegex() : string;
+	/**
+	 * Gets the route name
+	 *
+	 * @return string
+	 */
+	public function getName() : string;
+
+	/**
+	 * Gets the route path
+	 *
+	 * @return string
+	 */
+	public function getPath() : string;
+
+	/**
+	 * Gets the route methods
+	 *
+	 * @return string[]
+	 */
+	public function getMethods() : array;
+
+	/**
+	 * Gets the route request handler
+	 *
+	 * @return RequestHandlerInterface
+	 */
+	public function getRequestHandler() : RequestHandlerInterface;
+
+	/**
+	 * Gets the route middlewares
+	 *
+	 * @return MiddlewareInterface[]
+	 */
+	public function getMiddlewares() : array;
+
+	/**
+	 * Gets the route attributes
+	 *
+	 * @return array
+	 */
+	public function getAttributes() : array;
+
+	/**
+	 * Sets the given name to the route
+	 *
+	 * @param string $name
+	 *
+	 * @return RouteInterface
+	 */
+	public function setName(string $name) : RouteInterface;
+
+	/**
+	 * Sets the given path to the route
+	 *
+	 * @param string $path
+	 *
+	 * @return RouteInterface
+	 */
+	public function setPath(string $path) : RouteInterface;
+
+	/**
+	 * Sets the given method(s) to the route
+	 *
+	 * @param string ...$methods
+	 *
+	 * @return RouteInterface
+	 */
+	public function setMethods(string ...$methods) : RouteInterface;
+
+	/**
+	 * Sets the given request handler to the route
+	 *
+	 * @param RequestHandlerInterface $requestHandler
+	 *
+	 * @return RouteInterface
+	 */
+	public function setRequestHandler(RequestHandlerInterface $requestHandler) : RouteInterface;
+
+	/**
+	 * Sets the given middleware(s) to the route
+	 *
+	 * @param MiddlewareInterface ...$middlewares
+	 *
+	 * @return RouteInterface
+	 */
+	public function setMiddlewares(MiddlewareInterface ...$middlewares) : RouteInterface;
+
+	/**
+	 * Sets the given attributes to the route
+	 *
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function setAttributes(array $attributes) : RouteInterface;
+
+	/**
+	 * Returns the route clone with the given attributes
+	 *
+	 * This method MUST NOT change the state of the object.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function withAddedAttributes(array $attributes) : RouteInterface;
+
+	/**
+	 * Builds the route path
+	 *
+	 * @param array $attributes
+	 * @param bool $strict
+	 *
+	 * @return string
+	 */
+	public function buildPath(array $attributes, bool $strict) : string;
+
+	/**
+	 * Builds the route regex
+	 *
+	 * @return string
+	 */
+	public function buildRegex() : string;
 }

src/Annotation/AnnotationRouteLoader.php

Indentation +129 added lines, -129 removed lines

@@ -35,133 +35,133 @@
 class AnnotationRouteLoader
 {
 
-    /**
-     * @var SimpleAnnotationReader
-     */
-    private $annotationReader;
-
-    /**
-     * @var SplPriorityQueue
-     */
-    private $discoveredAnnotations;
-
-    /**
-     * Constructor of the class
-     */
-    public function __construct()
-    {
-        $this->annotationReader = new SimpleAnnotationReader();
-        $this->annotationReader->addNamespace(__NAMESPACE__);
-
-        $this->discoveredAnnotations = new SplPriorityQueue();
-    }
-
-    /**
-     * Builds discovered routes
-     *
-     * @param null|callable $objectCreator
-     *
-     * @return array
-     */
-    public function buildRoutes(callable $objectCreator = null) : array
-    {
-        $routes = [];
-        foreach ($this->discoveredAnnotations as $annotation) {
-            $requestHandlerClass = $annotation->source->getName();
-            $requestHandler = $objectCreator ? $objectCreator($requestHandlerClass) : new $requestHandlerClass;
-
-            $middlewares = [];
-            foreach ($annotation->middlewares as $middlewareClass) {
-                $middlewares[] = $objectCreator ? $objectCreator($middlewareClass) : new $middlewareClass;
-            }
-
-            $routes[] = new BaseRoute(
-                $annotation->name,
-                $annotation->path,
-                $annotation->methods,
-                $requestHandler,
-                $middlewares,
-                $annotation->attributes
-            );
-        }
-
-        return $routes;
-    }
-
-    /**
-     * Discovers routes in the given destination
-     *
-     * @param string $destination
-     *
-     * @return void
-     */
-    public function discover(string $destination) : void
-    {
-        $annotations = $this->findAnnotations($destination, Route::class);
-
-        foreach ($annotations as $annotation) {
-            $this->discoveredAnnotations->insert($annotation, $annotation->priority);
-        }
-    }
-
-    /**
-     * Finds annotations in the given destination
-     *
-     * @param string $destination
-     * @param string $name
-     *
-     * @return array
-     */
-    private function findAnnotations(string $destination, string $name) : array
-    {
-        $classes = $this->findClasses($destination);
-        $annotations = [];
-
-        foreach ($classes as $class) {
-            $class = new ReflectionClass($class);
-            $annotation = $this->annotationReader->getClassAnnotation($class, $name);
-
-            if ($annotation instanceof $name) {
-                $annotation->source = $class;
-                $annotations[] = $annotation;
-            }
-        }
-
-        return $annotations;
-    }
-
-    /**
-     * Finds classes in the given destination
-     *
-     * @param string $destination
-     *
-     * @return array
-     */
-    private function findClasses(string $destination) : array
-    {
-        $files = $this->findFiles($destination);
-        $classes = get_declared_classes();
-
-        foreach ($files as $file) {
-            require_once $file->getRealPath();
-        }
-
-        return array_diff(get_declared_classes(), $classes);
-    }
-
-    /**
-     * Finds files in the given destination
-     *
-     * @param string $destination
-     *
-     * @return array
-     */
-    private function findFiles(string $destination) : array
-    {
-        $directory = new RecursiveDirectoryIterator($destination);
-        $iterator = new RecursiveIteratorIterator($directory);
-        $files = new RegexIterator($iterator, '/\.php$/');
-
-        return iterator_to_array($files);
-    }
+	/**
+	 * @var SimpleAnnotationReader
+	 */
+	private $annotationReader;
+
+	/**
+	 * @var SplPriorityQueue
+	 */
+	private $discoveredAnnotations;
+
+	/**
+	 * Constructor of the class
+	 */
+	public function __construct()
+	{
+		$this->annotationReader = new SimpleAnnotationReader();
+		$this->annotationReader->addNamespace(__NAMESPACE__);
+
+		$this->discoveredAnnotations = new SplPriorityQueue();
+	}
+
+	/**
+	 * Builds discovered routes
+	 *
+	 * @param null|callable $objectCreator
+	 *
+	 * @return array
+	 */
+	public function buildRoutes(callable $objectCreator = null) : array
+	{
+		$routes = [];
+		foreach ($this->discoveredAnnotations as $annotation) {
+			$requestHandlerClass = $annotation->source->getName();
+			$requestHandler = $objectCreator ? $objectCreator($requestHandlerClass) : new $requestHandlerClass;
+
+			$middlewares = [];
+			foreach ($annotation->middlewares as $middlewareClass) {
+				$middlewares[] = $objectCreator ? $objectCreator($middlewareClass) : new $middlewareClass;
+			}
+
+			$routes[] = new BaseRoute(
+				$annotation->name,
+				$annotation->path,
+				$annotation->methods,
+				$requestHandler,
+				$middlewares,
+				$annotation->attributes
+			);
+		}
+
+		return $routes;
+	}
+
+	/**
+	 * Discovers routes in the given destination
+	 *
+	 * @param string $destination
+	 *
+	 * @return void
+	 */
+	public function discover(string $destination) : void
+	{
+		$annotations = $this->findAnnotations($destination, Route::class);
+
+		foreach ($annotations as $annotation) {
+			$this->discoveredAnnotations->insert($annotation, $annotation->priority);
+		}
+	}
+
+	/**
+	 * Finds annotations in the given destination
+	 *
+	 * @param string $destination
+	 * @param string $name
+	 *
+	 * @return array
+	 */
+	private function findAnnotations(string $destination, string $name) : array
+	{
+		$classes = $this->findClasses($destination);
+		$annotations = [];
+
+		foreach ($classes as $class) {
+			$class = new ReflectionClass($class);
+			$annotation = $this->annotationReader->getClassAnnotation($class, $name);
+
+			if ($annotation instanceof $name) {
+				$annotation->source = $class;
+				$annotations[] = $annotation;
+			}
+		}
+
+		return $annotations;
+	}
+
+	/**
+	 * Finds classes in the given destination
+	 *
+	 * @param string $destination
+	 *
+	 * @return array
+	 */
+	private function findClasses(string $destination) : array
+	{
+		$files = $this->findFiles($destination);
+		$classes = get_declared_classes();
+
+		foreach ($files as $file) {
+			require_once $file->getRealPath();
+		}
+
+		return array_diff(get_declared_classes(), $classes);
+	}
+
+	/**
+	 * Finds files in the given destination
+	 *
+	 * @param string $destination
+	 *
+	 * @return array
+	 */
+	private function findFiles(string $destination) : array
+	{
+		$directory = new RecursiveDirectoryIterator($destination);
+		$iterator = new RecursiveIteratorIterator($directory);
+		$files = new RegexIterator($iterator, '/\.php$/');
+
+		return iterator_to_array($files);
+	}
 }

src/Annotation/Route.php

Indentation +89 added lines, -89 removed lines

@@ -33,93 +33,93 @@
 final class Route
 {
 
-    /**
-     * @var object
-     */
-    public $source;
-
-    /**
-     * @var string
-     */
-    public $name;
-
-    /**
-     * @var string
-     */
-    public $path;
-
-    /**
-     * @var array
-     */
-    public $methods;
-
-    /**
-     * @var array
-     */
-    public $middlewares = [];
-
-    /**
-     * @var array
-     */
-    public $attributes = [];
-
-    /**
-     * @var int
-     */
-    public $priority = 0;
-
-    /**
-     * @param array $params
-     *
-     * @throws InvalidArgumentException
-     */
-    public function __construct(array $params)
-    {
-        if (empty($params['name']) || !is_string($params['name'])) {
-            throw new InvalidArgumentException('@Route.name must be not an empty string.');
-        }
-        if (empty($params['path']) || !is_string($params['path'])) {
-            throw new InvalidArgumentException('@Route.path must be not an empty string.');
-        }
-        if (empty($params['methods']) || !is_array($params['methods'])) {
-            throw new InvalidArgumentException('@Route.methods must be not an empty array.');
-        }
-        if (isset($params['middlewares']) && !is_array($params['middlewares'])) {
-            throw new InvalidArgumentException('@Route.middlewares must be an array.');
-        }
-        if (isset($params['attributes']) && !is_array($params['attributes'])) {
-            throw new InvalidArgumentException('@Route.attributes must be an array.');
-        }
-        if (isset($params['priority']) && !is_int($params['priority'])) {
-            throw new InvalidArgumentException('@Route.priority must be an integer.');
-        }
-
-        foreach ($params['methods'] as $v) {
-            if (!is_string($v)) {
-                throw new InvalidArgumentException('@Route.methods must contain only strings.');
-            }
-        }
-
-        if (isset($params['middlewares'])) {
-            foreach ($params['middlewares'] as $v) {
-                if (!is_string($v) || !class_exists($v) || !is_subclass_of($v, MiddlewareInterface::class)) {
-                    throw new InvalidArgumentException('@Route.middlewares must contain only middlewares.');
-                }
-            }
-        }
-
-        $this->name = $params['name'];
-        $this->path = $params['path'];
-        $this->methods = $params['methods'];
-
-        if (isset($params['middlewares'])) {
-            $this->middlewares = $params['middlewares'];
-        }
-        if (isset($params['attributes'])) {
-            $this->attributes = $params['attributes'];
-        }
-        if (isset($params['priority'])) {
-            $this->priority = $params['priority'];
-        }
-    }
+	/**
+	 * @var object
+	 */
+	public $source;
+
+	/**
+	 * @var string
+	 */
+	public $name;
+
+	/**
+	 * @var string
+	 */
+	public $path;
+
+	/**
+	 * @var array
+	 */
+	public $methods;
+
+	/**
+	 * @var array
+	 */
+	public $middlewares = [];
+
+	/**
+	 * @var array
+	 */
+	public $attributes = [];
+
+	/**
+	 * @var int
+	 */
+	public $priority = 0;
+
+	/**
+	 * @param array $params
+	 *
+	 * @throws InvalidArgumentException
+	 */
+	public function __construct(array $params)
+	{
+		if (empty($params['name']) || !is_string($params['name'])) {
+			throw new InvalidArgumentException('@Route.name must be not an empty string.');
+		}
+		if (empty($params['path']) || !is_string($params['path'])) {
+			throw new InvalidArgumentException('@Route.path must be not an empty string.');
+		}
+		if (empty($params['methods']) || !is_array($params['methods'])) {
+			throw new InvalidArgumentException('@Route.methods must be not an empty array.');
+		}
+		if (isset($params['middlewares']) && !is_array($params['middlewares'])) {
+			throw new InvalidArgumentException('@Route.middlewares must be an array.');
+		}
+		if (isset($params['attributes']) && !is_array($params['attributes'])) {
+			throw new InvalidArgumentException('@Route.attributes must be an array.');
+		}
+		if (isset($params['priority']) && !is_int($params['priority'])) {
+			throw new InvalidArgumentException('@Route.priority must be an integer.');
+		}
+
+		foreach ($params['methods'] as $v) {
+			if (!is_string($v)) {
+				throw new InvalidArgumentException('@Route.methods must contain only strings.');
+			}
+		}
+
+		if (isset($params['middlewares'])) {
+			foreach ($params['middlewares'] as $v) {
+				if (!is_string($v) || !class_exists($v) || !is_subclass_of($v, MiddlewareInterface::class)) {
+					throw new InvalidArgumentException('@Route.middlewares must contain only middlewares.');
+				}
+			}
+		}
+
+		$this->name = $params['name'];
+		$this->path = $params['path'];
+		$this->methods = $params['methods'];
+
+		if (isset($params['middlewares'])) {
+			$this->middlewares = $params['middlewares'];
+		}
+		if (isset($params['attributes'])) {
+			$this->attributes = $params['attributes'];
+		}
+		if (isset($params['priority'])) {
+			$this->priority = $params['priority'];
+		}
+	}
 }

src/RequestHandler/RoutableRequestHandler.php

Indentation +34 added lines, -34 removed lines

@@ -25,45 +25,45 @@
 class RoutableRequestHandler implements RequestHandlerInterface
 {
 
-    /**
-     * Server Request attribute name for a route name
-     *
-     * @var string
-     */
-    public const ATTR_NAME_FOR_ROUTE_NAME = '@route-name';
+	/**
+	 * Server Request attribute name for a route name
+	 *
+	 * @var string
+	 */
+	public const ATTR_NAME_FOR_ROUTE_NAME = '@route-name';
 
-    /**
-     * The request handler route
-     *
-     * @var RouteInterface
-     */
-    private $route;
+	/**
+	 * The request handler route
+	 *
+	 * @var RouteInterface
+	 */
+	private $route;
 
-    /**
-     * Constructor of the class
-     *
-     * @param RouteInterface $route
-     */
-    public function __construct(RouteInterface $route)
-    {
-        $this->route = $route;
-    }
+	/**
+	 * Constructor of the class
+	 *
+	 * @param RouteInterface $route
+	 */
+	public function __construct(RouteInterface $route)
+	{
+		$this->route = $route;
+	}
 
-    /**
-     * {@inheritDoc}
-     */
-    public function handle(ServerRequestInterface $request) : ResponseInterface
-    {
-        $request = $request->withAttribute(self::ATTR_NAME_FOR_ROUTE_NAME, $this->route->getName());
+	/**
+	 * {@inheritDoc}
+	 */
+	public function handle(ServerRequestInterface $request) : ResponseInterface
+	{
+		$request = $request->withAttribute(self::ATTR_NAME_FOR_ROUTE_NAME, $this->route->getName());
 
-        foreach ($this->route->getAttributes() as $key => $value) {
-            $request = $request->withAttribute($key, $value);
-        }
+		foreach ($this->route->getAttributes() as $key => $value) {
+			$request = $request->withAttribute($key, $value);
+		}
 
-        $handler = new QueueableRequestHandler($this->route->getRequestHandler());
+		$handler = new QueueableRequestHandler($this->route->getRequestHandler());
 
-        $handler->add(...$this->route->getMiddlewares());
+		$handler->add(...$this->route->getMiddlewares());
 
-        return $handler->handle($request);
-    }
+		return $handler->handle($request);
+	}
 }

src/RequestHandler/CallableRequestHandler.php

Indentation +22 added lines, -22 removed lines

@@ -24,28 +24,28 @@
 class CallableRequestHandler implements RequestHandlerInterface
 {
 
-    /**
-     * The request handler callback
-     *
-     * @var callable
-     */
-    private $callback;
+	/**
+	 * The request handler callback
+	 *
+	 * @var callable
+	 */
+	private $callback;
 
-    /**
-     * Constructor of the class
-     *
-     * @param callable $callback
-     */
-    public function __construct(callable $callback)
-    {
-        $this->callback = $callback;
-    }
+	/**
+	 * Constructor of the class
+	 *
+	 * @param callable $callback
+	 */
+	public function __construct(callable $callback)
+	{
+		$this->callback = $callback;
+	}
 
-    /**
-     * {@inheritDoc}
-     */
-    public function handle(ServerRequestInterface $request) : ResponseInterface
-    {
-        return ($this->callback)($request);
-    }
+	/**
+	 * {@inheritDoc}
+	 */
+	public function handle(ServerRequestInterface $request) : ResponseInterface
+	{
+		return ($this->callback)($request);
+	}
 }

src/Route.php

Indentation +211 added lines, -211 removed lines

@@ -28,215 +28,215 @@
 class Route implements RouteInterface
 {
 
-    /**
-     * The route name
-     *
-     * @var string
-     */
-    private $name;
-
-    /**
-     * The route path
-     *
-     * @var string
-     */
-    private $path;
-
-    /**
-     * The route methods
-     *
-     * @var string[]
-     */
-    private $methods;
-
-    /**
-     * The route request handler
-     *
-     * @var RequestHandlerInterface
-     */
-    private $requestHandler;
-
-    /**
-     * The route middlewares
-     *
-     * @var MiddlewareInterface[]
-     */
-    private $middlewares = [];
-
-    /**
-     * The route attributes
-     *
-     * @var array
-     */
-    private $attributes = [];
-
-    /**
-     * Constructor of the class
-     *
-     * @param string $name
-     * @param string $path
-     * @param string[] $methods
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     */
-    public function __construct(
-        string $name,
-        string $path,
-        array $methods,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares = [],
-        array $attributes = []
-    ) {
-        $this->setName($name);
-        $this->setPath($path);
-        $this->setMethods(...$methods);
-        $this->setRequestHandler($requestHandler);
-        $this->setMiddlewares(...$middlewares);
-        $this->setAttributes($attributes);
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getName() : string
-    {
-        return $this->name;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getPath() : string
-    {
-        return $this->path;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getMethods() : array
-    {
-        return $this->methods;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getRequestHandler() : RequestHandlerInterface
-    {
-        return $this->requestHandler;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getMiddlewares() : array
-    {
-        return $this->middlewares;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function getAttributes() : array
-    {
-        return $this->attributes;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setName(string $name) : RouteInterface
-    {
-        $this->name = $name;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setPath(string $path) : RouteInterface
-    {
-        $this->path = $path;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setMethods(string ...$methods) : RouteInterface
-    {
-        foreach ($methods as &$method) {
-            $method = strtoupper($method);
-        }
-
-        $this->methods = $methods;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setRequestHandler(RequestHandlerInterface $requestHandler) : RouteInterface
-    {
-        $this->requestHandler = $requestHandler;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setMiddlewares(MiddlewareInterface ...$middlewares) : RouteInterface
-    {
-        $this->middlewares = $middlewares;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function setAttributes(array $attributes) : RouteInterface
-    {
-        $this->attributes = $attributes;
-
-        return $this;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function withAddedAttributes(array $attributes) : RouteInterface
-    {
-        $clone = clone $this;
-
-        foreach ($attributes as $key => $value) {
-            $clone->attributes[$key] = $value;
-        }
-
-        return $clone;
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function buildPath(array $attributes = [], bool $strict = false) : string
-    {
-        $attributes += $this->attributes;
-
-        return path_build($this->path, $attributes, $strict);
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    public function buildRegex() : string
-    {
-        return path_regex($this->path);
-    }
+	/**
+	 * The route name
+	 *
+	 * @var string
+	 */
+	private $name;
+
+	/**
+	 * The route path
+	 *
+	 * @var string
+	 */
+	private $path;
+
+	/**
+	 * The route methods
+	 *
+	 * @var string[]
+	 */
+	private $methods;
+
+	/**
+	 * The route request handler
+	 *
+	 * @var RequestHandlerInterface
+	 */
+	private $requestHandler;
+
+	/**
+	 * The route middlewares
+	 *
+	 * @var MiddlewareInterface[]
+	 */
+	private $middlewares = [];
+
+	/**
+	 * The route attributes
+	 *
+	 * @var array
+	 */
+	private $attributes = [];
+
+	/**
+	 * Constructor of the class
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param string[] $methods
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 */
+	public function __construct(
+		string $name,
+		string $path,
+		array $methods,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares = [],
+		array $attributes = []
+	) {
+		$this->setName($name);
+		$this->setPath($path);
+		$this->setMethods(...$methods);
+		$this->setRequestHandler($requestHandler);
+		$this->setMiddlewares(...$middlewares);
+		$this->setAttributes($attributes);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getName() : string
+	{
+		return $this->name;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getPath() : string
+	{
+		return $this->path;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getMethods() : array
+	{
+		return $this->methods;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getRequestHandler() : RequestHandlerInterface
+	{
+		return $this->requestHandler;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getMiddlewares() : array
+	{
+		return $this->middlewares;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function getAttributes() : array
+	{
+		return $this->attributes;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setName(string $name) : RouteInterface
+	{
+		$this->name = $name;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setPath(string $path) : RouteInterface
+	{
+		$this->path = $path;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setMethods(string ...$methods) : RouteInterface
+	{
+		foreach ($methods as &$method) {
+			$method = strtoupper($method);
+		}
+
+		$this->methods = $methods;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setRequestHandler(RequestHandlerInterface $requestHandler) : RouteInterface
+	{
+		$this->requestHandler = $requestHandler;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setMiddlewares(MiddlewareInterface ...$middlewares) : RouteInterface
+	{
+		$this->middlewares = $middlewares;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function setAttributes(array $attributes) : RouteInterface
+	{
+		$this->attributes = $attributes;
+
+		return $this;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function withAddedAttributes(array $attributes) : RouteInterface
+	{
+		$clone = clone $this;
+
+		foreach ($attributes as $key => $value) {
+			$clone->attributes[$key] = $value;
+		}
+
+		return $clone;
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function buildPath(array $attributes = [], bool $strict = false) : string
+	{
+		$attributes += $this->attributes;
+
+		return path_build($this->path, $attributes, $strict);
+	}
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public function buildRegex() : string
+	{
+		return path_regex($this->path);
+	}
 }

src/Exception/MethodNotAllowedException.php

Indentation +31 added lines, -31 removed lines

@@ -23,35 +23,35 @@
 class MethodNotAllowedException extends RuntimeException implements ExceptionInterface
 {
 
-    /**
-     * Allowed HTTP methods
-     *
-     * @var string[]
-     */
-    private $allowedMethods;
-
-    /**
-     * Constructor of the class
-     *
-     * @param string[]  $allowedMethods
-     * @param string    $message
-     * @param int       $code
-     * @param Throwable $previous
-     */
-    public function __construct(array $allowedMethods, string $message = '', int $code = 0, Throwable $previous = null)
-    {
-        $this->allowedMethods = $allowedMethods;
-
-        parent::__construct($message, $code, $previous);
-    }
-
-    /**
-     * Gets allowed HTTP methods
-     *
-     * @return string[]
-     */
-    public function getAllowedMethods() : array
-    {
-        return $this->allowedMethods;
-    }
+	/**
+	 * Allowed HTTP methods
+	 *
+	 * @var string[]
+	 */
+	private $allowedMethods;
+
+	/**
+	 * Constructor of the class
+	 *
+	 * @param string[]  $allowedMethods
+	 * @param string    $message
+	 * @param int       $code
+	 * @param Throwable $previous
+	 */
+	public function __construct(array $allowedMethods, string $message = '', int $code = 0, Throwable $previous = null)
+	{
+		$this->allowedMethods = $allowedMethods;
+
+		parent::__construct($message, $code, $previous);
+	}
+
+	/**
+	 * Gets allowed HTTP methods
+	 *
+	 * @return string[]
+	 */
+	public function getAllowedMethods() : array
+	{
+		return $this->allowedMethods;
+	}
 }

src/RouteCollectionInterface.php

Indentation +201 added lines, -201 removed lines

@@ -23,205 +23,205 @@
 interface RouteCollectionInterface
 {
 
-    /**
-     * Gets the collection prefix
-     *
-     * @return null|string
-     */
-    public function getPrefix() : ?string;
-
-    /**
-     * Gets the collection middlewares
-     *
-     * @return MiddlewareInterface[]
-     */
-    public function getMiddlewares() : array;
-
-    /**
-     * Gets the collection routes
-     *
-     * @return RouteInterface[]
-     */
-    public function getRoutes() : array;
-
-    /**
-     * Sets the given prefix to the collection
-     *
-     * @param string $prefix
-     *
-     * @return RouteCollectionInterface
-     */
-    public function setPrefix(string $prefix) : RouteCollectionInterface;
-
-    /**
-     * Adds the given middleware(s) to the collection
-     *
-     * @param MiddlewareInterface ...$middlewares
-     *
-     * @return RouteCollectionInterface
-     */
-    public function addMiddlewares(MiddlewareInterface ...$middlewares) : RouteCollectionInterface;
-
-    /**
-     * Adds the given route(s) to the collection
-     *
-     * @param RouteInterface ...$routes
-     *
-     * @return RouteCollectionInterface
-     */
-    public function addRoutes(RouteInterface ...$routes) : RouteCollectionInterface;
-
-    /**
-     * Makes a new route from the given parameters
-     *
-     * @param string $name
-     * @param string $path
-     * @param string[] $methods
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function route(
-        string $name,
-        string $path,
-        array $methods,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to HEAD requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function head(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to GET requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function get(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to POST requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function post(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to PUT requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function put(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to PATCH requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function patch(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to DELETE requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function delete(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
-
-    /**
-     * Makes a new route that will respond to PURGE requests
-     *
-     * @param string $name
-     * @param string $path
-     * @param RequestHandlerInterface $requestHandler
-     * @param MiddlewareInterface[] $middlewares
-     * @param array $attributes
-     *
-     * @return RouteInterface
-     */
-    public function purge(
-        string $name,
-        string $path,
-        RequestHandlerInterface $requestHandler,
-        array $middlewares,
-        array $attributes
-    ) : RouteInterface;
+	/**
+	 * Gets the collection prefix
+	 *
+	 * @return null|string
+	 */
+	public function getPrefix() : ?string;
+
+	/**
+	 * Gets the collection middlewares
+	 *
+	 * @return MiddlewareInterface[]
+	 */
+	public function getMiddlewares() : array;
+
+	/**
+	 * Gets the collection routes
+	 *
+	 * @return RouteInterface[]
+	 */
+	public function getRoutes() : array;
+
+	/**
+	 * Sets the given prefix to the collection
+	 *
+	 * @param string $prefix
+	 *
+	 * @return RouteCollectionInterface
+	 */
+	public function setPrefix(string $prefix) : RouteCollectionInterface;
+
+	/**
+	 * Adds the given middleware(s) to the collection
+	 *
+	 * @param MiddlewareInterface ...$middlewares
+	 *
+	 * @return RouteCollectionInterface
+	 */
+	public function addMiddlewares(MiddlewareInterface ...$middlewares) : RouteCollectionInterface;
+
+	/**
+	 * Adds the given route(s) to the collection
+	 *
+	 * @param RouteInterface ...$routes
+	 *
+	 * @return RouteCollectionInterface
+	 */
+	public function addRoutes(RouteInterface ...$routes) : RouteCollectionInterface;
+
+	/**
+	 * Makes a new route from the given parameters
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param string[] $methods
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function route(
+		string $name,
+		string $path,
+		array $methods,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to HEAD requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function head(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to GET requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function get(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to POST requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function post(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to PUT requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function put(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to PATCH requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function patch(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to DELETE requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function delete(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
+
+	/**
+	 * Makes a new route that will respond to PURGE requests
+	 *
+	 * @param string $name
+	 * @param string $path
+	 * @param RequestHandlerInterface $requestHandler
+	 * @param MiddlewareInterface[] $middlewares
+	 * @param array $attributes
+	 *
+	 * @return RouteInterface
+	 */
+	public function purge(
+		string $name,
+		string $path,
+		RequestHandlerInterface $requestHandler,
+		array $middlewares,
+		array $attributes
+	) : RouteInterface;
 }