Sunrise\Http\Router\RouteCollection

Complexity

Total Complexity

17

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	patch()	0	14	1
A	addRoutes()	0	7	2
A	addMiddlewares()	0	7	2
A	delete()	0	14	1
A	setPrefix()	0	8	1
A	post()	0	14	1
A	head()	0	14	1
A	put()	0	14	1
A	route()	0	27	1
A	getRoutes()	0	3	1
A	getPrefix()	0	3	1
A	get()	0	14	1
A	getMiddlewares()	0	3	1
A	purge()	0	14	1
A	group()	0	8	1

<?php declare(strict_types=1);

/**
 * It's free open-source software released under the MIT License.
 *
 * @author Anatoly Fenric <anatoly@fenric.ru>
 * @copyright Copyright (c) 2018, Anatoly Fenric
 * @license https://github.com/sunrise-php/http-router/blob/master/LICENSE
 * @link https://github.com/sunrise-php/http-router
 */

namespace Sunrise\Http\Router;

/**
 * Import classes
 */
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

/**
 * Import functions
 */
use function array_merge;
use function rtrim;

/**
 * RouteCollection
 */
class RouteCollection implements RouteCollectionInterface
{

    /**
     * The collection prefix
     *
     * @var null|string
     */
    private $prefix;

    /**
     * The collection middlewares
     *
     * @var MiddlewareInterface[]
     */
    private $middlewares = [];

    /**
     * The collection routes
     *
     * @var RouteInterface[]
     */
    private $routes = [];

    /**
     * {@inheritDoc}
     */
    public function getPrefix() : ?string
    {
        return $this->prefix;
    }

    /**
     * {@inheritDoc}
     */
    public function getMiddlewares() : array
    {
        return $this->middlewares;
    }

    /**
     * {@inheritDoc}
     */
    public function getRoutes() : array
    {
        return $this->routes;
    }

    /**
     * {@inheritDoc}
     */
    public function setPrefix(string $prefix) : RouteCollectionInterface
    {
        // https://github.com/sunrise-php/http-router/issues/26
        $prefix = rtrim($prefix, '/');

        $this->prefix = $prefix;

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function addMiddlewares(MiddlewareInterface ...$middlewares) : RouteCollectionInterface
    {
        foreach ($middlewares as $middleware) {
            $this->middlewares[] = $middleware;
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function addRoutes(RouteInterface ...$routes) : RouteCollectionInterface
    {
        foreach ($routes as $route) {
            $this->routes[] = $route;
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     *
     * @todo Maybe create a route factory?
     */
    public function route(
        string $name,
        string $path,
        array $methods,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        $path = $this->prefix . $path;

        $middlewares = array_merge(
            $this->middlewares,
            $middlewares
        );

        $route = new Route(
            $name,
            $path,
            $methods,
            $requestHandler,
            $middlewares,
            $attributes
        );

        $this->addRoutes($route);

        return $route;
    }

    /**
     * {@inheritDoc}
     */
    public function head(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['HEAD'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function get(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['GET'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function post(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['POST'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function put(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['PUT'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function patch(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['PATCH'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function delete(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['DELETE'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function purge(
        string $name,
        string $path,
        RequestHandlerInterface $requestHandler,
        array $middlewares = [],
        array $attributes = []
    ) : RouteInterface {
        return $this->route(
            $name,
            $path,
            ['PURGE'],
            $requestHandler,
            $middlewares,
            $attributes
        );
    }

    /**
     * {@inheritDoc}
     */
    public function group(string $prefix, callable $callback) : void
    {
        $children = new self;
        $children->setPrefix($this->prefix . $prefix);

        $callback($children);

        $this->addRoutes(...$children->getRoutes());
    }
}