Micro\Plugin\Http\Business\Route\RouteBuilder

Complexity

Total Complexity

25

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Test Coverage

Coverage

98.21%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setController()	0	5	1
A	setUri()	0	5	1
A	setMethods()	0	9	2
A	addMethod()	0	7	2
A	__construct()	0	13	1
C	build()	0	67	16
A	clear()	0	6	1
A	setName()	0	5	1

<?php

declare(strict_types=1);

/*
 *  This file is part of the Micro framework package.
 *
 *  (c) Stanislau Komar <kost@micro-php.net>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Micro\Plugin\Http\Business\Route;

use Micro\Plugin\Http\Exception\RouteInvalidConfigurationException;
use Symfony\Component\HttpFoundation\Request;

/**
 * @author Stanislau Komar <kost@micro-php.net>
 */
class RouteBuilder implements RouteBuilderInterface
{
    private string|null $name;

    /**
     * @var array<class-string, string|null>|class-string|\Closure|null

The doc comment array<class-string, string|null>|class-string|\Closure|null at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string, string|null>|class-string|\Closure|null.

     */
    private mixed $action;

    private string|null $uri;

    /**
     * @var array|string[]
     */
    private array $methods;

    /**
     * @param string[] $methodsByDefault
     */
    public function __construct(
        private readonly array $methodsByDefault = [
            Request::METHOD_GET,
            Request::METHOD_POST,
            Request::METHOD_PUT,
            Request::METHOD_PATCH,
            Request::METHOD_DELETE,
        ],
    ) {
        $this->name = null;
        $this->action = null;
        $this->uri = null;
        $this->methods = $this->methodsByDefault;
    }

    /**
     * {@inheritDoc}
     */
    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function addMethod(string $method): self
    {
        if (!\in_array($method, $this->methods)) {
            $this->methods[] = mb_strtoupper($method);
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function setMethods(array $methods): self
    {
        $this->methods = [];

        foreach ($methods as $method) {
            $this->addMethod($method);
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function setController(string|array|\Closure $action): self
    {
        $this->action = $action;

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function setUri(string $uri): self
    {
        $this->uri = $uri;

        return $this;
    }

    /**
     * TODO: Move pattern builder to separate class.
     *
     * {@inheritDoc}
     */
    public function build(): RouteInterface
    {
        $exceptions = [];

        if (!$this->uri) {
            $exceptions[] = 'Uri can not be empty.';
        }

        if ($this->name && !preg_match('/^([a-zA-Z_][a-zA-Z0-9_]*)$/', $this->name)) {
            $exceptions[] = 'The route name must match "[a-zA-Z][a-zA-Z0-9_]*".';
        }

        if (!$this->action) {
            $exceptions[] = 'The route action can not be empty.';
        }

        if (
            $this->action &&
            (
                !\is_callable($this->action) &&
                (\is_string($this->action) && (class_exists($this->action) && !$this->name))
            )
        ) {
            $exceptions[] = 'The route action should be callable. Examples: `[object, "method|<route_name>"], [Classname, "metnod|<routeName>"], Classname::method, Classname, function() {}` Current value: '.$this->action;
        }

        if (!\count($this->methods)) {
            $exceptions[] = 'The route should support at least one HTTP method.';
        }

        if (\count($exceptions)) {
            $exception = new RouteInvalidConfigurationException($this->name ?: $this->uri ?: 'Undefined', $exceptions);

            $this->clear();

            throw $exception;
        }

        $pattern = null;
        $parameters = null;
        /** @psalm-suppress PossiblyNullArgument */
        $isDynamic = preg_match_all('/\{\s*([^}\s]*)\s*}/', $this->uri, $matches);
        if ($isDynamic) {

The expression $isDynamic of type integer|null is loosely compared to true; this is ambiguous if the integer can be 0. You might want to explicitly use !== null instead.

            $parameters = $matches[1];
            /** @psalm-suppress PossiblyNullArgument */
            $pattern = '/'.addcslashes($this->uri, '/.').'$/';

It seems like $this->uri can also be of type null; however, parameter $string of addcslashes() does only seem to accept string, maybe add an additional type check?

            foreach ($matches[0] as $replaced) {
                $pattern = str_replace($replaced, '([a-zA-Z_][a-zA-Z0-9_]*)', $pattern);
            }
        }
        /**
         * @psalm-suppress PossiblyNullArgument
         * @psalm-suppress MixedArgumentTypeCoercion
         */
        $route = new Route(
            $this->uri,
            $this->action,
            $this->methods,
            $this->name,
            $pattern,
            $parameters
        );

        $this->clear();

        return $route;
    }

    protected function clear(): void
    {
        $this->uri = null;
        $this->action = null;
        $this->methods = $this->methodsByDefault;
        $this->name = null;
    }
}