Wandu\Router\RouteCollection

Complexity

Total Complexity

35

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

87.13%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	toArray()	0	4	1
A	prefix()	0	4	1
A	domain()	0	4	1
A	middleware()	0	4	1
B	group()	0	24	6
A	append()	0	4	1
A	resource()	0	10	1
A	get()	0	4	1
A	post()	0	4	1
A	put()	0	4	1
A	delete()	0	4	1
A	options()	0	4	1
A	patch()	0	4	1
A	any()	0	12	1
A	createRoute()	0	11	2
A	getIterator()	0	11	4
A	dispatch()	0	4	1
C	compile()	0	43	8

<?php
namespace Wandu\Router;

use FastRoute\DataGenerator\GroupCountBased as GCBGenerator;
use IteratorAggregate;
use Psr\Http\Message\ServerRequestInterface;
use Wandu\Router\Contracts\Dispatchable;
use Wandu\Router\Contracts\LoaderInterface;
use Wandu\Router\Contracts\ResponsifierInterface;
use Wandu\Router\Contracts\Routable;
use Wandu\Router\Contracts\RouteFluent;
use Wandu\Router\Path\Pattern;

class RouteCollection implements Routable, IteratorAggregate, Dispatchable
{
    /** @var \Wandu\Router\RouteCollection[] */
    protected $routers = [];

    /** @var \Wandu\Router\Route[] */
    protected $routes = [];

    /** @var array */
    protected $status;

    /**
     * @param string $prefix
     * @param array $middlewares
     * @param array $domains
     */
    public function __construct($prefix = '', $middlewares = [], $domains = [])
    {
        $this->status = [
            'prefix' => $prefix,
            'middlewares' => $middlewares,
            'domains' => $domains,
        ];
    }

    /**
     * @return array
     */
    public function toArray()
    {
        return iterator_to_array($this->getIterator());
    }
    
    /**
     * {@inheritdoc}
     */
    public function prefix(string $prefix, callable $handler)
    {
        $this->group(['prefix' => $prefix, ], $handler);
    }

    /**
     * {@inheritdoc}
     */
    public function domain($domain, callable $handler)
    {
        $this->group(['domain' => $domain, ], $handler);
    }

    /**
     * {@inheritdoc}
     */
    public function middleware($middleware, callable $handler)
    {
        $this->group(['middleware' => $middleware, ], $handler);
    }

    /**
     * {@inheritdoc}
     */
    public function group(array $attributes, callable $handler)
    {
        $prefix = '';
        if (isset($attributes['prefix'])) {
            $prefix = "{$this->status['prefix']}/" . $attributes['prefix'];
        }
        $middlewares = $this->status['middlewares'];
        if (isset($attributes['middleware'])) {
            $middlewares = array_merge($middlewares, array_filter((array)$attributes['middleware']));
        }
        if (isset($attributes['middlewares'])) {
            $middlewares = array_merge($middlewares, array_filter((array)$attributes['middlewares']));
        }
        $domains = [];
        if (isset($attributes['domain'])) {
            $domains = (array) $attributes['domain'];
        }
        if (isset($attributes['domains'])) {
            $domains = (array) $attributes['domains'];
        }
        $router = new RouteCollection($prefix, $middlewares, $domains);
        call_user_func($handler, $router);
        $this->routers[] = $router;
    }

    /**
     * {@inheritdoc}
     */
    public function append(callable $handler)
    {
        call_user_func($handler, $this);
    }

    public function resource($className, $except = [], $only = [])

The parameter $except is not used and could be removed.

The parameter $only is not used and could be removed.

    {
        $this->get('', $className, 'index');
        $this->post('', $className, 'store');
        $this->get(':id', $className, 'show');
        $this->put(':id', $className, 'update');
        $this->patch(':id', $className, 'patch');
        $this->delete(':id', $className, 'destroy');
        // $this->options();

72% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * {@inheritdoc}
     */
    public function get(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['GET', 'HEAD'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function post(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['POST'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function put(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['PUT'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function delete(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['DELETE'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function options(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['OPTIONS'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function patch(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute(['PATCH'], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function any(string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        return $this->createRoute([
            'GET',
            'HEAD',
            'POST',
            'PUT',
            'DELETE',
            'OPTIONS',
            'PATCH'
        ], $path, $className, $methodName);
    }

    /**
     * {@inheritdoc}
     */
    public function createRoute(array $methods, string $path, string $className, string $methodName = 'index'): RouteFluent
    {
        $path = trim("{$this->status['prefix']}/{$path}", '/');
        while(strpos($path, '//') !== false) {
            $path = str_replace('//', '/', $path);
        }
        $path = '/' . $path;
        $route = new Route($className, $methodName, $this->status['middlewares'], $this->status['domains']);
        $this->routes[] = [$methods, $path, $route];
        return $route;
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        foreach ($this->routes as $route) {
            yield $route;
        }
        foreach ($this->routers as $router) {
            foreach ($router as $route) {
                yield $route;
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function dispatch(LoaderInterface $loader, ResponsifierInterface $responsifier, ServerRequestInterface $request)
    {
        return $this->compile()->dispatch($loader, $responsifier, $request);
    }

    /**
     * @return \Wandu\Router\CompiledRouteCollection
     */
    public function compile(): CompiledRouteCollection
    {
        $routeMap = [];

        /** @var \FastRoute\DataGenerator\GroupCountBased[] $generators */
        $generators = [];

        /**
         * @var array|string[] $methods
         * @var string $path
         * @var \Wandu\Router\Route $route
         */
        foreach ($this->getIterator() as list($methods, $path, $route)) {
            $pathPattern = new Pattern($path);

            $handleId = uniqid('HANDLER');
            $routeMap[$handleId] = $route;

            foreach ($pathPattern->parse() as $parsedPath) {
                foreach ($methods as $method) {
                    $domains = $route->getDomains();
                    if (count($domains)) {
                        foreach ($domains as $domain) {
                            if (!isset($generators[$domain])) {
                                $generators[$domain] = new GCBGenerator();
                            }
                            $generators[$domain]->addRoute($method, $parsedPath, $handleId);
                        }
                    } else {
                        if (!isset($generators['@'])) {
                            $generators['@'] = new GCBGenerator();
                        }
                        $generators['@']->addRoute($method, $parsedPath, $handleId);
                    }
                }
            }
        }

        $compiledRoutes = array_map(function (GCBGenerator $generator) {
            return $generator->getData();
        }, $generators);
        return new CompiledRouteCollection($compiledRoutes, $routeMap);
    }
}