SimpleRoute\Router

Complexity

Total Complexity

7

Size/Duplication

Total Lines	55
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

92.31%

Importance

Changes	2
Bugs	1	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	match()	0	13	4
A	__construct()	0	22	3

<?php

namespace SimpleRoute;

use FastRoute;
use FastRoute\Dispatcher;
use FastRoute\RouteCollector;
use SimpleRoute\Exception\MethodNotAllowedException;
use SimpleRoute\Exception\NotFoundException;

final class Router implements RouterInterface
{
    /**
     * @var Dispatcher
     */
    private $dispatcher;

    /**
     * @var RouteInterface[]
     */
    private $routes;

    /**
     * @param RouteInterface[] A collection of routes
     */
    public function __construct(array $routes)
    {
        $this->routes = array();

        $this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $collector) use ($routes) {
            foreach ($routes as $route) {
                if (!$route instanceof RouteInterface) {
                    throw new \InvalidArgumentException('Routes array must contain only RouteInterface objects');
                }

                $key = spl_object_hash($route);

                $this->routes[$key] = $route;

                $collector->addRoute(
                    $route->getMethods(),
                    $route->getPattern(),
                    $key
                );
            }
        });
    }

    /**
     * {@inheritdoc}
     */
    public function match($method, $uri)
    {
        $result = $this->dispatcher->dispatch($method, $uri);

        switch ($result[0]) {
            case Dispatcher::FOUND:
                return new Result($this->routes[$result[1]], $result[2]); 
            case Dispatcher::METHOD_NOT_ALLOWED:
                throw new MethodNotAllowedException($method, $result[1]);
            case Dispatcher::NOT_FOUND:
                throw new NotFoundException($uri);
        }
    }
}