Na}{

File Content: `Route.php`

<?php

declare (strict_types=1);
namespace PleskGrafana\Mezzio\Router;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use function array_map;
use function array_reduce;
use function implode;
use function in_array;
use function is_array;
use function is_string;
use function preg_match;
use function strtoupper;
/**
 * Value object representing a single route.
 *
 * Routes are a combination of path, middleware, and HTTP methods; two routes
 * representing the same path and overlapping HTTP methods are not allowed,
 * while two routes representing the same path and non-overlapping HTTP methods
 * can be used (and should typically resolve to different middleware).
 *
 * Internally, only those three properties are required. However, underlying
 * router implementations may allow or require additional information, such as
 * information defining how to generate a URL from the given route, qualifiers
 * for how segments of a route match, or even default values to use. These may
 * be provided after instantiation via the "options" property and related
 * setOptions() method.
 *
 * @final
 */
class Route implements MiddlewareInterface
{
    public const HTTP_METHOD_ANY = null;
    public const HTTP_METHOD_SEPARATOR = ':';
    /** @var null|list<string> HTTP methods allowed with this route. */
    private ?array $methods;
    /** @var array Options related to this route to pass to the routing implementation. */
    private array $options = [];
    /** @var non-empty-string */
    private string $name;
    /**
     * @param non-empty-string    $path Path to match.
     * @param MiddlewareInterface $middleware Middleware to use when this route is matched.
     * @param null|list<string>   $methods Allowed HTTP methods; defaults to HTTP_METHOD_ANY.
     * @param null|string         $name the route name
     */
    public function __construct(private string $path, private MiddlewareInterface $middleware, ?array $methods = self::HTTP_METHOD_ANY, ?string $name = null)
    {
        $this->methods = is_array($methods) ? $this->validateHttpMethods($methods) : $methods;
        if ($name === null || $name === '') {
            $name = $this->methods === self::HTTP_METHOD_ANY ? $path : $path . '^' . implode(self::HTTP_METHOD_SEPARATOR, $this->methods);
        }
        $this->name = $name;
    }
    /**
     * Proxies to the middleware composed during instantiation.
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface
    {
        return $this->middleware->process($request, $handler);
    }
    /** @return non-empty-string */
    public function getPath() : string
    {
        return $this->path;
    }
    /**
     * Set the route name.
     *
     * @param non-empty-string $name
     */
    public function setName(string $name) : void
    {
        $this->name = $name;
    }
    /** @return non-empty-string */
    public function getName() : string
    {
        return $this->name;
    }
    public function getMiddleware() : MiddlewareInterface
    {
        return $this->middleware;
    }
    /**
     * @return null|list<string> Returns HTTP_METHOD_ANY or array of allowed methods.
     */
    public function getAllowedMethods() : ?array
    {
        return $this->methods;
    }
    /**
     * Indicate whether the specified method is allowed by the route.
     *
     * @param string $method HTTP method to test.
     */
    public function allowsMethod(string $method) : bool
    {
        $method = strtoupper($method);
        return $this->allowsAnyMethod() || in_array($method, $this->methods ?? [], \true);
    }
    /**
     * Indicate whether any method is allowed by the route.
     */
    public function allowsAnyMethod() : bool
    {
        return $this->methods === self::HTTP_METHOD_ANY;
    }
    public function setOptions(array $options) : void
    {
        $this->options = $options;
    }
    public function getOptions() : array
    {
        return $this->options;
    }
    /**
     * Validate the provided HTTP method names.
     *
     * Validates, and then normalizes to upper case.
     *
     * @param list<string> $methods An array of HTTP method names.
     * @return list<string>
     * @throws Exception\InvalidArgumentException For any invalid method names.
     */
    private function validateHttpMethods(array $methods) : array
    {
        if (empty($methods)) {
            throw new Exception\InvalidArgumentException('HTTP methods argument was empty; must contain at least one method');
        }
        if (\false === array_reduce($methods, function ($valid, $method) {
            if (\false === $valid) {
                return \false;
            }
            if (!is_string($method)) {
                return \false;
            }
            if (!preg_match('/^[!#$%&\'*+.^_`\\|~0-9a-z-]+$/i', $method)) {
                return \false;
            }
            return $valid;
        }, \true)) {
            throw new Exception\InvalidArgumentException('One or more HTTP methods were invalid');
        }
        return array_map('strtoupper', $methods);
    }
}
Name	Size	Permission
Exception	---	0755
Middleware	---	0755
Response	---	0755
Stream	---	0755
Test	---	0755
ConfigProvider.php	1137 bytes	0644
DuplicateRouteDetector.php	3198 bytes	0644
Route.php	5255 bytes	0644
RouteCollector.php	3354 bytes	0644
RouteCollectorFactory.php	1714 bytes	0644
RouteCollectorInterface.php	2774 bytes	0644
RouteResult.php	5151 bytes	0644
RouterInterface.php	1926 bytes	0644
File Content: Route.php

File Content: `Route.php`
