mvc5 / mvc5

src/Url/Route/Generator.php

<?php
/**
 *
 */

namespace Mvc5\Url\Route;

use Closure;
use Mvc5\Http\HttpUri;
use Mvc5\Http\Uri;
use Mvc5\Route\Config;
use Mvc5\Route\Definition\Build;
use Mvc5\Route\Definition\Compiler;
use Mvc5\Route\Route;
use Throwable;

use function array_shift;
use function explode;
use function is_array;

use const Mvc5\{ DEFAULTS, HOST, PATH, PORT, SCHEME, SEPARATOR, TOKENS };

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

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

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

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

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

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

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

trait Generator
{
    /**
     *
     */
    use Build;

    /**
     * @var array
     */
    protected array $generated = [];

    /**
     * @var Route
     */
    protected Route $route;

    /**
     * @var Uri
     */
    protected Uri $uri;

    /**
     * @param array|Route $route
     * @param Uri|null $uri
     */
    function __construct($route, Uri $uri = null)
    {
        $this->route = is_array($route) ? new Config($route) : $route;
        $this->uri = $uri ?? new HttpUri;
    }

    /**
     * @param Route $parent
     * @param array|Route $route
     * @return Route|null
     * @throws Throwable
     */
    protected function child(Route $parent, $route) : ?Route
    {
        return $route ? $this->merge($parent, $this->route($route)) : null;
    }

    /**
     * @param string $name
     * @return array|Route|null
     */
    protected function config(string $name)
    {
        return $this->route[$name] ?? null;
    }

    /**
     * @param string $name
     * @return Route|null
     * @throws Throwable
     */
    protected function construct(string $name) : ?Route
    {
        return $this->generated[$name] ?? $this->generated[$name] = $this->generate(explode(SEPARATOR, $name));
    }

    /**
     * @param array $name
     * @param array $path
     * @param Route|null $parent
     * @return Route|null
     * @throws Throwable
     */
    protected function generate(array $name, array $path = [], Route $parent = null) : ?Route
    {
        return $this->resolve($this->match(array_shift($name), $parent), $name, $path);
    }

    /**
     * @param array|string|null $host
     * @param array $params
     * @return string|null
     * @throws Throwable
     */
    protected function hostname($host, array &$params) : ?string
    {
        return !is_array($host) ? $host : Compiler::compile($host[TOKENS], $params, $host[DEFAULTS] ?? []);
    }

    /**
     * @param string $name
     * @param Route|null $parent
     * @return Route|null
     * @throws Throwable
     */
    protected function match(string $name, Route $parent = null) : ?Route
    {
        return $parent ? $this->child($parent, $parent->child($name)) : $this->route($this->config($name));
    }

    /**
     * @param Route $parent
     * @param Route $child
     * @param array $config
     * @return Route
     */
    protected function merge(Route $parent, Route $child, array $config = []) : Route
    {
        !$child->scheme()
            && $config[SCHEME] = $parent->scheme();

        !$child->host()
            && $config[HOST] = $parent->host();

        !$child->port()

The expression $child->port() of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

            && $config[PORT] = $parent->port();

        return $config ? $child->with($config) : $child;

The expression return $config ? $child->with($config) : $child could return the type Mvc5\Config\Model which includes types incompatible with the type-hinted return Mvc5\Route\Route. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param Route $route
     * @param array $name
     * @param array $path
     * @return Route|null
     * @throws Throwable
     */
    protected function next(Route $route, array $name, array $path) : ?Route
    {
        return $name ? $this->generate($name, $path, $route) : $route->with(PATH, $path);

The expression return $name ? $this->generate($name, $path, $route) : $route->with(Mvc5\PATH, $path) could return the type Mvc5\Config\Model which includes types incompatible with the type-hinted return Mvc5\Route\Route|null. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param Route $route
     * @param array $params
     * @param array $options
     * @return array
     * @throws Throwable
     */
    protected function options(Route $route, array $params, array $options) : array
    {
        $options[SCHEME] ??= $route->scheme();
        $options[HOST] ??= $this->hostname($route->host(), $params);
        $options[PORT] ??= $route->port();

        $options[PATH] = $this->path($route->path(), $params);

It seems like $route->path() can also be of type null and string; however, parameter $segment of Mvc5\Url\Route\Generator::path() does only seem to accept array, maybe add an additional type check?

        return $options;
    }

    /**
     * @param array $segment
     * @param array $params
     * @param string $path
     * @return string
     * @throws Throwable
     */
    protected function path(array $segment, array $params, string $path = '') : string
    {
        /** @var Route $route */
        foreach($segment as $route) {
            $path .= Compiler::compile($route->tokens(), $params, $route->defaults(), $this->wildcard($route));
        }

        return $path;
    }

    /**
     * @param array|Route $route
     * @param array $name
     * @param array $path
     * @return Route|null
     * @throws Throwable
     */
    protected function resolve($route, array $name, array $path) : ?Route
    {
        return $route ? $this->next($route, $name, [...$path, $route]) : null;

It seems like $route can also be of type array; however, parameter $route of Mvc5\Url\Route\Generator::next() does only seem to accept Mvc5\Route\Route, maybe add an additional type check?

    }

    /**
     * @param array|Route $route
     * @return Route|null
     * @throws Throwable
     */
    protected function route($route) : ?Route
    {
        return !$route || $route instanceof Route ? $route : $this->build($route, false);

The expression return ! $route || $route instanceof Mvc5\Route\Route ? $route : $this->build($route, false) could return the type array which is incompatible with the type-hinted return Mvc5\Route\Route|null. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param Route|null $route
     * @param array $params
     * @param array $options
     * @return Uri|null
     * @throws Throwable
     */
    protected function uri(Route $route = null, array $params = [], array $options = []) : ?Uri
    {
        return $route ? $this->uri->with($this->options($route, $params, $options)) : null;

The expression return $route ? $this->uri->with($this->options($route, $params, $options)) : null could return the type Mvc5\Config\Model which includes types incompatible with the type-hinted return Mvc5\Http\Uri|null. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param Route $route
     * @return Closure|null
     */
    protected function wildcard(Route $route) : ?Closure
    {
        return !$route->wildcard() ? null : function(string $path, array $params = []) {
            foreach($params as $key => $value) {
                null !== $value && $path .= SEPARATOR . $key . SEPARATOR . $value;
            }

            return $path;
        };
    }

    /**
     * @param string $name
     * @param array $params
     * @param array $options
     * @return Uri|null
     * @throws Throwable
     */
    function __invoke(string $name, array $params = [], array $options = []) : ?Uri
    {
        return $this->uri($this->construct($name), $params, $options);
    }
}