Syscodes\Routing\Route

Complexity

Total Complexity

77

Size/Duplication

Total Lines	733
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	runResolverController()	0	3	1
A	runResolverCallable()	0	6	1
A	__construct()	0	12	2
A	getAction()	0	3	1
A	getRoute()	0	3	1
A	domain()	0	9	2
A	getController()	0	9	2
A	controllerDispatcher()	0	3	1
A	parseAction()	0	7	5
A	isControllerAction()	0	3	1
A	getName()	0	3	1
A	getArguments()	0	3	1
A	parseControllerCallback()	0	3	1
A	getMethod()	0	3	1
A	getControllerMethod()	0	3	1
A	getDomain()	0	5	2
A	runResolver()	0	12	4
A	setParameter()	0	5	1
A	setDefaults()	0	5	1
A	prefix()	0	9	3
A	middleware()	0	16	3
A	parameter()	0	3	1
A	httpsOnly()	0	3	1
A	getMiddleware()	0	3	1
A	secure()	0	3	1
A	parseMethod()	0	13	5
A	__get()	0	3	1
A	name()	0	5	2
A	named()	0	13	4
A	setContainer()	0	5	1
A	compileParamNames()	0	7	1
A	httpOnly()	0	3	1
A	parseRoutePath()	0	22	4
A	bind()	0	5	1
A	gatherMiddleware()	0	12	2
A	setAction()	0	9	2
A	controllerMiddleware()	0	9	2
A	parseRoute()	0	9	2
A	parameters()	0	7	2
A	parameterNames()	0	7	2
A	defaults()	0	5	1
A	parametersWithouNulls()	0	4	1
A	where()	0	9	3

<?php 

/**
 * Lenevor Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file license.md.
 * It is also available through the world-wide-web at this URL:
 * https://lenevor.com/license
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@Lenevor.com so we can send you a copy immediately.
 *
 * @package     Lenevor
 * @subpackage  Base
 * @link        https://lenevor.com
 * @copyright   Copyright (c) 2019 - 2021 Alexander Campo <jalexcam@gmail.com>
 * @license     https://opensource.org/licenses/BSD-3-Clause New BSD license or see https://lenevor.com/license or see /license.md
 */

namespace Syscodes\Routing;

use Closure;
use LogicException;
use ReflectionFunction;
use Syscodes\Support\Str;
use Syscodes\Http\Request;
use InvalidArgumentException;
use Syscodes\Collections\Arr;
use Syscodes\Container\Container;
use Syscodes\Controller\ControllerDispatcher;
use Syscodes\Http\Exceptions\HttpResponseException;

/**
 * A Route describes a route and its parameters.
 * 
 * @author Alexander Campo <jalexcam@gmail.com>
 */
class Route 
{
	use Concerns\RouteCondition,

The trait Syscodes\Routing\Concerns\RouteDependencyResolver requires the property $name which is not provided by Syscodes\Routing\Route.

	    Concerns\RouteDependencyResolver;
	
	/**
	 * Action that the route will use when called.
	 *
	 * @var \Closure|string|array $action
	 */
	public $action;

	/**
	 * The computed gathered middleware.
	 * 
	 * @var array|null $computedMiddleware
	 */
	public $computedMiddleware;

	/**
	 * The container instance used by the route.
	 * 
	 * @var \Syscodes\Container\Container $container
	 */
	protected $container;

	/**
	 * The controller instance.
	 * 
	 * @var string $controller
	 */
	public $controller;

	/**
	 * The default values for the route.
	 * 
	 * @var array $defaults
	 */
	public $defaults = [];

	/**
	 * Variable of HTTP method.
	 *  
	 * @var array|string $method
	 */
	public $method;

	/**
	 * The array of matched parameters.
	 * 
	 * @var array $parameters
	 */
	public $parameters = [];

	/**
	 * The parameter names for the route.
	 * 
	 * @var string|null $parameterNames
	 */
	public $parameterNames;

	/**
	* Patterns that should be replaced.
	*
	* @var array $patterns 
	*/
	public $patterns = [
		'~/~'                    =>  '\/',               // Slash
		'~{an:[^\/{}]+}~'        => '([0-9a-zA-Z]++)',   // Placeholder accepts alphabetic and numeric chars
		'~{n:[^\/{}]+}~'         => '([0-9]++)',         // Placeholder accepts only numeric
		'~{a:[^\/{}]+}~'         => '([a-zA-Z]++)',      // Placeholder accepts only alphabetic chars
		'~{w:[^\/{}]+}~'         => '([0-9a-zA-Z-_]++)', // Placeholder accepts alphanumeric and underscore
		'~{\*:[^\/{}]+}~'        => '(.++)',             // Placeholder match rest of url
		'~(\\\/)?{\?:[^\/{}]+}~' => '\/?([^\/]*)',		 // Optional placeholder
		'~{[^\/{}]+}~'           => '([^\/]++)'			 // Normal placeholder
	];

	/**
	 * The URI pattern the route responds to.
	 *
	 * @var array $uri
	 */
	public $uri = [];

	/**
	 * Contains the arguments of the current route.
	 *
	 * @var array $where
	 */
	public $wheres = [];

	/**
	 * Constructor. Initialize route.
	 *
	 * @param  array|string|null  $method  
	 * @param  string|null  $uri  
	 * @param  \Closure|string|null  $action  
	 *
	 * @return void
	 */
	public function __construct($method = null, $uri = null, $action = null)
	{
		$this->uri = $uri;

It seems like $uri can also be of type string. However, the property $uri is declared as type array. Maybe add an additional type check?

		// Set the method
		$this->method = $this->parseMethod($method);

It seems like $method can also be of type string; however, parameter $method of Syscodes\Routing\Route::parseMethod() does only seem to accept array, maybe add an additional type check?

		// Set the action
		$this->action = Arr::except($this->parseAction($action), ['prefix']);

$this->parseAction($action) of type Syscodes\Routing\Route is incompatible with the type array expected by parameter $array of Syscodes\Collections\Arr::except().

		if (is_null($prefix = Arr::get($this->action, 'prefix'))) {
			$this->prefix($prefix);
		}
	}

	// Getters

	/**
	 * Get the action of the current route.
	 *
	 * @return \Closure|string|array
	 */
	public function getAction()
	{
		return $this->action;
	}

	/**
	 * Get the arguments of the current route.
	 *
	 * @return array
	 */
	public function getArguments()
	{
		return $this->wheres;
	}

	/**
	 * Get the controller instance for the route.
	 * 
	 * @return mixed
	 */
	public function getController()
	{
		if ( ! $this->controller) {
			$class = $this->parseControllerCallback()[0];
 
			$this->controller = $this->container->make(ltrim($class, '\\'));

It seems like $this->container->make(ltrim($class, '\')) of type object is incompatible with the declared type string of property $controller.

		}

		return $this->controller;
	}

	/**
	 * Get the controller method used for the route.
	 * 
	 * @return string
	 */
	public function getControllerMethod()
	{
		return $this->parseControllerCallback()[1];
	}

	/**
	 * Get the request method of the current route.
	 *
	 * @return array|string
	 */
	public function getMethod()
	{
		return $this->method;
	}

	/**
	 * Get the url of the current route.
	 *
	 * @return string
	 */
	public function getName()
	{
		return $this->action['as'] ?? null;
	}

	/**
	 * Get the url of the current route.
	 *
	 * @return array
	 */
	public function getRoute()
	{
		return $this->uri;
	}

	/**
	 * Get or set the domain for the route.
	 * 
	 * @param  string|null  $domain  
	 * 
	 * @return $this
	 */
	public function domain($domain = null)
	{
		if (is_null($domain)) {
			return $this->getDomain();

The expression return $this->getDomain() also could return the type string which is incompatible with the documented return type Syscodes\Routing\Route.

		}

		$this->action['domain'] = $this->parseRoute($domain);

		return $this;
	}

	/**
	 * Get the domain defined for the route.
	 * 
	 * @return string|null
	 */
	public function getDomain()
	{
		return isset($this->action['domain'])
				? str_replace(['http://', 'https://'], '', $this->action['domain'])
				: null;
	}

	/**
	 * Parse the controller.
	 * 
	 * @return array
	 */
	public function parseControllerCallback()
	{
		return Str::parseCallback($this->action['uses']);
	}
	
	/**
	 * Checks whether the route's action is a controller.
	 * 
	 * @return bool
	 */
	public function isControllerAction()
	{
		return is_string($this->action['uses']);
	}

	/**
	 * Get the dispatcher for the route's controller.
	 * 
	 * @return \Syscodes\Controller\ControllerDispatcher
	 */
	private function controllerDispatcher()
	{
		return new ControllerDispatcher($this->container);
	}

	// Setters
	
	/**
	 * Run the route action and return the response.
	 * 
	 * @return mixed
	 */
	public function runResolver()
	{
		$this->container = $this->container ?: new Container;

		try {
			if ($this->isControllerAction()) {
				return $this->runResolverController();
			}

			return $this->runResolverCallable();
		} catch (HttpResponseException $e) {
			return $e->getResponse();
		}
	}

	/**
	 * Run the route action and return the response.
	 *  
	 * @return mixed
	 */
	protected function runResolverCallable()
	{
		$callable = $this->action['uses'];

		return $callable(...array_values($this->resolveMethodDependencies(
			$this->parametersWithouNulls(), new ReflectionFunction($this->action['uses'])
		)));
	}

	/**
	 * Run the route action and return the response.
	 * 
	 * @return mixed
	 */
	protected function runResolverController()
	{
		return $this->controllerDispatcher()->dispatch($this, $this->getController(), $this->getControllerMethod());
	}

	/**
	 * Set the action.
	 *
	 * @param  \Closure|string  $action
	 *
	 * @return $this
	 *
	 * @throws \InvalidArgumentException
	 */
	public function parseAction($action)
	{
		if ( ! (is_object($action) && ($action instanceof Closure)) && ($action === null || $action === '')) {
			throw new InvalidArgumentException(__('route.actionClosureOrFunction'));
		}

		return RouteAction::parse($this->uri, $action);

The expression return Syscodes\Routing\RouteAction::parse($this->uri, $action) returns the type array which is incompatible with the documented return type Syscodes\Routing\Route.

	}

	/**
	 * Set the method of the current route.
	 *
	 * @param  array  $method
	 *
	 * @return string $this
	 * 
	 * @throws \InvalidArgumentException
	 */
	public function parseMethod($method)
	{
		if ($method === null || empty($method)) {
			throw new InvalidArgumentException(__('route.methodNotProvided'));			
		}

		foreach ((array) $method as $httpMethod) {
			if ( ! in_array($httpMethod, ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'ANY'])) {
				throw new InvalidArgumentException(__('route.methodNotAllowed'));				
			}
		}

	    return $method;

The expression return $method returns the type array which is incompatible with the documented return type string.

	}

	/**
	 * Set the route.
	 *
	 * @param  string|array|null  $uri
	 *
	 * @return string
	 *
	 * @throws  \InvalidArgumentException
	 */
	public function parseRoute($uri)
	{
		if ($uri === null) {
			throw new InvalidArgumentException(__('route.uriNotProvided'));
		}	

		$this->uri = $this->parseRoutePath($uri);

It seems like $uri can also be of type array; however, parameter $uri of Syscodes\Routing\Route::parseRoutePath() does only seem to accept string, maybe add an additional type check?

It seems like $this->parseRoutePath($uri) of type string is incompatible with the declared type array of property $uri.

		return $this;

The expression return $this returns the type Syscodes\Routing\Route which is incompatible with the documented return type string.

	}

	/**
	 * Replace word patterns with regex in route uri.
	 * 
	 * @param  string  $uri
	 * 
	 * @return string
	 */
	protected function parseRoutePath($uri)
	{
		$uri = trim($uri, '\/?');
		$uri = trim($uri, '\/');
		
		preg_match_all('/\{([\w\:]+?)\??\}/', $uri, $matches);
		
		foreach ($matches[1] as $match) {
			if (strpos($match, ':') === false) {
				continue;
			}
			
			$pattern  = array_keys($this->patterns);
			$replace  = array_values($this->patterns);
			$segments = explode(':', trim($match, '{}?'));
			
			$uri = strpos($match, ':') !== false
					? preg_replace($pattern, $replace, $uri)
					: str_replace($match, '{'.$segments[0].'}', $uri);
		}
		
		return $uri;
	}

	/**
	 * Add a prefix to the route URI.
	 * 
	 * @param  string  $prefix
	 * 
	 * @return $this
	 */
	public function prefix($prefix)
	{
		if ( ! empty($newPrefix = trim(rtrim($prefix, '/').'/'.ltrim($this->action['prefix'] ?? '', '/'), '/'))) {
			$this->action['prefix'] = $newPrefix;
		}
		
		$uri = rtrim($prefix, '/').'/'.ltrim($this->uri, '/');

$this->uri of type array is incompatible with the type string expected by parameter $string of ltrim().

		
		return $this->parseRoute($uri !== '/' ? trim($uri, '/') : $uri);

The expression return $this->parseRoute($uri !== '/' ? trim($uri, '/') : $uri) returns the type string which is incompatible with the documented return type Syscodes\Routing\Route.

	}

	/**
	 * Set the action array for the route.
	 * 
	 * @param  array  $action
	 * 
	 * @return $this
	 */
	public function setAction(array $action)
	{
		$this->action = $action;

		if (isset($this->action['domain'])) {
			$this->domain($this->action['domain']);
		}
		
		return $this;
	}

	/**
	 * Set the name.
	 *
	 * @param  string  $name
	 *
	 * @return $this
	 */
	public function name($name)
	{
		$this->action['as'] = isset($this->action['as']) ? $this->action['as'].$name : $name;

		return $this;
	}

	/**
	 * Determine whether the route's name matches the given patterns.
	 * 
	 * @param  mixed  ...$patterns
	 * 
	 * @return bool
	 */
	public function named(...$patterns)
	{
		if (is_null($routeName = $this->getName())) {

The condition is_null($routeName = $this->getName()) is always false.

			return false;
		}

		foreach ($patterns as $pattern) {
			if (Str::is($pattern, $routeName)) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Set a default value for the route.
	 * 
	 * @param  string  $key
	 * @param  mixed   $value
	 * 
	 * @return $this
	 */
	public function defaults($key, $value)
	{
		$this->defaults[$key] = $value;

		return $this;
	}

	/**
	 * Set a default values for the route.
	 * 
	 * @param  string  $defaults
	 * 
	 * @return $this
	 */
	public function setDefaults(array $defaults)
	{
		$this->defaults = $defaults;

		return $this;
	}

	/**
	 * Set the where.
	 *
	 * @param  array|string  $name
	 * @param  string|null  $expression  
	 *
	 * @return $this
	 */
	public function where($name, string $expression = null)
	{
		$wheres = is_array($name) ? $name : [$name => $expression];
		
		foreach ($wheres as $name => $expression) {

$name is overwriting one of the parameters of this function.

			$this->wheres[$name] = $expression;
		}

		return $this;
	}

	/**
	 * Bind the route to a given request for execution.
	 * 
	 * @param  \Syscodes\Http\Request  $request
	 * 
	 * @return $this
	 */
	public function bind(Request $request)
	{
		$this->parameters = (new RouteParamBinding($this))->parameters($request);

		return $this;
	}

	/**
	 * Get all of the parameter names for the route.
	 * 
	 * @return array
	 */
	public function parameterNames()
	{
		if (isset($this->parameterNames)) {
			return $this->parameterNames;

The expression return $this->parameterNames also could return the type string which is incompatible with the documented return type array.

		}

		return $this->parameterNames = $this->compileParamNames();

It seems like $this->compileParamNames() of type array is incompatible with the declared type null|string of property $parameterNames.

	}

	/**
	 * Get the parameter names for the route.
	 * 
	 * @return array
	 */
	protected function compileParamNames()
	{
		preg_match_all('~[^\/\{(.*?)\}]~', $this->domain().$this->uri, $matches);

Are you sure $this->domain() of type Syscodes\Routing\Route can be used in concatenation? Consider adding a __toString()-method.

		return array_map(function ($match) {
			return trim($match, '?');
		}, $matches[0]);
	}

	/**
	 * Get a given parameter from the route.
	 * 
	 * @param  string  $name
	 * @param  mixed  $default  
	 * 
	 * @return array
	 */
	public function parameter($name, $default = null)
	{
		return Arr::get($this->parameters(), $name, $default);
	}

	/**
	 * Set a parameter to the given value.
	 * 
	 * @param  string  $name
	 * @param  mixed  $value
	 * 
	 * @return array
	 */
	public function setParameter($name, $value)
	{
		$this->parameters();

		$this->parameters[$name] = $value;
	}

	/**
	 * Get the key / value list of parameters without null values.
	 * 
	 * @return array
	 */
	public function parametersWithouNulls()
	{
		return array_filter($this->parameters(), function ($parameter) {
			return ! is_null($parameter);
		});
	}

	/**
	 * Get the key / value list of parameters for the route.
	 * 
	 * @return array
	 */
	public function parameters()
	{
		if (isset($this->parameters)) {
			return $this->parameters;
		}

		throw new LogicException('The route is not bound.');
	}

	/**
	 * Get all middleware, including the ones from the controller.
	 * 
	 * @return array
	 */
	public function gatherMiddleware()
	{
		if ( ! is_null($this->computedMiddleware)) {
			return $this->computedMiddleware;
		}

		$this->computedMiddleware = [];

		return $this->computedMiddleware = array_unique(array_merge(
			$this->middleware(),
			$this->controllerMiddleware()
		), SORT_REGULAR);
	}

	/**
	 * Get or set the middlewares attached to the route.
	 * 
	 * @param  array|string|null  $middleware
	 * 
	 * @return $this|array
	 */
	public function middleware($middleware = null)
	{
		if (is_null($middleware)) {
			return $this->getMiddleware();
		}

		if (is_string($middleware)) {
			$middleware = func_get_args();
		}

		$this->action['middleware'] = array_merge(
			$this->getMiddleware(),
			$middleware
		);

		return $this;
	}

	/**
	 * Get the middlewares attached to the route.
	 * 
	 * @return array
	 */
	protected function getMiddleware()
	{
		return (array) ($this->action['middleware'] ?? []);
	}

	/**
	 * Get the middleware for the route's controller.
	 * 
	 * @return array
	 */
	public function controllerMiddleware()
	{
		if ( ! $this->isControllerAction()) {
			return [];
		}

		return $this->controllerDispatcher()->getMiddleware(
			$this->getController(),

$this->getController() of type string is incompatible with the type Syscodes\Controller\Controller expected by parameter $controller of Syscodes\Controller\ControllerDispatcher::getMiddleware().

			$this->getControllerMethod()
		);
	}

	/**
	 * Determine if the route only responds to HTTP requests.
	 * 
	 * @return bool
	 */
	public function httpOnly()
	{
		return in_array('http', $this->action, true);
	}

	/**
	 * Determine if the route only responds to HTTPS requests.
	 * 
	 * @return bool
	 */
	public function httpsOnly()
	{
		return $this->secure();
	}

	/**
	 * Determine if the route only responds to HTTPS requests.
	 * 
	 * @return bool
	 */
	public function secure()
	{
		return in_array('https', $this->action, true);
	}

	/**
	 * Set the container instance on the route.
	 * 
	 * @param  \Syscodes\Container\Container  $container
	 * 
	 * @return $this
	 */
	public function setContainer(Container $container)
	{
		$this->container = $container;

		return $this;
	}

	/**
	 * Dynamically access route parameters.
	 * 
	 * @param  string  $key
	 * 
	 * @return mixed
	 */
	public function __get($key)
	{
		return $this->parameter($key);
	}
}