Valkyrja\Http\Routing\Collection\Collection

Complexity

Total Complexity

40

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	setFromData()	0	6	1
A	hasStatic()	0	4	1
A	hasNamed()	0	4	1
A	allDynamic()	0	4	1
A	getData()	0	12	2
A	get()	0	5	1
A	getStatic()	0	4	1
A	allFlattened()	0	4	1
A	getDynamic()	0	4	1
A	has()	0	5	2
A	hasDynamic()	0	4	1
A	getByName()	0	10	2
A	allStatic()	0	4	1
A	all()	0	4	1
A	add()	0	7	1
A	ensureRoutes()	0	5	1
A	ensureMethodRoutes()	0	5	1
A	allOfType()	0	7	2
A	setRouteToRequestMethod()	0	13	2
A	hasAnyOfType()	0	9	3
A	ensureRoute()	0	17	5
A	setRouteToRequestMethods()	0	4	2
A	hasOfType()	0	7	2
A	getOfType()	0	13	3
A	getAnyOfType()	0	8	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <melechmizrachi@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Http\Routing\Collection;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Http\Message\Enum\RequestMethod;

The type Valkyrja\Http\Message\Enum\RequestMethod was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Http\Routing\Collection\Contract\CollectionContract;
use Valkyrja\Http\Routing\Data\Contract\RouteContract;
use Valkyrja\Http\Routing\Data\Data;
use Valkyrja\Http\Routing\Throwable\Exception\InvalidArgumentException;

use function array_map;
use function is_string;

/**
 * @phpstan-import-type RequestMethodList from CollectionContract
 * @phpstan-import-type RequestMethodRouteList from CollectionContract
 *
 * @psalm-import-type RequestMethodList from CollectionContract
 * @psalm-import-type RequestMethodRouteList from CollectionContract
 */
class Collection implements CollectionContract
{
    /**
     * The routes.
     *
     * @var array<string, RouteContract|string>
     */
    protected array $routes = [];

    /**
     * The static routes.
     *
     * @var RequestMethodList

The type Valkyrja\Http\Routing\Collection\RequestMethodList was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected array $static = [];

    /**
     * The dynamic routes.
     *
     * @var RequestMethodList
     */
    protected array $dynamic = [];

    /**
     * @inheritDoc
     */
    #[Override]
    public function getData(): Data
    {
        return new Data(
            routes: array_map(
                static fn (RouteContract|string $route): string => ! is_string($route)
                    ? serialize($route)
                    : $route,
                $this->routes
            ),
            static: $this->static,
            dynamic: $this->dynamic,
        );
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function setFromData(Data $data): void
    {
        $this->routes  = $data->routes;
        $this->static  = $data->static;

It seems like $data->static of type array is incompatible with the declared type Valkyrja\Http\Routing\Collection\RequestMethodList of property $static.

It seems like $data->static of type array is incompatible with the declared type Valkyrja\Http\Routing\Data\RequestArray of property $static.

        $this->dynamic = $data->dynamic;

It seems like $data->dynamic of type array is incompatible with the declared type Valkyrja\Http\Routing\Collection\RequestMethodList of property $dynamic.

It seems like $data->dynamic of type array is incompatible with the declared type Valkyrja\Http\Routing\Data\RequestArray of property $dynamic.

    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function add(RouteContract $route): void
    {
        // Set the route to its request methods
        $this->setRouteToRequestMethods($route);

        $this->routes[$route->getName()] = $route;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function get(string $path, RequestMethod|null $method = null): RouteContract|null
    {
        return $this->getStatic($path, $method)
            ?? $this->getDynamic($path, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function has(string $path, RequestMethod|null $method = null): bool
    {
        return $this->hasStatic($path, $method)
            || $this->hasDynamic($path, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function all(): array
    {
        return $this->ensureMethodRoutes(array_merge_recursive($this->static, $this->dynamic));
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function allFlattened(): array
    {
        return $this->ensureRoutes($this->routes);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getStatic(string $path, RequestMethod|null $method = null): RouteContract|null
    {
        return $this->getOfType($this->static, $path, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasStatic(string $path, RequestMethod|null $method = null): bool
    {
        return $this->hasOfType($this->static, $path, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function allStatic(RequestMethod|null $method = null): array
    {
        return $this->allOfType($this->static, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getDynamic(string $regex, RequestMethod|null $method = null): RouteContract|null
    {
        return $this->getOfType($this->dynamic, $regex, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasDynamic(string $regex, RequestMethod|null $method = null): bool
    {
        return $this->hasOfType($this->dynamic, $regex, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function allDynamic(RequestMethod|null $method = null): array
    {
        return $this->allOfType($this->dynamic, $method);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getByName(string $name): RouteContract|null
    {
        $named = $this->routes[$name] ?? null;

        if ($named === null) {
            return null;
        }

        return $this->ensureRoute($named);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasNamed(string $name): bool
    {
        return isset($this->routes[$name]);
    }

    /**
     * Set a route to its request methods.
     *
     * @param RouteContract $route The route
     */
    protected function setRouteToRequestMethods(RouteContract $route): void
    {
        foreach ($route->getRequestMethods() as $requestMethod) {
            $this->setRouteToRequestMethod($route, $requestMethod);
        }
    }

    /**
     * Set the route to the request method.
     *
     * @param RouteContract $route         The route
     * @param RequestMethod $requestMethod The request method
     */
    protected function setRouteToRequestMethod(RouteContract $route, RequestMethod $requestMethod): void
    {
        $name  = $route->getName();
        $regex = $route->getRegex();

        // If this is a dynamic route
        if ($regex !== null) {
            // Set the route in the dynamic routes list
            $this->dynamic[$requestMethod->value][$regex] = $name;
        } else {
            // Otherwise set it in the static routes array
            // Set the route in the static routes list
            $this->static[$requestMethod->value][$route->getPath()] = $name;
        }
    }

    /**
     * Get a route of type (static|dynamic).
     *
     * @param RequestMethodList  $type   The type [static|dynamic]
     * @param string             $path   The path
     * @param RequestMethod|null $method [optional] The request method
     */
    protected function getOfType(array $type, string $path, RequestMethod|null $method = null): RouteContract|null
    {
        if ($method === null) {
            return $this->getAnyOfType($type, $path);
        }

        $route = $type[$method->value][$path] ?? null;

        if ($route === null) {
            return null;
        }

        return $this->ensureRoute($route);
    }

    /**
     * Get a route of any type (static|dynamic).
     *
     * @param RequestMethodList $type The type [static|dynamic]
     * @param string            $path The path
     */
    protected function getAnyOfType(array $type, string $path): RouteContract|null
    {
        return $this->getOfType($type, $path, RequestMethod::GET)
            ?? $this->getOfType($type, $path, RequestMethod::HEAD)
            ?? $this->getOfType($type, $path, RequestMethod::POST)
            ?? $this->getOfType($type, $path, RequestMethod::PUT)
            ?? $this->getOfType($type, $path, RequestMethod::PATCH)
            ?? $this->getOfType($type, $path, RequestMethod::DELETE);
    }

    /**
     * Has a path of type (static|dynamic).
     *
     * @param RequestMethodList  $type   The type [static|dynamic]
     * @param string             $path   The path
     * @param RequestMethod|null $method [optional] The request method
     */
    protected function hasOfType(array $type, string $path, RequestMethod|null $method = null): bool
    {
        if ($method === null) {
            return $this->hasAnyOfType($type, $path);
        }

        return isset($type[$method->value][$path]);
    }

    /**
     * Has a path of any type.
     *
     * @param RequestMethodList $type The type [static|dynamic]
     * @param string            $path The path
     */
    protected function hasAnyOfType(array $type, string $path): bool
    {
        foreach ($type as $requestMethod) {
            if (isset($requestMethod[$path])) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get all of type with optional by request method.
     *
     * @param RequestMethodList  $type   The type [static|dynamic]
     * @param RequestMethod|null $method [optional] The request method
     *
     * @return RequestMethodRouteList|array<string, RouteContract>

The type Valkyrja\Http\Routing\Collection\RequestMethodRouteList was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected function allOfType(array $type, RequestMethod|null $method = null): array
    {
        if ($method === null) {
            return $this->ensureMethodRoutes($type);
        }

        return $this->ensureRoutes($type[$method->value] ?? []);
    }

    /**
     * Ensure request methods are arrays of routes.
     *
     * @param RequestMethodList $methodsArray
     *
     * @return RequestMethodRouteList
     */
    protected function ensureMethodRoutes(array $methodsArray): array
    {
        return array_map(
            [$this, 'ensureRoutes'],
            $methodsArray
        );
    }

    /**
     * Ensure an array is an array of routes.
     *
     * @param array<string, string|RouteContract> $routesArray The routes array
     *
     * @return array<string, RouteContract>
     */
    protected function ensureRoutes(array $routesArray): array
    {
        return array_map(
            [$this, 'ensureRoute'],
            $routesArray
        );
    }

    /**
     * Ensure a route, or null, is returned.
     *
     * @param RouteContract|string $route The route
     */
    protected function ensureRoute(RouteContract|string $route): RouteContract
    {
        if (is_string($route) && isset($this->routes[$route])) {
            $route = $this->routes[$route];
        }

        if (is_string($route)) {
            $unserializedRoute = unserialize($route, ['allowed_classes' => true]);

            if (! $unserializedRoute instanceof RouteContract) {
                throw new InvalidArgumentException('Invalid object serialized.');
            }

            return $unserializedRoute;
        }

        return $route;
    }
}