Quantum\Router\Route

Complexity

Total Complexity

42

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	name()	0	23	8
A	getVirtualRoutes()	0	3	1
A	getRuntimeRoutes()	0	9	3
A	assignMiddlewaresToRoute()	0	9	3
B	cacheable()	0	35	9
A	group()	0	11	1
A	__construct()	0	6	1
A	assignCacheToCurrentRoute()	0	5	1
A	middlewares()	0	24	4
A	get()	0	3	1
A	add()	0	33	5
A	canSetCacheToCurrentRoute()	0	6	4
A	post()	0	3	1

<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <arman.ag@softberg.org>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.9.0
 */

namespace Quantum\Router;

use Quantum\Libraries\ResourceCache\ViewCache;
use Quantum\Exceptions\DatabaseException;
use Quantum\Exceptions\SessionException;
use Quantum\Exceptions\ConfigException;
use Quantum\Exceptions\RouteException;
use Quantum\Exceptions\LangException;
use Quantum\Exceptions\DiException;
use ReflectionException;
use Closure;

/**
 * Route Class
 * @package Quantum\Router
 */
class Route
{

    /**
     * Current module name
     * @var string
     */
    private $moduleName;

    /**
     * Module options
     * @var array
     */
    private $moduleOptions = [];

    /**
     * Identifies the group middleware
     * @var bool
     */
    private $isGroupMiddlewares;

    /**
     * Identifies the group
     * @var boolean
     */
    private $isGroup = false;

    /**
     * Current group name
     * @var string
     */
    private $currentGroupName = null;

    /**
     * Current route
     * @var array
     */
    private $currentRoute = [];

    /**
     * Virtual routes
     * @var array
     */
    private $virtualRoutes = [];

	/**
	 * @var ViewCache
	 */
	private $viewCacheInstance;

	/**
	 * @param array $module
	 */
    public function __construct(array $module)
    {
        $this->virtualRoutes['*'] = [];
        $this->moduleName = key($module);
        $this->moduleOptions = $module[key($module)];
		$this->viewCacheInstance = ViewCache::getInstance();
    }

	/**
	 * @param string $route
	 * @param string $method
	 * @param ...$params
	 * @return $this
	 * @throws ConfigException
	 * @throws DatabaseException
	 * @throws DiException
	 * @throws LangException
	 * @throws ReflectionException
	 * @throws SessionException
	 */
    public function add(string $route, string $method, ...$params): Route
    {
        $this->currentRoute = [
            'route' => !empty($this->moduleOptions['prefix']) ? $this->moduleOptions['prefix'] . '/' . $route : $route,
            'prefix' => $this->moduleOptions['prefix'],
            'method' => $method,
            'module' => $this->moduleName
        ];

	    if ($this->canSetCacheToCurrentRoute()){
		    $this->currentRoute['cache_settings'] = [
			    'shouldCache' => true,
			    'ttl' => $this->viewCacheInstance->getTtl(),
		    ];
	    }

        if (is_callable($params[0])) {
            $this->currentRoute['callback'] = $params[0];
        } else {
            $this->currentRoute['controller'] = $params[0];
            $this->currentRoute['action'] = $params[1];
        }

        if ($this->currentGroupName) {
            $this->currentRoute['group'] = $this->currentGroupName;
            $this->virtualRoutes[$this->currentGroupName][] = $this->currentRoute;
        } else {
            $this->isGroup = false;
            $this->isGroupMiddlewares = false;
            $this->virtualRoutes['*'][] = $this->currentRoute;
        }

        return $this;
    }

	/**
	 * @param string $route
	 * @param ...$params
	 * @return $this
	 * @throws ConfigException
	 * @throws DatabaseException
	 * @throws DiException
	 * @throws LangException
	 * @throws ReflectionException
	 * @throws SessionException
	 */
    public function get(string $route, ...$params): Route
    {
        return $this->add($route, 'GET', ...$params);
    }

	/**
	 * @param string $route
	 * @param ...$params
	 * @return $this
	 * @throws ConfigException
	 * @throws DatabaseException
	 * @throws DiException
	 * @throws LangException
	 * @throws ReflectionException
	 * @throws SessionException
	 */
    public function post(string $route, ...$params): Route
    {
        return $this->add($route, 'POST', ...$params);
    }

    /**
     * Starts a named group of routes
     * @param string $groupName
     * @param Closure $callback
     * @return Route
     */
    public function group(string $groupName, Closure $callback): Route
    {
        $this->currentGroupName = $groupName;

        $this->isGroup = true;
        $this->isGroupMiddlewares = false;
        $callback($this);
        $this->isGroupMiddlewares = true;
        $this->currentGroupName = null;

        return $this;
    }

    /**
     * Adds middlewares to routes and route groups
     * @param array $middlewares
     * @return Route
     */
    public function middlewares(array $middlewares = []): Route
    {
        if (!$this->isGroup) {
            end($this->virtualRoutes['*']);
            $lastKey = key($this->virtualRoutes['*']);
            $this->assignMiddlewaresToRoute($this->virtualRoutes['*'][$lastKey], $middlewares);
            return $this;
        }

        end($this->virtualRoutes);
        $lastKeyOfFirstRound = key($this->virtualRoutes);

        if (!$this->isGroupMiddlewares) {
            end($this->virtualRoutes[$lastKeyOfFirstRound]);
            $lastKeyOfSecondRound = key($this->virtualRoutes[$lastKeyOfFirstRound]);
            $this->assignMiddlewaresToRoute($this->virtualRoutes[$lastKeyOfFirstRound][$lastKeyOfSecondRound], $middlewares);
            return $this;
        }

        foreach ($this->virtualRoutes[$lastKeyOfFirstRound] as &$route) {
            $this->assignMiddlewaresToRoute($route, $middlewares);
        }

        return $this;
    }

	/**
	 * @param bool $shouldCache
	 * @param int|null $ttl
	 * @return $this
	 * @throws ConfigException
	 * @throws DatabaseException
	 * @throws DiException
	 * @throws LangException
	 * @throws ReflectionException
	 * @throws SessionException
	 */
	public function cacheable(bool $shouldCache, int $ttl = null): Route
	{
		if (empty(session()->getId())){
			return $this;
		}

		if (!$ttl) {

The expression $ttl of type integer|null is loosely compared to false; this is ambiguous if the integer can be 0. You might want to explicitly use === null instead.

			$ttl = $this->viewCacheInstance->getTtl();
		}

		if (!$this->isGroup){
			end($this->virtualRoutes['*']);
			$lastKey = key($this->virtualRoutes['*']);

			if (!$shouldCache && key_exists('cache_settings', $this->virtualRoutes['*'][$lastKey])) {
				unset($this->virtualRoutes['*'][$lastKey]['cache_settings']);
			}else{
				$this->assignCacheToCurrentRoute($this->virtualRoutes['*'][$lastKey], $shouldCache, $ttl);
			}

			return $this;
		}

		end($this->virtualRoutes);
		$lastKeyOfFirstRound = key($this->virtualRoutes);

		foreach ($this->virtualRoutes[$lastKeyOfFirstRound] as &$route) {
			if (!$shouldCache && key_exists('cache_settings', $route)) {
				unset($route['cache_settings']);
			}else{
				$this->assignCacheToCurrentRoute($route, $shouldCache, $ttl);
			}
		}

		return $this;
	}

    /**
     * Sets a unique name for a route
     * @param string $name
     * @return Route
     * @throws RouteException
     */
    public function name(string $name): Route
    {
        if (empty($this->currentRoute)) {
            throw RouteException::nameBeforeDefinition();
        }

        if ($this->isGroupMiddlewares) {
            throw RouteException::nameOnGroup();
        }

        foreach ($this->virtualRoutes as &$virtualRoute) {
            foreach ($virtualRoute as &$route) {
                if (isset($route['name']) && $route['name'] == $name) {
                    throw RouteException::nonUniqueName();
                }

                if ($route['route'] == $this->currentRoute['route']) {
                    $route['name'] = $name;
                }
            }
        }

        return $this;
    }

    /**
     * Gets the run-time routes
     * @return array
     */
    public function getRuntimeRoutes(): array
    {
        $runtimeRoutes = [];
        foreach ($this->virtualRoutes as $virtualRoute) {
            foreach ($virtualRoute as $route) {
                $runtimeRoutes[] = $route;
            }
        }
        return $runtimeRoutes;
    }

    /**
     * Gets the virtual routes
     * @return array
     */
    public function getVirtualRoutes(): array
    {
        return $this->virtualRoutes;
    }

    /**
     * Assigns middlewares to the route
     * @param array $route
     * @param array $middlewares
     */
    private function assignMiddlewaresToRoute(array &$route, array $middlewares)
    {
        if (!key_exists('middlewares', $route)) {
            $route['middlewares'] = $middlewares;
        } else {
            $middlewares = array_reverse($middlewares);

            foreach ($middlewares as $middleware) {
                array_unshift($route['middlewares'], $middleware);
            }
        }
    }

	/**
	 * @param array $route
	 * @param bool $shouldCache
	 * @param int $ttl
	 * @return void
	 */
	private function assignCacheToCurrentRoute(array &$route, bool $shouldCache, int $ttl)
	{
		$route['cache_settings'] = [
			'shouldCache' => $shouldCache,
			'ttl' => $ttl,
		];
	}

	/**
	 * @return bool
	 * @throws ConfigException
	 * @throws DatabaseException
	 * @throws DiException
	 * @throws LangException
	 * @throws SessionException
	 * @throws ReflectionException
	 */
	private function canSetCacheToCurrentRoute(): bool
	{
		return $this->viewCacheInstance->isEnabled() &&
			!empty(session()->getId()) &&
			!empty($this->moduleOptions) &&
			!empty($this->moduleOptions['cacheable']);
	}
}