Suricate\Router

Complexity

Total Complexity

23

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

12.77%

Importance

Changes	11
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getResponse()	0	4	1
A	__construct()	0	9	1
A	configure()	0	11	4
B	buildRoute()	0	25	5
B	buildRestRoutes()	0	26	2
A	parseRequest()	0	5	1
A	addRoute()	0	13	2
A	addMiddleware()	0	6	1
A	getMiddlewares()	0	4	1
B	doRouting()	0	24	5

<?php
namespace Suricate;

/**
// TODO : handle closure
**/
class Router extends Service
{
    private $requestUri;
    private $baseUri;
    private $routes;
    private $response;
    private $appMiddlewares = array(
        '\Suricate\Middleware\CheckMaintenance',
        );



    public function __construct()
    {
        $this->routes   = array();
        $this->response = Suricate::Response();
        $this->parseRequest();

        // Get app base URI, to transform real path before passing to route
        $this->baseUri = Suricate::App()->getParameter('base_uri');
    }

    public function configure($parameters = array())
    {

        foreach ($parameters as $routeName => $routeData) {
            if (isset($routeData['isRest']) && $routeData['isRest']) {
                $this->buildRestRoutes($routeName, $routeData);
            } else {
                $this->buildRoute($routeName, $routeData);
            }
        }
    }

    private function buildRoute($routeName, $routeData) {
        if (isset($routeData['target'])) {
            $routeTarget = explode('::', $routeData['target']);
        } else {
            $routeTarget = null;
        }
        $routeMethod    = isset($routeData['method']) ? $routeData['method'] : 'any';
        $parameters     = isset($routeData['parameters']) ? $routeData['parameters'] : array();
        

        if (isset($routeData['middleware'])) {
            $middleware = (array)$routeData['middleware'];
        } else {
            $middleware = array(); 
        }

        $this->addRoute(
            $routeName,
            $routeMethod,
            $routeData['path'],
            $routeTarget,
            $parameters,
            $middleware
        );
    }

    private function buildRestRoutes($routeBaseName, $routeBaseData)
    {
        $resources = array(
            'index'     => array('method' => 'GET', 'append' => ''),
            'create'    => array('method' => 'GET', 'append' => '/create'),
            'store'     => array('method' => 'POST', 'append' => ''),
            'show'      => array('method' => 'GET', 'append' => '/:id'),
            'edit'      => array('method' => 'GET', 'append' => '/:id/edit'),
            'update'    => array('method' => 'PUT', 'append' => '/:id'),
            'destroy'   => array('method' => 'DELETE', 'append' => '/:id'),
            );

        foreach ($resources as $name => $definition) {
            $routeName = $routeBaseName . '.' . $name;
            $routeData = $routeBaseData;
            $routeData['method'] = $definition['method'];
            $routeData['path'] .= $definition['append'];
            $routeData['target'] .= '::' . $name;
            $routeData['parameters'] = array_merge(
                array('id' => '[0-9]*'),
                dataGet($routeBaseData, 'parameters', array())
                );

            $this->buildRoute($routeName, $routeData);
        }
    }

    private function parseRequest()
    {
        $this->requestUri = Suricate::Request()->getRequestUri();
        $this->response->setRequestUri($this->requestUri);
    }

    public function addRoute($routeName, $routeMethod, $routePath, $routeTarget, $parametersDefinitions, $middleware = null)
    {
        $computedRoutePath = ($this->baseUri != '/') ? $this->baseUri . $routePath : $routePath;
        $this->routes[$routeName] = new Route(
            $routeName,
            $routeMethod,
            $computedRoutePath,
            Suricate::Request(),
            $routeTarget,
            $parametersDefinitions,
            $middleware
        );
    }

    public function addMiddleware($middleware)
    {
        array_unshift($this->appMiddlewares, $middleware);

        return $this;
    }

    public function getMiddlewares()
    {
        return $this->appMiddlewares;
    }

    public function getResponse()
    {
        return $this->response;
    }
    /**
     * Loop through each defined routes, to find good one
     * @return null
     */
    public function doRouting()
    {
        $hasRoute = false;

        foreach ($this->routes as $route) {
            if ($route->isMatched) {
                $hasRoute = true;

                Suricate::Logger()->debug('Route "' . $route->getPath() . '" matched, target: ' . json_encode($route->target));
                $result = $route->dispatch($this->response, $this->appMiddlewares);
                if ($result === false) {
                    break;
                }
            }
        }

        // No route matched
        if (!$hasRoute) {
            Suricate::Logger()->debug('No route found');
            app()->abort('404');
        }

        $this->response->write();
    }
}