Gacela\Router\Router

Complexity

Total Complexity

9

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Test Coverage

Coverage

96.77%

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	findHandler()	0	4	1
A	handleException()	0	15	3
A	configure()	0	20	2
A	findRoute()	0	9	3

<?php

declare(strict_types=1);

namespace Gacela\Router;

use Closure;
use Exception;
use Gacela\Resolver\InstanceCreator;
use Gacela\Router\Entities\Route;
use Gacela\Router\Exceptions\NotFound404Exception;
use ReflectionException;
use ReflectionFunction;

use function get_class;
use function is_callable;

final class Router
{
    /**
     * @throws ReflectionException
     */
    public static function configure(Closure $fn): void
    {
        $routes = new Routes();
        $bindings = new Bindings();
        $handlers = new Handlers();

        $params = array_map(static fn ($param) => match ((string)$param->getType()) {
            Routes::class => $routes,
            Bindings::class => $bindings,
            Handlers::class => $handlers,
            default => null,
        }, (new ReflectionFunction($fn))->getParameters());

        $fn(...$params);

        try {
            echo self::findRoute($routes)
                ->run($bindings);
        } catch (Exception $exception) {
            echo self::handleException($handlers, $exception);
        }
    }

    private static function findRoute(Routes $routes): Route
    {
        foreach ($routes->getAllRoutes() as $route) {
            if ($route->requestMatches()) {
                return $route;
            }
        }

        throw new NotFound404Exception();
    }

    private static function handleException(Handlers $handlers, Exception $exception): string
    {
        $handler = self::findHandler($handlers, $exception);

        if (is_callable($handler)) {
            return $handler($exception);
        }

        $instance = (new InstanceCreator())->createByClassName($handler);

It seems like $handler can also be of type callable; however, parameter $className of Gacela\Resolver\InstanceCreator::createByClassName() does only seem to accept string, maybe add an additional type check?

        if (is_callable($instance)) {
            return $instance($exception);
        }

        return '';
    }

    /**
     * @return callable|class-string

The doc comment callable|class-string at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in callable|class-string.

     */
    private static function findHandler(Handlers $handlers, Exception $exception): string|callable
    {
        return $handlers->getAllHandlers()[get_class($exception)]
            ?? $handlers->getAllHandlers()[Exception::class];
    }
}