Route::dispatch() - Code Metrics - BonfimLabs/PHP-HTTP-Router - Measure and Improve Code Quality continuously with Scrutinizer

Route::dispatch() A
last analyzed 2019-09-06 03:08 UTC

↳ Parent: Route

Complexity

Conditions	3
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
cc	3
eloc	3
nc	2
nop	0
dl	0
loc	7
ccs	0
cts	6
cp	0
crap	12
rs	10
c	0
b	0
f	0

<?php

namespace Bonfim\Router;

use ReflectionException;
use ReflectionFunction;

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

    /**
     * @var bool
     */
    private $status = false;


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

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


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

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

        return self::$route;
    }

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

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        }

        return self::$match;
    }

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

        $match = $this->dispatch();

        $args = [];

        if ($match) {

            if (is_array($callback)) {
                $reflect = new \ReflectionMethod($callback[0], $callback[1]);
            } else {
                $reflect = new ReflectionFunction();
                $reflect = /** @scrutinizer ignore-call */ new ReflectionFunction();
            }

            foreach ($reflect->getParameters() as $i => $param) {
                // Caso o parametro seja tipado
                if ($param->hasType()) {
                    // Adiciona o objecto Request nos parametros da classe
                    if ($param->getType()->getName() == Request::class) {
                        $args[$i] = new Request();
                    }

                    // Adiciona o objeto Response nos parametros da classe
                    if ($param->getType()->getName() == Response::class) {
                        $args[$i] = new Response();
                    }
                } else {
                    //Adiciona o restante dos parametros nao tipados
                    $args[$i] = $match->getArg($param->getName());
                }
            }

            call_user_func_array($match->getCallback(), $args);
            exit;

        }
    }

    /**
     * @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);
    }

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

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


BonfimLabs / PHP-HTTP-Router

Route::dispatch() A last analyzed 2019-09-06 03:08 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Route::dispatch() A
last analyzed 2019-09-06 03:08 UTC