inroutephp\inroute\Runtime\Route

Complexity

Total Complexity

37

Size/Duplication

Total Lines	259
Duplicated Lines	0 %

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	hasAttribute()	0	3	1
A	getAnnotation()	0	3	1
A	hasAnnotation()	0	3	1
A	getAttributes()	0	3	1
A	setMiddlewareServiceIds()	0	3	1
A	withRoutable()	0	5	1
A	withMiddleware()	0	5	1
A	withAttribute()	0	5	1
A	isRoutable()	0	3	1
A	getWrappedAnnotations()	0	7	2
A	__construct()	0	13	3
A	withHttpMethod()	0	5	1
A	getName()	0	3	1
A	setServiceId()	0	3	1
A	setServiceMethod()	0	3	1
A	withPath()	0	5	1
A	getServiceId()	0	3	1
A	getHttpMethods()	0	3	1
A	withServiceId()	0	5	1
A	setHttpMethods()	0	3	1
A	getAnnotations()	0	3	1
A	withoutHttpMethod()	0	13	2
A	setName()	0	3	1
A	setAttribute()	0	3	1
A	setPath()	0	3	1
A	setRoutable()	0	3	1
A	getServiceMethod()	0	3	1
A	__sleep()	0	11	1
A	getAttribute()	0	3	1
A	getMiddlewareServiceIds()	0	3	1
A	withName()	0	5	1
A	getPath()	0	3	1
A	withServiceMethod()	0	5	1

<?php

declare(strict_types = 1);

namespace inroutephp\inroute\Runtime;

use inroutephp\inroute\Annotation\AnnotatedInterface;
use inroutephp\inroute\Exception\LogicException;

final class Route implements RouteInterface
{
    /**
     * @var AnnotatedInterface
     */
    private $annotations;

    /**
     * @var string
     */
    private $name = '';

    /**
     * @var bool
     */
    private $routable = false;

    /**
     * @var string[]
     */
    private $httpMethods = [];

    /**
     * @var string
     */
    private $path = '';

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

    /**
     * @var string
     */
    private $serviceId = '';

    /**
     * @var string
     */
    private $serviceMethod = '';

    /**
     * @var string[]
     */
    private $middlewareServiceIds = [];

    public function __construct(string $serviceId, string $serviceMethod, AnnotatedInterface $annotations)
    {
        if ($serviceId) {
            $this->name = $serviceId;
            $this->serviceId = $serviceId;
        }

        if ($serviceMethod) {
            $this->name .= ":$serviceMethod";
            $this->serviceMethod = $serviceMethod;
        }

        $this->annotations = $annotations;
    }

    public function __sleep(): array
    {
        return [
            'name',
            'routable',
            'httpMethods',
            'path',
            'attributes',
            'serviceId',
            'serviceMethod',
            'middlewareServiceIds',
        ];
    }

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

    public function withName(string $name): RouteInterface
    {
        $new = clone $this;
        $new->setName($name);
        return $new;
    }

    private function setName(string $name): void
    {
        $this->name = $name;
    }

    public function isRoutable(): bool
    {
        return $this->routable;
    }

    public function withRoutable(bool $routable): RouteInterface
    {
        $new = clone $this;
        $new->setRoutable($routable);
        return $new;
    }

    private function setRoutable(bool $routable): void
    {
        $this->routable = $routable;
    }

    public function getHttpMethods(): array
    {
        return array_values($this->httpMethods);
    }

    public function withHttpMethod(string $httpMethod): RouteInterface
    {
        $new = clone $this;
        $new->setHttpMethods(array_merge($this->httpMethods, [strtoupper($httpMethod)]));
        return $new;
    }

    public function withoutHttpMethod(string $httpMethod): RouteInterface
    {
        $new = clone $this;

        $id = array_search(strtoupper($httpMethod), $this->httpMethods);

        if (false !== $id) {
            $newHttpMethods = $this->httpMethods;
            unset($newHttpMethods[$id]);
            $new->setHttpMethods($newHttpMethods);
        }

        return $new;
    }

    private function setHttpMethods(array $httpMethods): void
    {
        $this->httpMethods = array_change_key_case($httpMethods, CASE_UPPER);
    }

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

    public function withPath(string $path): RouteInterface
    {
        $new = clone $this;
        $new->setPath($path);
        return $new;
    }

    private function setPath(string $path): void
    {
        $this->path = $path;
    }

    public function hasAttribute(string $name): bool
    {
        return isset($this->attributes[$name]);
    }

    public function getAttribute(string $name)
    {
        return $this->attributes[$name] ?? null;
    }

    public function getAttributes(): array
    {
        return $this->attributes;
    }

    public function withAttribute(string $name, $value): RouteInterface
    {
        $new = clone $this;
        $new->setAttribute($name, $value);
        return $new;
    }

    private function setAttribute(string $name, $value): void
    {
        $this->attributes[$name] = $value;
    }

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

    public function withServiceId(string $serviceId): RouteInterface
    {
        $new = clone $this;
        $new->setServiceId($serviceId);
        return $new;
    }

    private function setServiceId(string $serviceId): void
    {
        $this->serviceId = $serviceId;
    }

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

    public function withServiceMethod(string $serviceMethod): RouteInterface
    {
        $new = clone $this;
        $new->setServiceMethod($serviceMethod);
        return $new;
    }

    private function setServiceMethod(string $serviceMethod): void
    {
        $this->serviceMethod = $serviceMethod;
    }

    public function getMiddlewareServiceIds(): array
    {
        return $this->middlewareServiceIds;
    }

    public function withMiddleware(string $serviceId): RouteInterface
    {
        $new = clone $this;
        $new->setMiddlewareServiceIds(array_merge($this->middlewareServiceIds, [$serviceId]));
        return $new;
    }

    private function setMiddlewareServiceIds(array $serviceIds): void
    {
        $this->middlewareServiceIds = $serviceIds;
    }

    public function hasAnnotation(string $annotationId): bool
    {
        return $this->getWrappedAnnotations()->hasAnnotation($annotationId);
    }

    public function getAnnotation(string $annotationId)
    {
        return $this->getWrappedAnnotations()->getAnnotation($annotationId);
    }

    public function getAnnotations(string $annotationId = ''): array
    {
        return $this->getWrappedAnnotations()->getAnnotations($annotationId);
    }

    private function getWrappedAnnotations(): AnnotatedInterface
    {
        if (!isset($this->annotations)) {
            throw new LogicException('Unserialized route does not contain annotations');
        }

        return $this->annotations;
    }
}