RouteCompiler::generateUri() - Code Metrics - Inspection of "Performance Update" - divineniiquaye/flight-routing - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — master (#16)

by Divine Niiquaye
created 2021-09-07 17:39 UTC
RouteCompiler::generateUri() B

↳ Parent: RouteCompiler
Complexity

Conditions	7
Paths	18
Size

Total Lines	30
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	7
eloc	15
c	2
b	0
f	0
nc	18
nop	3
dl	0
loc	30
rs	8.8333
<?php

declare(strict_types=1);

/*
 * This file is part of Flight Routing.
 *
 * PHP version 7.1 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Flight\Routing;

use Flight\Routing\Routes\{FastRoute as Route, Route as BaseRoute};
use Flight\Routing\Exceptions\{UriHandlerException, UrlGenerationException};
use Flight\Routing\Interfaces\RouteCompilerInterface;

/**
 * RouteCompiler compiles Route instances to regex.
 *
 * provides ability to match and generate uris based on given parameters.
 *
 * @final This class is final and recommended not to be extended unless special cases
 *
 * @author Divine Niiquaye Ibok <[email protected]>
 */
class RouteCompiler implements RouteCompilerInterface
{
    private const DEFAULT_SEGMENT = '[^\/]+';

    /**
     * This string defines the characters that are automatically considered separators in front of
     * optional placeholders (with default and no static text following). Such a single separator
     * can be left out together with the optional placeholder from matching and generating URLs.
     */
    private const PATTERN_REPLACES = ['/' => '\\/', '/[' => '\/?(?:', '[' => '(?:', ']' => ')?', '.' => '\.'];

    private const SEGMENT_REPLACES = ['/' => '\\/', '.' => '\.'];

    /**
     * This regex is used to match a certain rule of pattern to be used for routing.
     *
     * List of string patterns that regex matches:
     * - /{var} - A required variable pattern
     * - /[{var}] - An optional variable pattern
     * - /foo[/{var}] - A path with an optional sub variable pattern
     * - /foo[/{var}[.{format}]] - A path with optional nested variables
     * - /{var:[a-z]+} - A required variable with lowercase rule
     * - /{var=foo} - A required variable with default value
     * - /{var}[.{format:(html|php)=html}] - A required variable with an optional variable, a rule & default
     */
    private const COMPILER_REGEX = '~\\{(\\w+)(?:\\:([^{}=]+(?:\\{[\\w,^{}]+)?))?(?:\\=((?2)))?\\}~i';

    /**
     * A matching requirement helper, to ease matching route pattern when found.
     */
    private const SEGMENT_TYPES = [
        'int' => '\d+',
        'lower' => '[a-z]+',
        'upper' => '[A-Z]+',
        'alpha' => '[A-Za-z]+',
        'alnum' => '[A-Za-z0-9]+',
        'year' => '[12][0-9]{3}',
        'month' => '0[1-9]|1[012]+',
        'day' => '0[1-9]|[12][0-9]|3[01]+',
        'uuid' => '0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}',
    ];

    /**
     * A helper in reversing route pattern to URI.
     */
    private const URI_FIXERS = [
        '[]' => '',
        '[/]' => '',
        '[' => '',
        ']' => '',
        '://' => '://',
        '//' => '/',
        '/..' => '/%2E%2E',
        '/.' => '/%2E',
    ];

    /**
     * The maximum supported length of a PCRE subpattern name
     * http://pcre.org/current/doc/html/pcre2pattern.html#SEC16.
     *
     * @internal
     */
    private const VARIABLE_MAXIMUM_LENGTH = 32;

    /**
     * {@inheritdoc}
     */
    public function compile(Route $route): array
    {
        $hostVariables = $hostsRegex = [];
        $requirements = $route->get('patterns');

        // Strip supported browser prefix of $routePath ...
        $routePath = \rtrim($routePath = $route->get('path'), Route::URL_PREFIX_SLASHES[$routePath[-1]] ?? '/');
        $routePath = \rtrim(/** @scrutinizer ignore-type */ $routePath = $route->get('path'), Route::URL_PREFIX_SLASHES[$routePath[-1]] ?? '/');

        if (!empty($routePath) && '/' === $routePath[0]) {
            $routePath = \substr($routePath, 1);
        }

        foreach ($route->get('domain') as $host) {
            [$hostRegex, $hostVariable] = self::compilePattern($host, false, $requirements);
            [$hostRegex, $hostVariable] = self::compilePattern($host, false, /** @scrutinizer ignore-type */ $requirements);

            $hostVariables += $hostVariable;
            $hostsRegex[] = $hostRegex;
        }

        if (\str_contains($routePath, '{')) {
            [$pathRegex, $pathVariables] = self::compilePattern('/' . $routePath, false, $requirements);
            $variables = empty($hostVariables) ? $pathVariables : $hostVariables += $pathVariables;
        }

        return [$pathRegex ?? '/' . $routePath, $hostsRegex, $variables ?? $hostVariables];
    }

    /**
     * {@inheritdoc}
     */
    public function generateUri(Route $route, array $parameters, array $defaults = []): GeneratedUri
    {
        [$pathRegex, $pathVariables] = self::compilePattern(\ltrim($route->get('path'), '/'), true);
        [$pathRegex, $pathVariables] = self::compilePattern(\ltrim(/** @scrutinizer ignore-type */ $route->get('path'), '/'), true);

        $pathRegex = '/' . \stripslashes(\str_replace('?', '', $pathRegex));
        $createUri = new GeneratedUri(self::interpolate($pathRegex, $parameters, $defaults, $pathVariables));

        foreach ($route->get('domain') as $host) {
            $compiledHost = self::compilePattern($host, true);

            if (!empty($compiledHost)) {
                [$hostRegex, $hostVariables] = $compiledHost;

                break;
            }
        }

        if (!empty($schemes = $route->get('schemes'))) {
            $createUri->withScheme(\in_array('https', $schemes, true) ? 'https' : \end($schemes) ?? 'http');

            if (!isset($hostRegex)) {
                $createUri->withHost($_SERVER['HTTP_HOST'] ?? '');
            }
        }

        if (isset($hostRegex)) {
            $createUri->withHost(self::interpolate($hostRegex, $parameters, $defaults, $hostVariables));

        }

        return $createUri;
    }

    /**
     * Check for mandatory parameters then interpolate $uriRoute with given $parameters.
     *
     * @param array<int|string,mixed> $parameters
     */
    private static function interpolate(string $uriRoute, array $parameters, array $defaults, array $allowed): string
    {
        \preg_match_all('#(?:\[)?\<(\w+).*?\>(?:\])?#', $uriRoute, $paramVars, \PREG_SET_ORDER);

        foreach ($paramVars as $offset => [$type, $var]) {
            if ('[' === $type[0]) {
                $defaults[$var] = null;

                continue;
            }

            if (isset($parameters[$offset])) {
                $defaults[$var] = $parameters[$offset];
                unset($parameters[$offset]);
            }
        }

        // Fetch and merge all possible parameters + route defaults ...
        $parameters += $defaults;

        // all params must be given
        if ($diff = \array_diff_key($allowed, $parameters)) {
            throw new UrlGenerationException(\sprintf('Some mandatory parameters are missing ("%s") to generate a URL for route path "%s".', \implode('", "', \array_keys($diff)), $uriRoute));
        }

        $replaces = self::URI_FIXERS;

        foreach ($parameters as $key => $value) {
            $replaces["<{$key}>"] = (\is_array($value) || $value instanceof \Closure) ? '' : $value;
        }

        return \strtr($uriRoute, $replaces);
    }

    private static function sanitizeRequirement(string $key, ?string $regex): string
    {
        if (!empty($regex)) {
            if ('^' === $regex[0]) {
                $regex = \substr($regex, 1);
            } elseif (0 === \strpos($regex, '\\A')) {
                $regex = \substr($regex, 2);
            }

            if ('$' === $regex[-1]) {
                $regex = \substr($regex, 0, -1);
            } elseif (\strlen($regex) - 2 === \strpos($regex, '\\z')) {
                $regex = \substr($regex, 0, -2);
            }
        }

        if ('' === $regex) {
            throw new \InvalidArgumentException(\sprintf('Routing requirement for "%s" cannot be empty.', $key));
        }

        return null !== $regex ? \strtr($regex, self::SEGMENT_REPLACES) : self::DEFAULT_SEGMENT;
    }

    /**
     * @param array<string,string|string[]> $requirements
     *
     * @throws UriHandlerException if a variable name starts with a digit or
     *                             if it is too long to be successfully used as a PCRE subpattern or
     *                             if a variable is referenced more than once
     *
     * @return array<string,mixed>
     */
    private static function compilePattern(string $uriPattern, bool $reversed = false, array $requirements = []): array
    {
        $variables = $replaces = [];

        // correct [/ first occurrence]
        if (0 === \strpos($uriPattern, '[/')) {
            $uriPattern = '[' . \substr($uriPattern, 3);
        }

        // Match all variables enclosed in "{}" and iterate over them...
        \preg_match_all(self::COMPILER_REGEX, $uriPattern, $matches, \PREG_SET_ORDER | \PREG_UNMATCHED_AS_NULL);

        foreach ($matches as [$placeholder, $varName, $segment, $default]) {
            // Filter variable name to meet requirement
            self::filterVariableName($varName, $uriPattern);

            if (\array_key_exists($varName, $variables)) {
                throw new UriHandlerException(\sprintf('Route pattern "%s" cannot reference variable name "%s" more than once.', $uriPattern, $varName));
            }

            $variables[$varName] = $default;
            $replaces[$placeholder] = !$reversed ? '(?P<' . $varName . '>' . (self::SEGMENT_TYPES[$segment] ?? $segment ?? self::prepareSegment($varName, $requirements)) . ')' : "<$varName>";
        }

        return [\strtr($uriPattern, !$reversed ? self::PATTERN_REPLACES + $replaces : $replaces), $variables];
    }

    /**
     * Prevent variables with same name used more than once.
     */
    private static function filterVariableName(string $varName, string $pattern): void
    {
        // A PCRE subpattern name must start with a non-digit. Also a PHP variable cannot start with a digit so the
        // variable would not be usable as a Controller action argument.
        if (1 === \preg_match('/^\d/', $varName)) {
            throw new UriHandlerException(
                \sprintf('Variable name "%s" cannot start with a digit in route pattern "%s". Use a different name.', $varName, $pattern)
            );
        }

        if (\strlen($varName) > self::VARIABLE_MAXIMUM_LENGTH) {
            throw new UriHandlerException(
                \sprintf(
                    'Variable name "%s" cannot be longer than %s characters in route pattern "%s".',
                    $varName,
                    self::VARIABLE_MAXIMUM_LENGTH,
                    $pattern
                )
            );
        }
    }

    /**
     * Prepares segment pattern with given constrains.
     *
     * @param array<string,mixed> $requirements
     */
    private static function prepareSegment(string $name, array $requirements): string
    {
        $segment = $requirements[$name] ?? null;

        if (!\is_array($segment)) {
            return self::sanitizeRequirement($name, $segment);
        }

        return \implode('|', \array_map([__CLASS__, 'sanitizeRequirement'], $segment));
    }
}

divineniiquaye / flight-routing

Pull Request — master (#16)

RouteCompiler::generateUri() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
