Route::calculateDefaultPathPattern() - Code Metrics - Inspection of "Bugfix/mandatory and optional args" - gacela-project/router - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#35)

unknown

created 2023-06-04 09:43 UTC

Route::calculateDefaultPathPattern() A

↳ Parent: Route

Complexity

Conditions	5
Paths	5

Size

Total Lines	19
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	5

Importance

Changes

Metric	Value
cc	5
eloc	12
c	0
b	0
f	0
nc	5
nop	0
dl	0
loc	19
ccs	12
cts	12
cp	1
crap	5
rs	9.5555

<?php

declare(strict_types=1);

namespace Gacela\Router\Entities;

use Gacela\Container\Container;
use Gacela\Router\Configure\Bindings;
use Gacela\Router\Exceptions\UnsupportedResponseTypeException;
use Stringable;

use function is_object;
use function is_string;

final class Route
{
    /**
     * @param object|class-string $controller

     */
    public function __construct(
        private string $method,
        private string $path,
        private object|string $controller,
        private string $action = '__invoke',
        private ?string $pathPattern = null,
    ) {
    }

    /**
     * @psalm-suppress MixedMethodCall
     */
    public function run(Bindings $bindings): string|Stringable
    {
        $params = (new RouteParams($this))->getAll();

        if (!is_object($this->controller)) {
            $creator = new Container($bindings->getAllBindings());
            /** @var object $controller */
            $controller = $creator->get($this->controller);
            $response = $controller->{$this->action}(...$params);
        } else {
            /** @var string|Stringable $response */
            $response = $this->controller->{$this->action}(...$params);
        }

        if (!is_string($response) && !($response instanceof Stringable)) {
            throw UnsupportedResponseTypeException::fromType($response);
        }

        return $response;
    }

    public function path(): string
    {
        return $this->path;
    }

    /**
     * @return object|class-string

     */
    public function controller(): object|string
    {
        return $this->controller;
    }

    public function action(): string
    {
        return $this->action;
    }

    public function getPathPattern(): string
    {
        if ($this->pathPattern === null) {
            $this->pathPattern = $this->calculateDefaultPathPattern();
        }

        return $this->pathPattern;

    }

    public function requestMatches(): bool
    {
        return $this->methodMatches() && $this->pathMatches();
    }

    private function methodMatches(): bool
    {
        return Request::fromGlobals()->isMethod($this->method);
    }

    private function pathMatches(): bool
    {
        $path = Request::fromGlobals()->path();

        return (bool)preg_match($this->getPathPattern(), $path);
    }

    /**
     * @todo: improve this method and maybe move it to a separate class
     *
     * @return string
     */
    private function calculateDefaultPathPattern(): string
    {
        if ($this->path === '') {
            return '#^/?$#';
        }

        $parts = explode('/', $this->path);
        $pattern = '';
        foreach ($parts as $part) {
            if (preg_match(RouteParams::MANDATORY_PARAM_PATTERN, $part)) {
                $pattern .= '/([^\/]+)';
            } elseif (preg_match(RouteParams::OPTIONAL_PARAM_PATTERN, $part)) {
                $pattern .= '/?([^\/]+)?';
            } else {
                $pattern .= '/' . $part;
            }
        }

        return '#^/' . ltrim($pattern, '/') . '$#';
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Gacela\Router\Entities;
6
7		use Gacela\Container\Container;
8		use Gacela\Router\Configure\Bindings;
9		use Gacela\Router\Exceptions\UnsupportedResponseTypeException;
10		use Stringable;
11
12		use function is_object;
13		use function is_string;
14
15		final class Route
16		{
17		/**
18		* @param object\|class-string $controller
		0 ignored issues – show Documentation Bug introduced 2023-04-09 15:08 UTC by Report Bug Copy Issue Report The doc comment `object\|class-string` at position `2` could not be parsed: Unknown type name 'class-string' at position 2 in object\|class-string. Loading history...
19		*/
20	102	public function __construct(
21		private string $method,
22		private string $path,
23		private object\|string $controller,
24		private string $action = '__invoke',
25		private ?string $pathPattern = null,
26		) {
27	102	}
28
29		/**
30		* @psalm-suppress MixedMethodCall
31		*/
32	97	public function run(Bindings $bindings): string\|Stringable
33		{
34	97	$params = (new RouteParams($this))->getAll();
35
36	95	if (!is_object($this->controller)) {
37	70	$creator = new Container($bindings->getAllBindings());
38		/** @var object $controller */
39	70	$controller = $creator->get($this->controller);
40	70	$response = $controller->{$this->action}(...$params);
41		} else {
42		/** @var string\|Stringable $response */
43	25	$response = $this->controller->{$this->action}(...$params);
44		}
45
46	90	if (!is_string($response) && !($response instanceof Stringable)) {
47	4	throw UnsupportedResponseTypeException::fromType($response);
48		}
49
50	86	return $response;
51		}
52
53	97	public function path(): string
54		{
55	97	return $this->path;
56		}
57
58		/**
59		* @return object\|class-string
		0 ignored issues – show Documentation Bug introduced 2023-04-11 13:38 UTC by Report Bug Copy Issue Report The doc comment `object\|class-string` at position `2` could not be parsed: Unknown type name 'class-string' at position 2 in object\|class-string. Loading history...
60		*/
61	97	public function controller(): object\|string
62		{
63	97	return $this->controller;
64		}
65
66	97	public function action(): string
67		{
68	97	return $this->action;
69		}
70
71	97	public function getPathPattern(): string
72		{
73	97	if ($this->pathPattern === null) {
74	97	$this->pathPattern = $this->calculateDefaultPathPattern();
75		}
76
77	97	return $this->pathPattern;
		0 ignored issues – show Bug Best Practice introduced 2023-05-16 21:47 UTC by Report Bug Copy Issue Report The expression `return $this->pathPattern` could return the type `null` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
78		}
79
80	102	public function requestMatches(): bool
81		{
82	102	return $this->methodMatches() && $this->pathMatches();
83		}
84
85	102	private function methodMatches(): bool
86		{
87	102	return Request::fromGlobals()->isMethod($this->method);
88		}
89
90	97	private function pathMatches(): bool
91		{
92	97	$path = Request::fromGlobals()->path();
93
94	97	return (bool)preg_match($this->getPathPattern(), $path);
95		}
96
97		/**
98		* @todo: improve this method and maybe move it to a separate class
99		*
100		* @return string
101		*/
102	97	private function calculateDefaultPathPattern(): string
103		{
104	97	if ($this->path === '') {
105	1	return '#^/?$#';
106		}
107
108	97	$parts = explode('/', $this->path);
109	97	$pattern = '';
110	97	foreach ($parts as $part) {
111	97	if (preg_match(RouteParams::MANDATORY_PARAM_PATTERN, $part)) {
112	43	$pattern .= '/([^\/]+)';
113	93	} elseif (preg_match(RouteParams::OPTIONAL_PARAM_PATTERN, $part)) {
114	8	$pattern .= '/?([^\/]+)?';
115		} else {
116	93	$pattern .= '/' . $part;
117		}
118		}
119
120	97	return '#^/' . ltrim($pattern, '/') . '$#';
121		}
122		}
123

gacela-project / router

Pull Request — main (#35)

Route::calculateDefaultPathPattern() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like