Syscodes\Http\URI

Complexity

Total Complexity

53

Size/Duplication

Total Lines	494
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	5	1
A	filterSegments()	0	3	2
D	applyParts()	0	36	10
A	__toString()	0	3	1
A	setUserInfo()	0	6	1
A	setHost()	0	5	1
A	getTotalSegments()	0	3	1
A	getScheme()	0	3	1
A	getUserInfo()	0	9	3
A	getPort()	0	3	1
A	getHost()	0	3	1
A	setScheme()	0	7	1
A	get()	0	3	1
A	setPort()	0	13	4
A	showPassword()	0	5	1
A	getSegment()	0	3	1
A	getAuthority()	0	21	6
A	getPath()	0	3	2
A	getFragment()	0	3	2
A	getSegments()	0	4	1
A	setUri()	0	13	3
A	setAuthority()	0	12	3
A	__construct()	0	4	2
A	filterPath()	0	5	1
A	setFragment()	0	5	1
A	setPath()	0	7	1

<?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\Http;

use InvalidArgumentException;
use Syscodes\Collections\Arr;
use Syscodes\Http\Contributors\Parameters;
use Syscodes\Http\Exceptions\HttpURIException;

/**
 * Abstraction for a uniform resource identifier (URI).
 * 
 * @author Alexander Campo <jalexcam@gmail.com>
 */
class URI
{
	/**
	 * Returns default schemes/ports.
	 * 
	 * @var array $defaultPorts
	 */
	protected $defaultPorts = [
		'http'  => 80,
		'https' => 443,
		'ftp'   => 21,
		'sftp'  => 22
	];

	/**
	 * The name of any fragment.
	 * 
	 * @var string $fragment
	 */
	protected $fragment = '';

	/**
	 * The URI Host.
	 * 
	 * @var string $host
	 */
	protected $host;
	
	/**
	 * The URI User Password.
	 * 
	 * @var string $password
	 */
	protected $password;

	/**
	 * The URI path.
	 * 
	 * @var string $path
	 */
	protected $path;

	/**
	 * The URI Port.
	 * 
	 * @var int $port
	 */
	protected $port;

	/**
	 * The query string.
	 * 
	 * @var string $query
	 */
	protected $query;

	/**
	 * The URI Scheme.
	 * 
	 * @var string $scheme
	 */
	protected $scheme = 'http';

	/**
	 * The URI segments.
	 *
	 * @var array $segments
	 */
	protected $segments = [];

	/**
	 * Whether passwords should be shown in userInfo/authority calls.
	 * 
	 * @var boolean $showPassword
	 */
	protected $showPassword = false;
	
	/**
	 * The URI User Info.
	 * 
	 * @var string $user
	 */
	protected $user;

	/**
	 * Constructor. The URI class instance.
	 * 
	 * @param  string|null  $uri  
	 * 
	 * @return void
	 * 
	 * @throws \Syscodes\Http\Exceptions\HttpURIException
	 */
	public function __construct(string $uri = null)
	{
		if ( ! is_null($uri)) {
			$this->setUri($uri);
		}
	}

	/**
	 * Sets and overwrites any current URI information.
	 * 
	 * @param  string|null  $uri  
	 * 
	 * @return mixed
	 * 
	 * @throws \Syscodes\Http\Exceptions\HttpURIException
	 */
	public function setUri(string $uri = null)
	{
		if ( ! is_null($uri)) {
			$parts = parse_url($uri);

			if ($parts === false) {
				throw HttpURIException::UnableToParseURI($uri);
			}

			$this->applyParts($parts);
		}

		return $this;
	}

	/**
	 * Returns the full URI string.
	 *
	 * @return string  The URI string
	 */
	public function get()
	{
		return '/'.ltrim($this->path, '/');
	}

	/**
	 * Sets of URI string.
	 * 
	 * @param  string  $uri
	 * 
	 * @return $this
	 */
	public function set($uri)
	{
		$this->path = $uri;

		return $this;
	}

	/**
	 * Retrieve the path component of the URI. The path can either be empty or absolute 
	 * (starting with a slash) or rootless (not starting with a slash).
	 * 
	 * @return string
	 */
	public function getPath()
	{
		return (is_null($this->path) ? '' : $this->path);

The condition is_null($this->path) is always false.

	}

	/**
	 * Sets the path portion of the URI.
	 * 
	 * @param  string  $path
	 *
	 * @return void
	 */
	public function setPath(string $path) 
	{
		$this->path = $this->filterPath($path);

		$this->filterSegments($this->path);

		return $this;

The expression return $this returns the type Syscodes\Http\URI which is incompatible with the documented return type void.

	} 

	/**
	 * Encodes any dangerous characters.
	 * 
	 * @param  string|null  $path
	 * 
	 * @return string
	 */
	protected function filterPath(string $path = null)
	{
		$path = urldecode($path);

It seems like $path can also be of type null; however, parameter $string of urldecode() does only seem to accept string, maybe add an additional type check?

		return $path;
	}

	/**
	 * Filter the segments of path.
	 * 
	 * @param  string  $uri
	 * 
	 * @return string[]
	 */
	protected function filterSegments($uri)
	{
		$this->segments = (empty($uri) ? [] : explode('/', $uri));
	}

	/**
	 * Get the specified URI segment, return default if it doesn't exist.
	 * Segment index is 1 based, not 0 based.
	 *
	 * @param  int  $index  The 1-based segment index
	 * @param  mixed  $default  The default value
	 *
	 * @return mixed
	 */
	public function getSegment(int $index, $default = null)
	{
		return Arr::get($this->getSegments(), $index - 1, $default);
	}

	/**
	 * Returns the segments of the path as an array.
	 *
	 * @return array  The URI segments
	 */
	public function getSegments()
	{
		return array_values(array_filter($this->segments, function ($value) {
			return $value != '';
		}));
	}

	/**
	 * Returns the total number of segment.
	 *
	 * @return int  
	 */
	public function getTotalSegments()
	{
		return count($this->getSegments());
	}

	/**
	 * Retrieve the scheme component of the URI.
	 * 
	 * @return string
	 */
	public function getScheme()
	{
		return $this->scheme;
	}

	/**
	 * Sets the scheme for this URI.
	 * 
	 * @param  string  $str
	 * 
	 * @return $this
	 */
	public function setScheme(string $str)
	{
		$str = preg_replace('~:(//)?$~', '', strtolower($str));

		$this->scheme = $str;

		return $this->scheme;

The expression return $this->scheme returns the type string which is incompatible with the documented return type Syscodes\Http\URI.

	}

	/**
	 * Retrieve the user component of the URI.
	 * 
	 * @return string|null
	 */
	public function getUserInfo()
	{
		$user = $this->user;

		if ($this->showPassword === true && ! empty($this->password)) {
			$user .= ":$this->password";
		}

		return $user;
	}

	/**
	 * Sets the userInfo/Authority portion of the URI.
	 * 
	 * @param  string  $user
	 * @param  string  $pass
	 * 
	 * @return $this
	 */
	public function setUserInfo(string $user, string $pass)
	{
		$this->user     = trim($user);
		$this->password = trim($pass);

		return $this;
	}

	/**
	 * Temporarily sets the URI to show a password in userInfo.
	 * 
	 * @param  boolean  $option  
	 * 
	 * @return $this
	 */
	public function showPassword(bool $option = true)
	{
		$this->password = $option;

The property $password was declared of type string, but $option is of type boolean. Maybe add a type cast?

		return $this->password;

The expression return $this->password returns the type boolean which is incompatible with the documented return type Syscodes\Http\URI.

	}

	/**
	 * Retrieve the authority component of the URI.
	 * 
	 * @param  boolean  $ignore  
	 * 
	 * @return string
	 */
	public function getAuthority(bool $ignore = false)
	{
		if (empty($this->host)) {
			return '';
		}

		$authority = $this->host;

		if ( ! empty($this->getUserInfo())) {
			$authority = $this->getUserInfo().'@'.$authority;
		}

		if ( ! empty($this->port) && ! $ignore) {
			if ($this->port !== $this->defaultPorts[$this->scheme]) {
				$authority .= ":$this->port";
			}
		}

		$this->showPassword = false;

		return $authority;
	}

	/**
	 * Parses the given string an saves the appropriate authority pieces.
	 * 
	 * @param  string  $str
	 * 
	 * @return $this
	 */
	public function setAuthority(string $str)
	{
		$parts = parse_url($str);

		if (empty($parts['host']) && ! empty($parts['path'])) {
			$parts['host'] = $parts['path'];
			unset($parts['path']);
		}

		$this->applyParts($parts);

		return $this;
	}

	/**
	 * Retrieve the host component of the URI.
	 * 
	 * @return string
	 */
	public function getHost()
	{
		return $this->host;
	}

	/**
	 * Sets the host name to use.
	 * 
	 * @param  string  $str
	 * 
	 * @return $this
	 */
	public function setHost(string $str)
	{
		$this->host = trim($str);

		return $this->host;

The expression return $this->host returns the type string which is incompatible with the documented return type Syscodes\Http\URI.

	}

	/**
	 * Retrieve the port component of the URI.
	 * 
	 * @return int|null
	 */
	public function getPort()
	{
		return $this->port;
	}

	/**
	 * Sets the port portion of the URI.
	 * 
	 * @param  int|null  $port  
	 * 
	 * @return string
	 */
	public function setPort(int $port = null)
	{
		if (is_null($port)) {
			return $this;
		}

		if ($port <= 0 || $port > 65355) {
			throw HttpURIException::invalidPort($port);
		}

		$this->port = $port;

		return $this->port;
	}

	/**
	 * Retrieve a URI fragment.
	 * 
	 * @return string
	 */
	public function getFragment()
	{
		return is_null($this->fragment) ? '' : $this->fragment;

The condition is_null($this->fragment) is always false.

	}

	/**
	 * Sets the fragment portion of the URI.
	 * 
	 * @param  string  $str
	 * 
	 * @return $this
	 */
	public function setFragment(string $str)
	{
		$this->fragment = trim($str, '# ');

		return $this->fragment;

The expression return $this->fragment returns the type string which is incompatible with the documented return type Syscodes\Http\URI.

	}

	/**
	 * Saves our parts from a parse_url call.
	 * 
	 * @param  array  $parts
	 * 
	 * @return mixed
	 */
	public function applyParts(array $paths)

The parameter $paths is not used and could be removed.

	{
		if (isset($parts['scheme'])) {

The variable $parts seems to never exist and therefore isset should always be false.

			$this->SetScheme(rtrim($parts['scheme'], ':/'));
		} else {
			$this->setScheme('http');
		}

		if ( ! empty($parts['host'])) {
			$this->host = $parts['host'];
		}

		if (isset($parts['port'])) {
			if ( ! is_null($parts['port'])) {

The variable $parts seems to be never defined.

				$this->port = $parts['port'];
			}
		}

		if ( ! empty($parts['user'])) {
			$this->user = $parts['user'];
		}

		if ( ! empty($parts['pass'])) {
			$this->password = $parts['pass'];
		}

		if ( ! empty($parts['path'])) {
			$this->path = $this->filterPath($parts['path']);
		}

		if ( ! empty($parts['fragment'])) {
			$this->fragment = $parts['fragment'];
		}

		if ( ! empty($parts['path'])) {
			$this->segments = explode('/', $parts['path'], '/');

'/' of type string is incompatible with the type integer expected by parameter $limit of explode().

		}
	}

	/**
	 * Returns the URI string.
	 *
	 * @return string
	 */
	public function __toString()
	{
		return (string) $this->getPath();
	}
}