Route::getPath() - Code Metrics - thephpleague/route - Measure and Improve Code Quality continuously with Scrutinizer

Route::getPath() A
last analyzed 2024-11-25 08:12 UTC

↳ Parent: Route

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
eloc	4
c	0
b	0
f	0
dl	0
loc	9
ccs	5
cts	5
cp	1
rs	10
cc	2
nc	2
nop	1
crap	2

<?php

declare(strict_types=1);

namespace League\Route;

use Laravel\SerializableClosure\SerializableClosure;
use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use League\Route\Strategy\{StrategyAwareInterface, StrategyAwareTrait, StrategyInterface};
use Psr\Container\ContainerInterface;
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
use RuntimeException;

class Route implements
    MiddlewareInterface,
    MiddlewareAwareInterface,
    RouteConditionHandlerInterface,
    StrategyAwareInterface
{
    use MiddlewareAwareTrait;
    use RouteConditionHandlerTrait;
    use StrategyAwareTrait;

    protected $handler;

    /**
     * @param array<string>|string $method
     * @param array<string> $vars
     */
    public function __construct(
        protected array|string $method,
        protected string $path,
        callable|array|string|RequestHandlerInterface $handler,
        protected ?RouteGroup $group = null,
        protected array $vars = []
    ) {
        if ($handler instanceof \Closure) {

            $handler = new SerializableClosure($handler);
        }

        $this->handler = ($handler instanceof RequestHandlerInterface) ? [$handler, 'handle'] : $handler;

    }

    public function getCallable(?ContainerInterface $container = null): callable
    {
        $callable = $this->handler;

        if ($callable instanceof SerializableClosure) {

            $callable = $callable->getClosure();
        }

        if (is_string($callable) && str_contains($callable, '::')) {

            $callable = explode('::', $callable);
        }

        if (is_array($callable) && isset($callable[0]) && is_object($callable[0])) {
            $callable = [$callable[0], $callable[1]];
        }

        if (is_array($callable) && isset($callable[0]) && is_string($callable[0])) {
            $callable = [$this->resolve($callable[0], $container), $callable[1]];
        }

        if (is_string($callable)) {
            $callable = $this->resolve($callable, $container);
        }

        if ($callable instanceof RequestHandlerInterface) {
            $callable = [$callable, 'handle'];
        }

        if (!is_callable($callable)) {
            throw new RuntimeException('Could not resolve a callable for this route');
        }

        return $callable;
    }

    /**
     * @return array<string>|string
     */
    public function getMethod(): array|string
    {
        return $this->method;
    }

    public function getParentGroup(): ?RouteGroup
    {
        return $this->group;
    }

    public function getPath(array $replacements = []): string
    {
        $toReplace = [];

        foreach ($replacements as $wildcard => $actual) {
            $toReplace['/{' . preg_quote($wildcard, '/') . '(:.*?)?}/'] = $actual;
        }

        return preg_replace(array_keys($toReplace), array_values($toReplace), $this->path);
    }

    /**
     * @return array<string>
     */
    public function getVars(): array
    {
        return $this->vars;
    }

    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler
    ): ResponseInterface {
        $strategy = $this->getStrategy();

        if (!($strategy instanceof StrategyInterface)) {
            throw new RuntimeException('A strategy must be set to process a route');
        }

        return $strategy->invokeRouteCallable($this, $request);
    }

    public function setParentGroup(RouteGroup $group): self
    {
        $this->group = $group;
        $prefix = $this->group->getPrefix();
        $path = $this->getPath();

        if (strcmp($prefix, substr($path, 0, strlen($prefix))) !== 0) {
            $path = $prefix . $path;
            $this->path = $path;
        }

        return $this;
    }

    /**
     * @param array<string> $vars
     */
    public function setVars(array $vars): self
    {
        $this->vars = $vars;
        return $this;
    }

    /**
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    protected function resolve(string $class, ?ContainerInterface $container = null): mixed
    {
        if ($container instanceof ContainerInterface && $container->has($class)) {
            return $container->get($class);
        }

        if (class_exists($class)) {
            return new $class();
        }

        return $class;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace League\Route;
6
7		use Laravel\SerializableClosure\SerializableClosure;
8		use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
9		use Psr\Container\ContainerExceptionInterface;
10		use Psr\Container\NotFoundExceptionInterface;
11		use League\Route\Strategy\{StrategyAwareInterface, StrategyAwareTrait, StrategyInterface};
12		use Psr\Container\ContainerInterface;
13		use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
14		use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
15		use RuntimeException;
16
17		class Route implements
18		MiddlewareInterface,
19		MiddlewareAwareInterface,
20		RouteConditionHandlerInterface,
21		StrategyAwareInterface
22		{
23		use MiddlewareAwareTrait;
24		use RouteConditionHandlerTrait;
25		use StrategyAwareTrait;
26
27		protected $handler;
28
29		/**
30		* @param array<string>\|string $method
31		* @param array<string> $vars
32		*/
33	90	public function __construct(
34		protected array\|string $method,
35		protected string $path,
36		callable\|array\|string\|RequestHandlerInterface $handler,
37		protected ?RouteGroup $group = null,
38		protected array $vars = []
39		) {
40	90	if ($handler instanceof \Closure) {
		0 ignored issues – show introduced 2024-11-25 08:12 UTC by Report Bug Copy Issue Report `$handler` is never a sub-type of `Closure`. Loading history...
41	66	$handler = new SerializableClosure($handler);
42		}
43
44	90	$this->handler = ($handler instanceof RequestHandlerInterface) ? [$handler, 'handle'] : $handler;
		0 ignored issues – show introduced 2024-11-20 10:02 UTC by Report Bug Copy Issue Report `$handler` is never a sub-type of `Psr\Http\Server\RequestHandlerInterface`. Loading history...
45		}
46
47	57	public function getCallable(?ContainerInterface $container = null): callable
48		{
49	57	$callable = $this->handler;
50
51	57	if ($callable instanceof SerializableClosure) {
		0 ignored issues – show introduced 2024-11-25 08:12 UTC by Report Bug Copy Issue Report `$callable` is never a sub-type of `Laravel\SerializableClosure\SerializableClosure`. Loading history...
52	33	$callable = $callable->getClosure();
53		}
54
55	57	if (is_string($callable) && str_contains($callable, '::')) {
		0 ignored issues – show introduced 2024-11-20 10:02 UTC by Report Bug Copy Issue Report The condition `is_string($callable)` is always `false`. Loading history...
56	6	$callable = explode('::', $callable);
57		}
58
59	57	if (is_array($callable) && isset($callable[0]) && is_object($callable[0])) {
60	6	$callable = [$callable[0], $callable[1]];
61		}
62
63	57	if (is_array($callable) && isset($callable[0]) && is_string($callable[0])) {
64	9	$callable = [$this->resolve($callable[0], $container), $callable[1]];
65		}
66
67	57	if (is_string($callable)) {
68	6	$callable = $this->resolve($callable, $container);
69		}
70
71	57	if ($callable instanceof RequestHandlerInterface) {
72	3	$callable = [$callable, 'handle'];
73		}
74
75	57	if (!is_callable($callable)) {
76		throw new RuntimeException('Could not resolve a callable for this route');
77		}
78
79	57	return $callable;
80		}
81
82		/**
83		* @return array<string>\|string
84		*/
85	45	public function getMethod(): array\|string
86		{
87	45	return $this->method;
88		}
89
90	33	public function getParentGroup(): ?RouteGroup
91		{
92	33	return $this->group;
93		}
94
95	51	public function getPath(array $replacements = []): string
96		{
97	51	$toReplace = [];
98
99	51	foreach ($replacements as $wildcard => $actual) {
100	3	$toReplace['/{' . preg_quote($wildcard, '/') . '(:.*?)?}/'] = $actual;
101		}
102
103	51	return preg_replace(array_keys($toReplace), array_values($toReplace), $this->path);
104		}
105
106		/**
107		* @return array<string>
108		*/
109	33	public function getVars(): array
110		{
111	33	return $this->vars;
112		}
113
114	33	public function process(
115		ServerRequestInterface $request,
116		RequestHandlerInterface $handler
117		): ResponseInterface {
118	33	$strategy = $this->getStrategy();
119
120	33	if (!($strategy instanceof StrategyInterface)) {
121	3	throw new RuntimeException('A strategy must be set to process a route');
122		}
123
124	30	return $strategy->invokeRouteCallable($this, $request);
125		}
126
127	15	public function setParentGroup(RouteGroup $group): self
128		{
129	15	$this->group = $group;
130	15	$prefix = $this->group->getPrefix();
131	15	$path = $this->getPath();
132
133	15	if (strcmp($prefix, substr($path, 0, strlen($prefix))) !== 0) {
134	3	$path = $prefix . $path;
135	3	$this->path = $path;
136		}
137
138	15	return $this;
139		}
140
141		/**
142		* @param array<string> $vars
143		*/
144	33	public function setVars(array $vars): self
145		{
146	33	$this->vars = $vars;
147	33	return $this;
148		}
149
150		/**
151		* @throws ContainerExceptionInterface
152		* @throws NotFoundExceptionInterface
153		*/
154	15	protected function resolve(string $class, ?ContainerInterface $container = null): mixed
155		{
156	15	if ($container instanceof ContainerInterface && $container->has($class)) {
157	9	return $container->get($class);
158		}
159
160	6	if (class_exists($class)) {
161	3	return new $class();
162		}
163
164	3	return $class;
165		}
166		}
167

thephpleague / route

Route::getPath() A last analyzed 2024-11-25 08:12 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Route::getPath() A
last analyzed 2024-11-25 08:12 UTC