kalanis\kw_routed_paths\Sources\Request

Complexity

Total Complexity

21

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	pathToSegments()	0	30	4
A	parseParamsToArray()	0	4	1
A	getData()	0	8	1
A	__construct()	0	4	1
A	updateVirtualKeys()	0	23	6
A	explodeInput()	0	3	2
A	parseVirtualPath()	0	23	6

<?php

namespace kalanis\kw_routed_paths\Sources;


use kalanis\kw_paths\Interfaces\IPaths;
use kalanis\kw_routed_paths\Support;


/**
 * Class Request
 * @package kalanis\kw_routed_paths\Sources
 * Input source is Request Uri in preset variables
 * This one is for accessing content with url rewrite engines
 */
class Request extends ASource
{
    protected string $requestUri = '';
    protected ?string $virtualDir = '';

    /**
     * @param string $requestUri
     * @param string|null $virtualDir
     *
     * virtual dir has following variants:
     * empty string - cut on start of query string - cut on first possible position
     * null - cut on end of query string - don't know when cut
     * something - cut where you find that "prefix"
     */
    public function __construct(string $requestUri, ?string $virtualDir = null)
    {
        $this->requestUri = $requestUri;
        $this->virtualDir = $virtualDir;
    }

    /**
     * @return array<string|int, mixed|null> $params
     * path is composed from:
     * static part - for subdirectory on server
     * virtual prefix - something to split the string
     * path and other keys - after splitting to describe what client want
     */
    public function getData(): array
    {
        list($path, $params) = $this->explodeInput($this->requestUri);
        list($staticPath, $virtualPrefix, $virtualParamPath) = $this->pathToSegments(urldecode($path), $this->virtualDir);
        return array_merge(
                compact('staticPath', 'virtualPrefix'),
                $this->updateVirtualKeys($this->parseVirtualPath($virtualParamPath)),
                $this->parseParamsToArray($params)
        );
    }

    /**
     * @param string $uri
     * @return string[]
     */
    protected function explodeInput(string $uri): array
    {
        return (false !== strpos($uri, IPaths::SPLITTER_QUOTE)) ? explode(IPaths::SPLITTER_QUOTE, $uri, 2) : [$uri, ''];
    }

    /**
     * @param string $path
     * @param string|null $fakeDir
     * @return array<string|null>
     */
    protected function pathToSegments(string $path, ?string $fakeDir): array
    {
        if (!empty($fakeDir)) {
            $splitPos = mb_strpos($path, $fakeDir);
            if (false !== $splitPos) {
                // got rewrite!
                $statical = mb_substr($path, 0, $splitPos);
                $mask = $fakeDir;
                $virtual = mb_substr($path, $splitPos + mb_strlen($fakeDir));
            } else {
                // no rewrite!
                $statical = $path;
                $mask = null;
                $virtual = null;
            }
        } else {
            if (is_null($fakeDir)) {

The condition is_null($fakeDir) is always true.

                // no rewrite!
                $statical = $path;
                $mask = null;
                $virtual = null;
            } else {
                // no rewrite!
                $statical = null;
                $mask = null;
                $virtual = $path;
            }
        }

        return [$statical, $mask, $virtual];
    }

    /**
     * @param string $param
     * @return array<string|int, array<mixed>|string|int|bool>
     */
    protected function parseParamsToArray(string $param): array
    {
        parse_str(html_entity_decode($param, ENT_QUOTES | ENT_HTML5, 'UTF-8'), $result);
        return $result;
    }

    /**
     * @param string|null $path
     * @return array<string|int, mixed>
     */
    protected function parseVirtualPath(?string $path): array
    {
        $params = [];
        if (is_null($path)) {
            return $params;
        }
        if (false != preg_match_all('#([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]*)#ui', $path, $matches)) {

It seems like you are loosely comparing preg_match_all('#([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]*)#ui', $path, $matches) of type integer|null against false; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

            // for each containing colons
            foreach ($matches[0] as $index => $match) {
                $params[$matches[1][$index]] = $matches[2][$index];
            }
            // lookup for last part which does not contain colon
            if (false != preg_match_all('#:[a-zA-Z0-9_-]*\/([^:]+)#ui', $path, $found)) {

It seems like you are loosely comparing preg_match_all('#:[a-zA-Z0-9_-]*\/([^:]+)#ui', $path, $found) of type integer|null against false; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

                $foundPath = end($found[1]);
                if (false !== $foundPath) {
                    $params['path'] = $foundPath;
                }
            }
        } else {
            // no colon, just path
            $params['path'] = $path;
        }
        return $params;
    }

    /**
     * @param array<string|int, mixed> $params
     * @return array<string|int, mixed>
    // U:user
    // M:module
    // MS:solo_module
    // L:lang
     */
    protected function updateVirtualKeys(array $params): array
    {
        $result = [];
        foreach ($params as $key => $param) {
            switch (strtolower(strval($key))) {
                case Support::PREFIX_MOD_SINGLE:
                    $result['module'] = $param;
                    $result['single'] = true;
                    break;
                case Support::PREFIX_MOD_NORMAL:
                    $result['module'] = $param;
                    break;
                case Support::PREFIX_USER:
                    $result['user'] = $param;
                    break;
                case Support::PREFIX_LANG:
                    $result['lang'] = $param;
                    break;
                default:
                    $result[$key] = $param;
            }
        }
        return $result;
    }
}