Router\Route

Complexity

Total Complexity

22

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	default()	0	3	1
A	post()	0	3	1
A	any()	0	4	1
A	route()	0	7	3
A	patch()	0	3	1
A	handle()	0	15	2
A	delete()	0	3	1
A	options()	0	3	1
A	__destruct()	0	10	3
A	put()	0	3	1
A	__construct()	0	3	1
A	match()	0	4	2
A	dispatch()	0	7	3
A	get()	0	3	1

<?php

namespace Router;

/**
 * Class Route
 * @package Router
 */
class Route
{
    /**
     * @var BaseRouter
     */
    private $router;

    private $status = false;

    /**
     * @var
     */
    private static $route;

    /**
     * @var null
     */
    private static $match = null;

    private static $defaultCallback = null;

    /**
     * Route constructor.
     */
    private function __construct()
    {
        $this->router = new BaseRouter();
    }

    public function __destruct()
    {
        if (!$this->status) {
            $callback = self::$defaultCallback;
            if (is_callable($callback)) {
                $callback();
            }
        }

        exit;

Using exit here is not recommended.

    }

    /**
     * @return Route
     */
    private static function route(): Route
    {
        if (!isset(self::$route) || is_null(self::$route)) {
            self::$route = new Route;
        }

        return self::$route;
    }

    /**
     * @return null|BaseRoute
     */
    private static function dispatch(): ?BaseRoute
    {
        if (!isset(self::$match) || is_null(self::$match)) {
            self::$match = self::route()->router->handle();

It seems like self::route()->router->handle() can also be of type Router\BaseRoute. However, the property $match is declared as type null. Maybe add an additional type check?

        }

        return self::$match;
    }

    /**
     * @param string $method
     * @param string $uri
     * @param $callback
     * @return void
     */
    private function handle(string $method, string $uri, $callback): void
    {
        $this->router->add([
            'uri' => $uri,
            'name' => '',
            'method' => $method,
            'callback' => $callback
        ]);

        $match = $this->dispatch();

        if ($match) {
            call_user_func_array($match->getCallback(), $match->getArgs());
            $this->status = true;
            exit;

Using exit here is not recommended.

        }
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function get(string $uri, $callback): void
    {
        self::route()->handle('get', $uri, $callback);
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function post(string $uri, $callback): void
    {
        self::route()->handle('post', $uri, $callback);
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function put(string $uri, $callback): void
    {
        self::route()->handle('put', $uri, $callback);
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function patch(string $uri, $callback): void
    {
        self::route()->handle('patch', $uri, $callback);
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function delete(string $uri, $callback): void
    {
        self::route()->handle('delete', $uri, $callback);
    }

    /**
     * @param string $uri
     * @param $callback
     */
    public static function options(string $uri, $callback): void
    {
        self::route()->handle('options', $uri, $callback);
    }

    public static function any(string $uri, $callback): void
    {
        $methods = ['get', 'post', 'put', 'patch', 'delete', 'options'];
        self::match($methods, $uri, $callback);
    }

    public static function match(array $methods, string $uri, $callback): void
    {
        foreach ($methods as $method) {
            self::route()->handle($method, $uri, $callback);
        }
    }

    public static function default($callback): void

Possible parse error: non-abstract method defined as abstract

It is generally advisable to only define one property per statement.

    {
        self::$defaultCallback = $callback;
    }
}