Vertex\Core\Router

Complexity

Total Complexity

11

Size/Duplication

Total Lines	107
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	4
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	dispatch()	0	16	4
A	info()	0	4	1
A	found()	0	12	2
A	handle()	0	6	2
A	error()	0	8	1

<?php

namespace Vertex\Core; 

use \FastRoute\Dispatcher;

class Router   
{ 

The opening class brace should be on a newline by itself.

    /**
     * Placeholder for the dispatcher class.
     * 
     * @var object
     */
    private $dispatcher;

    /**
     * Main controller namespace.
     * 
     * @var string
     */
    private $namespace = 'Vertex\\Controller\\';

    /**
     * Create a new router.
     *
     * @var \FastRoute\simpleDispatcher
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($dispatcher)
    {
        $this->dispatcher = $dispatcher;
    }

    /**
     * Dispatch the route.
     *
     * @return void
     */
    public function dispatch()
    {
        $routeInfo = $this->info();

        switch ($routeInfo[0]) {
            case Dispatcher::NOT_FOUND:
                echo $this->error('404', 'Page Could Not Be Found');
                break;
            case Dispatcher::METHOD_NOT_ALLOWED:
                echo $this->error('405', 'Method is not allowed');
                break;
            case Dispatcher::FOUND:
                echo $this->found($routeInfo[1], $routeInfo[2]);
                break;
        }
    }

    /**
     * Returns the current route information.
     * 
     * @return array
     */
    public function info()
    {
        return $this->dispatcher->dispatch($_SERVER['REQUEST_METHOD'], strtok($_SERVER['REQUEST_URI'], '?'));
    }

    /**
     * Check if a route was found.
     * 
     * @param  string $handler    
     * @param  array $parameters 
     */
    private function found($handler, $parameters)
    {
        /* its a closure */
        if (is_callable($handler)) {
            return $this->handle($handler, $parameters);
        }

        /* its a class */
        list($class, $method) = explode("@", $handler, 2);
        $class = $this->namespace . $class;
        return $this->handle([new $class, $method], $parameters);        
    }

    /**
     * Handle the callback.
     * 
     * @param  string $callback   
     * @param  array $parameters 
     */
    public function handle($callback, ...$parameters)
    {
        $callback = call_user_func_array($callback, ...$parameters);
        
        echo (is_array($callback)) ? json_encode($callback) : $callback;
    }

    /**
     * Error responce.
     * 
     * @param  string $type        
     * @param  string $description 
     */
    private function error($type, $description)
    {
        return View::render('errors.request', [
            'title' => $type,
            'error_number' => $type,
            'error_message' => $description
        ]);        
    }
}