Mezon\Router\UrlParser

Complexity

Total Complexity

16

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Importance

Changes	6
Bugs	1	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	_getRouteMatcherRegExPattern()	0	19	3
A	getDynamicRouteProcessor()	0	28	5
A	_getParameterNames()	0	26	4
A	warmCache()	0	15	4

<?php
declare(strict_types = 1);
namespace Mezon\Router;

use Mezon\Router\Types\BaseType;

/**
 * Trait UrlParser
 *
 * @package Router
 * @author Dodonov A.A.
 * @version v.1.0 (2021/09/27)
 * @copyright Copyright (c) 2021, aeon.org
 */
trait UrlParser
{

    use UrlParserBase;

    /**
     * Called route
     *
     * @var string
     */
    protected $calledRoute = '';

    /**
     * Cache for regular expressions
     *
     * @var string[]
     */
    private $cachedRegExps = [];

    /**
     * Cached parameters for route
     *
     * @var array<string, string[]>
     */
    private $cachedParameters = [];

    /**
     * Method compiles route pattern string in regex string.
     * For example [i:id]/some-str in ([\[0-9\]])/some-str
     *
     * @param string $routerPattern
     *            router pattern
     * @return string regexp pattern
     * @psalm-suppress MixedMethodCall
     */
    private function _getRouteMatcherRegExPattern(string $routerPattern): string
    {
        $key = $routerPattern;

        // try read from cache
        if (isset($this->cachedRegExps[$key])) {
            return $this->cachedRegExps[$key];
        }

        // parsing routes
        $compiledRouterPattern = $routerPattern;
        foreach ($this->types as $typeClass) {
            $compiledRouterPattern = preg_replace('/' . $typeClass::searchRegExp() . '/', '(' . $typeClass::parserRegExp() . ')', $compiledRouterPattern);
        }

        // final setup + save in cache
        $this->cachedRegExps[$key] = $compiledRouterPattern;

        return $compiledRouterPattern;
    }

    /**
     * Method returns all parameter names in the route
     *
     * @param string $routerPattern
     *            route
     * @return string[] names
     */
    private function _getParameterNames(string $routerPattern): array
    {
        if (isset($this->cachedParameters[$routerPattern])) {
            return $this->cachedParameters[$routerPattern];
        }

        $regExPattern = [];

        foreach (array_keys($this->types) as $typeName) {
            $regExPattern[] = $typeName;
        }

        $regExPattern = '\[(' . implode('|', $regExPattern) . '):(' . BaseType::PARAMETER_NAME_REGEXP . ')\]';

        $names = [];
        preg_match_all('/' . str_replace('/', '\\/', $regExPattern) . '/', $routerPattern, $names);

        $return = [];

        foreach ($names[2] as $name) {
            $return[] = $name;
        }

        $this->cachedParameters[$routerPattern] = $return;

        return $return;
    }

    /**
     * Method warms cache
     */
    public function warmCache(): void
    {
        foreach (SuppportedRequestMethods::getListOfSupportedRequestMethods() as $requestMethod) {
            /** @var array{bunch: array} $bunch */
            foreach ($this->paramRoutes[$requestMethod] as $bunch) {
                /** @var array{pattern: string} $route */
                foreach ($bunch['bunch'] as $route) {
                    $this->_getRouteMatcherRegExPattern($route['pattern']);

                    $this->_getParameterNames($route['pattern']);
                }
            }
        }

        $this->compileRegexpForBunches();

It seems like compileRegexpForBunches() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Method searches dynamic route processor
     *
     * @param string $route
     *            route
     * @param string $requestMethod
     *            request method
     * @return array{0: string, 1:string}|callable|false route's handler or false in case the handler was not found
     */
    protected function getDynamicRouteProcessor(string $route, string $requestMethod = '')
    {
        $bunches = $this->paramRoutes[$requestMethod == '' ? $this->getRequestMethod() : $requestMethod];

        /** @var array{bunch: string[], regexp: string} $bunch */
        foreach ($bunches as $bunch) {
            $matches = [];

            if (preg_match($bunch['regexp'], $route, $matches)) {
                /** @var array{pattern: string, callback: callable} $routeData */
                $routeData = $bunch['bunch'][count($matches)];

                $names = $this->_getParameterNames($routeData['pattern']);

                $this->parameters = [];
                foreach ($names as $i => $name) {
                    /** @var string[] $matches */
                    $this->parameters[$name] = $matches[(int) $i + 1];
                }

                $this->calledRoute = $routeData['pattern'];

                return $routeData['callback'];
            }
        }

        // match was not found
        return false;
    }
}