Route::withRouteDispatchedMiddleware() - Code Metrics - valkyrjaio/valkyrja - Measure and Improve Code Quality continuously with Scrutinizer

Route::withRouteDispatchedMiddleware() A
last analyzed 2025-08-08 04:54 UTC

↳ Parent: Route

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	4
dl	0
loc	8
rs	10
c	1
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Http\Routing\Data;

use Override;
filter:
    dependency_paths: ["lib/*"]
use Valkyrja\Dispatcher\Data\Contract\MethodDispatch;
use Valkyrja\Http\Message\Enum\RequestMethod;
filter:
    dependency_paths: ["lib/*"]
use Valkyrja\Http\Middleware\Contract\RouteDispatchedMiddleware;
use Valkyrja\Http\Middleware\Contract\RouteMatchedMiddleware;
use Valkyrja\Http\Middleware\Contract\SendingResponseMiddleware;
use Valkyrja\Http\Middleware\Contract\TerminatedMiddleware;
use Valkyrja\Http\Middleware\Contract\ThrowableCaughtMiddleware;
use Valkyrja\Http\Routing\Data\Contract\Parameter;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use Valkyrja\Http\Routing\Data\Contract\Route as Contract;
use Valkyrja\Http\Struct\Request\Contract\RequestStruct;
use Valkyrja\Http\Struct\Response\Contract\ResponseStruct;

use function in_array;

/**
 * Class Route.
 *
 * @author Melech Mizrachi
 */
class Route implements Contract
{
    /**
     * @param non-empty-string                          $path                      The path

     * @param non-empty-string                          $name                      The name
     * @param non-empty-string|null                     $regex                     The regex
     * @param RequestMethod[]                           $requestMethods            The request methods
     * @param Parameter[]                               $parameters                The parameters
     * @param class-string<RouteMatchedMiddleware>[]    $routeMatchedMiddleware    The route matched middleware
     * @param class-string<RouteDispatchedMiddleware>[] $routeDispatchedMiddleware The route dispatched middleware
     * @param class-string<ThrowableCaughtMiddleware>[] $throwableCaughtMiddleware The throwable caught middleware
     * @param class-string<SendingResponseMiddleware>[] $sendingResponseMiddleware The sending response middleware
     * @param class-string<TerminatedMiddleware>[]      $terminatedMiddleware      The terminated middleware
     * @param class-string<RequestStruct>|null          $requestStruct             The request struct
     * @param class-string<ResponseStruct>|null         $responseStruct            The response struct
     */
    public function __construct(
        protected string $path,
        protected string $name,
        protected MethodDispatch $dispatch = new \Valkyrja\Dispatcher\Data\MethodDispatch(self::class, 'getPath'),
        protected array $requestMethods = [RequestMethod::HEAD, RequestMethod::GET],
        protected string|null $regex = null,
        protected array $parameters = [],
        protected array $routeMatchedMiddleware = [],
        protected array $routeDispatchedMiddleware = [],
        protected array $throwableCaughtMiddleware = [],
        protected array $sendingResponseMiddleware = [],
        protected array $terminatedMiddleware = [],
        protected string|null $requestStruct = null,
        protected string|null $responseStruct = null,
    ) {
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withPath(string $path): static
    {
        $new = clone $this;

        $new->path = $path;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedPath(string $path): static
    {
        $new = clone $this;

        $filteredExistingPath = $this->getFilteredPath($this->path);
        $filteredPath         = $this->getFilteredPath($path);

        $new->path = $this->getFilteredPath($filteredExistingPath . $filteredPath);

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withName(string $name): static
    {
        $new = clone $this;

        $new->name = $name;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedName(string $name): static
    {
        $new = clone $this;

        $new->name = $this->name . $name;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getDispatch(): MethodDispatch
    {
        return $this->dispatch;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withDispatch(MethodDispatch $dispatch): static
    {
        $new = clone $this;

        $new->dispatch = $dispatch;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return RequestMethod[]
     */
    #[Override]
    public function getRequestMethods(): array
    {
        return $this->requestMethods;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function hasRequestMethod(RequestMethod $requestMethod): bool
    {
        return in_array($requestMethod, $this->requestMethods, true);
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withRequestMethod(RequestMethod $requestMethod): static
    {
        $new = clone $this;

        $new->requestMethods = [$requestMethod];

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withRequestMethods(RequestMethod ...$requestMethods): static
    {
        $new = clone $this;

        $new->requestMethods = $requestMethods;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedRequestMethod(RequestMethod $requestMethod): static
    {
        $new = clone $this;

        if (! in_array($requestMethod, $this->requestMethods, true)) {
            $new->requestMethods[] = $requestMethod;
        }

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedRequestMethods(RequestMethod ...$requestMethods): static
    {
        $new = clone $this;

        foreach ($requestMethods as $requestMethod) {
            if (! in_array($requestMethod, $this->requestMethods, true)) {
                $new->requestMethods[] = $requestMethod;
            }
        }

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getRegex(): string|null
    {
        return $this->regex;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withRegex(string|null $regex = null): static
    {
        $new = clone $this;

        $new->regex = $regex;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return array<array-key, Parameter>

     */
    #[Override]
    public function getParameters(): array
    {
        return $this->parameters;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withParameter(Parameter $parameter): static
    {
        $new = clone $this;

        $new->parameters = [$parameter];

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withParameters(Parameter ...$parameters): static
    {
        $new = clone $this;

        $new->parameters = $parameters;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedParameter(Parameter $parameter): static
    {
        $new = clone $this;

        $new->parameters[] = $parameter;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withAddedParameters(Parameter ...$parameters): static
    {
        $new = clone $this;

        $new->parameters = array_merge($this->parameters, $parameters);

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return class-string<RouteMatchedMiddleware>[]

     */
    #[Override]
    public function getRouteMatchedMiddleware(): array
    {
        return $this->routeMatchedMiddleware;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<RouteMatchedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withRouteMatchedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->routeMatchedMiddleware = $middleware;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<RouteMatchedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withAddedRouteMatchedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->routeMatchedMiddleware = array_merge($this->routeMatchedMiddleware, $middleware);

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return class-string<RouteDispatchedMiddleware>[]

     */
    #[Override]
    public function getRouteDispatchedMiddleware(): array
    {
        return $this->routeDispatchedMiddleware;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<RouteDispatchedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withRouteDispatchedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->routeDispatchedMiddleware = $middleware;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<RouteDispatchedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withAddedRouteDispatchedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->routeDispatchedMiddleware = array_merge($this->routeDispatchedMiddleware, $middleware);

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return class-string<ThrowableCaughtMiddleware>[]

     */
    #[Override]
    public function getThrowableCaughtMiddleware(): array
    {
        return $this->throwableCaughtMiddleware;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<ThrowableCaughtMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withThrowableCaughtMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->throwableCaughtMiddleware = $middleware;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<ThrowableCaughtMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withAddedThrowableCaughtMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->throwableCaughtMiddleware = array_merge($this->throwableCaughtMiddleware, $middleware);

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return class-string<SendingResponseMiddleware>[]

     */
    #[Override]
    public function getSendingResponseMiddleware(): array
    {
        return $this->sendingResponseMiddleware;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<SendingResponseMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withSendingResponseMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->sendingResponseMiddleware = $middleware;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<SendingResponseMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withAddedSendingResponseMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->sendingResponseMiddleware = array_merge($this->sendingResponseMiddleware, $middleware);

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @return class-string<TerminatedMiddleware>[]

     */
    #[Override]
    public function getTerminatedMiddleware(): array
    {
        return $this->terminatedMiddleware;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<TerminatedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withTerminatedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->terminatedMiddleware = $middleware;

        return $new;
    }

    /**
     * @inheritDoc
     *
     * @param class-string<TerminatedMiddleware> ...$middleware The middleware

     */
    #[Override]
    public function withAddedTerminatedMiddleware(string ...$middleware): static
    {
        $new = clone $this;

        $new->terminatedMiddleware = array_merge($this->terminatedMiddleware, $middleware);

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getRequestStruct(): string|null
    {
        return $this->requestStruct;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withRequestStruct(string|null $requestStruct = null): static
    {
        $new = clone $this;

        $new->requestStruct = $requestStruct;

        return $new;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function getResponseStruct(): string|null
    {
        return $this->responseStruct;
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function withResponseStruct(string|null $responseStruct = null): static
    {
        $new = clone $this;

        $new->responseStruct = $responseStruct;

        return $new;
    }

    /**
     * Validate a path.
     *
     * @param non-empty-string $path The path

     *
     * @return non-empty-string

     */
    protected function getFilteredPath(string $path): string
    {
        // Trim slashes from the beginning and end of the path
        if (! $path = trim($path, '/')) {
            // If the path only had a slash return as just slash
            return '/';
        }

        // Prepend a slash
        return '/' . $path;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Valkyrja Framework package.
7			*
8			* (c) Melech Mizrachi <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Valkyrja\Http\Routing\Data;
15
16			use Override;
			0 ignored issues – show Bug introduced 2025-07-10 03:52 UTC by Report Bug Copy Issue Report The type `Override` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
17			use Valkyrja\Dispatcher\Data\Contract\MethodDispatch;
18			use Valkyrja\Http\Message\Enum\RequestMethod;
			0 ignored issues – show Bug introduced 2025-06-18 18:28 UTC by Report Bug Copy Issue Report The type `Valkyrja\Http\Message\Enum\RequestMethod` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
19			use Valkyrja\Http\Middleware\Contract\RouteDispatchedMiddleware;
20			use Valkyrja\Http\Middleware\Contract\RouteMatchedMiddleware;
21			use Valkyrja\Http\Middleware\Contract\SendingResponseMiddleware;
22			use Valkyrja\Http\Middleware\Contract\TerminatedMiddleware;
23			use Valkyrja\Http\Middleware\Contract\ThrowableCaughtMiddleware;
24			use Valkyrja\Http\Routing\Data\Contract\Parameter;
			0 ignored issues – show Bug introduced 2025-06-18 16:47 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `Valkyrja\Http\Routing\Data\Parameter`. Consider defining an alias. Let?s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let?s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
25			use Valkyrja\Http\Routing\Data\Contract\Route as Contract;
26			use Valkyrja\Http\Struct\Request\Contract\RequestStruct;
27			use Valkyrja\Http\Struct\Response\Contract\ResponseStruct;
28
29			use function in_array;
30
31			/**
32			* Class Route.
33			*
34			* @author Melech Mizrachi
35			*/
36			class Route implements Contract
37			{

valkyrjaio / valkyrja

Route::withRouteDispatchedMiddleware() A last analyzed 2025-08-08 04:54 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Route::withRouteDispatchedMiddleware() A
last analyzed 2025-08-08 04:54 UTC