Core\Router

Complexity

Total Complexity

23

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	4
Bugs	1	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getInstance()	0	8	2
A	prefix()	0	11	2
A	add()	0	4	1
A	get()	0	4	1
A	post()	0	4	1
A	put()	0	4	1
B	setMethod()	0	23	4
B	getParams()	0	24	3
A	includeRoutes()	0	8	2
A	init()	0	10	2
A	getCollection()	0	4	1
A	group()	0	7	2

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 14 and the first side effect is on line 197.

namespace Core;

use Core\Exceptions\ExceptionHandler;
use Exception;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\Matcher\UrlMatcher;
use Symfony\Component\Routing\RequestContext;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

class Router
{
    public $routeColletion;
    private $prefix = '';
    private static $instance = null;
    private $middlewares = [];

    private function __construct()
    {
        $this->routeColletion = new RouteCollection();
    }

    public static function getInstance()
    {
        if (!self::$instance instanceof self) {
            self::$instance = new self();
        }

        return self::$instance;
    }

    /**
     * @param $prefixParam
     * @param $callable
     *
     * @throws \ErrorException
     */
    public function prefix($prefixParam, $callable)
    {
        if (!is_callable($callable)) {
            throw new \ErrorException('O segundo parâmetro não é executável');
        }

        $oldPrefix = $this->prefix;
        $this->prefix .= $prefixParam;
        $callable($this);
        $this->prefix = $oldPrefix;
    }

    /**
     * @param       $path
     * @param       $controller
     * @param array $params
     */
    public function add($path, $controller, $params = [])
    {
        $this->setMethod(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'PATCH'], $path, $controller, $params);
    }

    /**
     * @param       $path
     * @param       $controller
     * @param array $params
     */
    public function get($path, $controller, $params = [])
    {
        $this->setMethod('GET', $path, $controller, $params);
    }

    /**
     * @param       $path
     * @param       $controller
     * @param array $params
     */
    public function post($path, $controller, $params = [])
    {
        $this->setMethod('POST', $path, $controller, $params);
    }

    /**
     * @param       $path
     * @param       $controller
     * @param array $params
     */
    public function put($path, $controller, $params = [])
    {
        $this->setMethod('PUT', $path, $controller, $params);
    }

    /**
     * @param       $httpMethod
     * @param       $path
     * @param       $controller
     * @param array $params
     */
    private function setMethod($httpMethod, $path, $controller, $params = [])
    {
        if (!is_array($httpMethod)) {
            $httpMethod = [$httpMethod];
        }

        list($controller, $method) = explode('::', $controller);
        $prefixedPath = $this->prefix.$path;

        $configsParams = array_merge([
            '_path'       => $path,
            '_controller' => $controller,
            '_method'     => $method,
        ], $params);

        if (is_array($this->middlewares) && count($this->middlewares) > 0) {
            $configsParams['_middleware'] = $this->middlewares;
        }

        $route = new Route($prefixedPath, $configsParams);
        $route->setMethods($httpMethod);
        $this->routeColletion->add(implode('', $httpMethod).$prefixedPath, $route);
    }

    /**
     * @return array
     */
    public static function getParams()

getParams uses the super-global variable $_SERVER which is generally not recommended.

    {
        static::includeRoutes();

Since includeRoutes() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of includeRoutes() to at least protected.

        $parameters = null;
        $context = new RequestContext();
        $context->fromRequest(Request::createFromGlobals());
        $matcher = new UrlMatcher(self::getInstance()->routeColletion, $context);

        try {
            $parameters = $matcher->match(Request::createFromGlobals()->getPathInfo());
        } catch (ResourceNotFoundException $e) {
            $parameters = [
                '_path'       => $_SERVER['REQUEST_URI'],
                '_controller' => 'HomeController',
                '_method'     => '_404',
                '_route'      => 'GETPOSTPUTPATCHDELETEPATCH/',
            ];
        } catch (Exception $e) {
            new ExceptionHandler($e);
        }

        return $parameters;
    }

    private static function includeRoutes()
    {
        static $included = false;
        if (!$included) {
            require ROOT_APP.'routes.php';
            $included = true;
        }
    }

    /**
     * @return bool
     */
    public static function init()
    {
        static $init = false;
        if (!$init) {
            self::includeRoutes();
            $init = true;
        }

        return $init;
    }

    /**
     * Return router collection.
     *
     * @return RouteCollection
     */
    public function getCollection()
    {
        return $this->routeColletion;
    }

    /**
     * @param $params
     * @param $closure
     */
    public function group($params, $closure)
    {
        $oldMiddlewares = $this->middlewares;
        $this->middlewares = array_merge($this->middlewares, isset($params['middleware']) ? $params['middleware'] : []);
        $closure($this);
        $this->middlewares = $oldMiddlewares;
    }
}

Router::init();