Gorynych\Http\Routing\Router

Complexity

Total Complexity

11

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

97.62%

Importance

Changes	4
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	filterOperationsByUri()	0	15	2
A	filterOperationsByMethod()	0	15	2
A	__construct()	0	3	1
A	resolveResourceIdentity()	0	13	2
A	findOperation()	0	23	4

<?php
/**
 * Copyright (c) 2020.
 * @author Paweł Antosiak <contact@pawelantosiak.com>
 */

declare(strict_types=1);

namespace Gorynych\Http\Routing;

use Cake\Collection\Collection;
use Gorynych\Http\Exception\MethodNotAllowedHttpException;
use Gorynych\Http\Exception\NotFoundHttpException;
use Gorynych\Operation\ResourceOperationInterface;
use Gorynych\Resource\AbstractResource;
use Gorynych\Resource\ResourceLoader;
use Symfony\Component\HttpFoundation\Request;

final class Router
{
    private ResourceLoader $resourceLoader;
    private ?Request $request;

    public function __construct(ResourceLoader $resourceLoader)
    {
        $this->resourceLoader = $resourceLoader;
    }

    /**
     * Finds resource operation able to process given request
     *
     * @param Request $request
     * @return ResourceOperationInterface
     * @throws NotFoundHttpException if there is no proper operation mapped to any resource
     */
    public function findOperation(Request $request): ResourceOperationInterface
    {
        $this->request = $request;
        $resource = $operation = null;

        foreach ($this->resourceLoader->getResources() as $resourceClass) {
            try {
                $resource = $this->resourceLoader->loadResource($resourceClass);
                $operation = $this->filterOperationsByMethod($this->filterOperationsByUri($resource));

                break;
            } catch (NotFoundHttpException $e) {
                continue;
            }
        }

        if (!$operation instanceof ResourceOperationInterface) {
            throw new NotFoundHttpException();
        }

        $this->resolveResourceIdentity($resource, $operation);

It seems like $resource can also be of type null; however, parameter $resource of Gorynych\Http\Routing\Router::resolveResourceIdentity() does only seem to accept Gorynych\Resource\AbstractResource, maybe add an additional type check?

        return $operation;
    }

    /**
     * Returns resource operations matching request URI
     *
     * @param AbstractResource $resource
     * @return Collection
     * @throws NotFoundHttpException if even one operation does not match URI pattern
     */
    private function filterOperationsByUri(AbstractResource $resource): Collection
    {
        $request = $this->request;

        $operations = $resource->getOperations()->filter(
            static function (ResourceOperationInterface $operation) use ($request, $resource): bool {
                return UriMatcher::matchUri($request->getPathInfo(), $resource->getPath(), $operation->getPath());

The method getPathInfo() does not exist on null.

            }
        );

        if (true === $operations->isEmpty()) {
            throw new NotFoundHttpException();
        }

        return $operations;
    }

    /**
     * Returns resource operation matching request HTTP method
     *
     * @param Collection $operations matching request URI
     * @return ResourceOperationInterface
     * @throws MethodNotAllowedHttpException if method does not match the method of any available operations
     */
    private function filterOperationsByMethod(Collection $operations): ResourceOperationInterface
    {
        $method = $this->request->getMethod();

The method getMethod() does not exist on null.

        $operations = $operations->filter(
            static function (ResourceOperationInterface $operation) use ($method): bool {
                return $method === $operation->getMethod();
            }
        );

        if (true === $operations->isEmpty()) {
            throw new MethodNotAllowedHttpException();
        }

        return $operations->first();

The expression return $operations->first() could return the type null which is incompatible with the type-hinted return Gorynych\Operation\ResourceOperationInterface. Consider adding an additional type-check to rule them out.

    }

    /**
     * Resolves identity of the resource
     */
    private function resolveResourceIdentity(AbstractResource $resource, ResourceOperationInterface $operation): void
    {
        UriMatcher::matchUri(
            $this->request->getPathInfo(),
            $resource->getPath(),
            $operation->getPath(),
            $matches
        );

        $resource->id = $matches['id'] ?? null;

        if (true === property_exists($resource, 'subId')) {
            $resource->subId = $matches['subId'] ?? null;
        }
    }
}