Route::methods() - Code Metrics - Inspection of "Created RouteNotFoundException (#12)" - yiisoft/router - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 72a17c...7e1b76 )

by Alexander
created 2019-11-28 22:53 UTC
Route::methods() A

↳ Parent: Route
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	6
ccs	0
cts	0
cp	0
rs	10
cc	1
nc	1
nop	2
crap	2
<?php

namespace Yiisoft\Router;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

/**
 * Route defines a mapping from URL to callback / name and vice versa
 */
class Route implements MiddlewareInterface
{
    /**
     * @var string
     */
    private $name;

    /**
     * @var array
     */
    private $methods;

    /**
     * @var string
     */
    private $pattern;

    /**
     * @var string
     */
    private $host;

    /**
     * @var MiddlewareInterface
     */
    private $middleware;

    /**
     * @var array
     */
    private $parameters = [];

    /**
     * @var array
     */
    private $defaults = [];

    private function __construct()
    {
    }

    public static function get(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::GET];
        $route->pattern = $pattern;
        return $route;
    }

    public static function post(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::POST];
        $route->pattern = $pattern;
        return $route;
    }

    public static function put(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::PUT];
        $route->pattern = $pattern;
        return $route;
    }

    public static function delete(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::DELETE];
        $route->pattern = $pattern;
        return $route;
    }

    public static function patch(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::PATCH];
        $route->pattern = $pattern;
        return $route;
    }

    public static function head(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::HEAD];
        $route->pattern = $pattern;
        return $route;
    }

    public static function options(string $pattern): self
    {
        $route = new static();
        $route->methods = [Method::OPTIONS];
        $route->pattern = $pattern;
        return $route;
    }

    public static function methods(array $methods, string $pattern): self
    {
        $route = new static();
        $route->methods = $methods;
        $route->pattern = $pattern;
        return $route;
    }

    public static function anyMethod(string $pattern): self
    {
        $route = new static();
        $route->methods = Method::ANY;
        $route->pattern = $pattern;
        return $route;
    }

    public function name(string $name): self
    {
        $route = clone $this;
        $route->name = $name;
        return $route;
    }

    public function host(string $host): self
    {
        $route = clone $this;
        $route->host = rtrim($host, '/');
        return $route;
    }

    /**
     * Parameter validation rules indexed by parameter names
     *
     * @param array $parameters
     * @return Route
     */
    public function parameters(array $parameters): self
    {
        $route = clone $this;
        $route->parameters = $parameters;
        return $route;
    }

    /**
     * Parameter default values indexed by parameter names
     *
     * @param array $defaults
     * @return Route
     */
    public function defaults(array $defaults): self
    {
        $route = clone $this;
        $route->defaults = $defaults;
        return $route;
    }

    /**
     * Speicifes a handler that should be invoked for a matching route.
     * It can be either a PSR middleware or a callable with the following signature:
     *
     * ```
     * function (ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface {
     * ```
     *
     * @param MiddlewareInterface|callable $middleware
     * @return Route
     */
    public function to($middleware): self
    {
        $route = clone $this;
        if (\is_callable($middleware)) {
            $middleware = $this->wrapCallable($middleware);
            $middleware = $this->wrapCallable(/** @scrutinizer ignore-type */ $middleware);
        }

        if (!$middleware instanceof MiddlewareInterface) {
            throw new \InvalidArgumentException('Parameter should be either a PSR middleware or a callable.');
        }

        $route->middleware = $middleware;
        return $route;
    }

    private function wrapCallable(callable $callback): MiddlewareInterface
    {
        return new class($callback) implements MiddlewareInterface {
            private $callback;

            public function __construct(callable $callback)
            {
                $this->callback = $callback;
            }

            public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
            {
                return \call_user_func($this->callback, $request, $handler);
            }
        };
    }

    public function __toString()
    {
        $result = '';

        if ($this->name !== null) {
            $result .= '[' . $this->name . '] ';
        }

        if ($this->methods !== null) {
            $result .= implode(',', $this->methods) . ' ';
        }
        if ($this->host !== null && strrpos($this->pattern, $this->host) === false) {
            $result .= $this->host;
        }
        $result .= $this->pattern;

        return $result;
    }

    public function getName(): string
    {
        return $this->name ?? implode(', ', $this->methods) . ' ' . $this->pattern;
    }

    public function getMethods(): array
    {
        return $this->methods;
    }

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

    public function getHost(): ?string
    {
        return $this->host;
    }

    public function getParameters(): array
    {
        return $this->parameters;
    }

    public function getDefaults(): array
    {
        return $this->defaults;
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        return $this->middleware->process($request, $handler);
    }
}

yiisoft / router

Push — master ( 72a17c...7e1b76 )

Route::methods() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
