BlitzPHP\Http\UrlGenerator

Complexity

Total Complexity

56

Size/Duplication

Total Lines	449
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	getSession()	0	7	2
A	forceScheme()	0	5	2
A	previous()	0	13	4
A	assetFrom()	0	8	1
A	getPreviousUrlFromSession()	0	5	2
A	current()	0	3	1
A	formatScheme()	0	11	5
A	extractQueryString()	0	10	2
A	getRequest()	0	3	1
A	isValidUrl()	0	7	2
A	removeIndex()	0	5	2
A	forceRootUrl()	0	5	2
A	secure()	0	3	1
A	to()	0	23	2
A	asset()	0	12	3
A	setKeyResolver()	0	5	1
A	full()	0	3	1
A	formatHostUsing()	0	5	1
A	__construct()	0	3	1
A	formatPathUsing()	0	5	1
A	pathFormatter()	0	4	2
A	route()	0	9	3
A	setRoutes()	0	5	1
A	formatRoot()	0	13	5
A	secureAsset()	0	3	1
A	formatParameters()	0	5	1
A	format()	0	13	3
A	setSessionResolver()	0	5	1
A	setRequest()	0	8	1
A	setRootControllerNamespace()	0	5	1

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Http;

use BlitzPHP\Container\Services;
use BlitzPHP\Contracts\Router\RouteCollectionInterface;
use BlitzPHP\Exceptions\HttpException;
use BlitzPHP\Session\Store;

The type BlitzPHP\Session\Store was not found. Maybe you did not declare it correctly or list all dependencies?

use BlitzPHP\Traits\Macroable;
use BlitzPHP\Utilities\Iterable\Arr;
use BlitzPHP\Utilities\String\Text;
use Closure;

/**
 * @credit <a href="http://laravel.com">Laravel - \Illuminate\Routing\UrlGenerator</a>
 */
class UrlGenerator 
{
	use Macroable;

The trait BlitzPHP\Traits\Macroable requires the property $name which is not provided by BlitzPHP\Http\UrlGenerator.

    /**
     * The forced URL root.
     */
    protected string $forcedRoot = '';

    /**
     * The forced scheme for URLs.
     */
    protected string $forceScheme = '';

    /**
     * A cached copy of the URL root for the current request.
     */
    protected ?string $cachedRoot = null;

    /**
     * A cached copy of the URL scheme for the current request.
     */
    protected ?string $cachedScheme = null;

    /**
     * The root namespace being applied to controller actions.
     */
    protected string $rootNamespace = '';

    /**
     * The session resolver callable.
     *
     * @var callable
     */
    protected $sessionResolver;

    /**
     * The encryption key resolver callable.
     *
     * @var callable
     */
    protected $keyResolver;

    /**
     * The callback to use to format hosts.
     *
     * @var \Closure
     */
    protected $formatHostUsing;

    /**
     * The callback to use to format paths.
     *
     * @var \Closure
     */
    protected $formatPathUsing;

    /**
     * Create a new URL Generator instance.
     *
     * @param  RouteCollectionInterface  $routes The route collection.
     * @param  Request  $request  The request instance.
     * @param  string|null  $assetRoot The asset root URL.
     * @return void
     */
    public function __construct(protected RouteCollectionInterface $routes, protected Request $request, protected ?string $assetRoot = null)
    {
		$this->setRequest($request);
    }

    /**
     * Get the full URL for the current request.
     */
    public function full(): string
    {
        return $this->request->fullUrl();
    }

    /**
     * Get the current URL for the request.
     */
    public function current(): string
    {
        return $this->to($this->request->getUri()->getPath());
    }

    /**
     * Get the URL for the previous request.
     *
     * @param  mixed  $fallback
     */
    public function previous($fallback = false): string
    {
        $referrer = $this->request->getHeaderLine('Referer');

        $url = $referrer ? $this->to($referrer) : $this->getPreviousUrlFromSession();

        if ($url) {
            return $url;
        } elseif ($fallback) {
            return $this->to($fallback);
        }

        return $this->to('/');
    }

    /**
     * Get the previous URL from the session if possible.
     */
    protected function getPreviousUrlFromSession(): ?string
    {
        $session = $this->getSession();

        return $session ? $session->previousUrl() : null;

$session is of type BlitzPHP\Session\Store, thus it always evaluated to true.

    }

    /**
     * Generate an absolute URL to the given path.
     */
    public function to(string $path, mixed $extra = [], ?bool $secure = null): string
    {
        // First we will check if the URL is already a valid URL. If it is we will not
        // try to generate a new one but will simply return the URL as is, which is
        // convenient since developers do not always have to check if it's valid.
        if ($this->isValidUrl($path)) {
            return $path;
        }

        $tail = implode('/', array_map(
            'rawurlencode', (array) $this->formatParameters($extra))
        );

        // Once we have the scheme we will compile the "tail" by collapsing the values
        // into a single string delimited by slashes. This just makes it convenient
        // for passing the array of parameters to this URL as a list of segments.
        $root = $this->formatRoot($this->formatScheme($secure));

        [$path, $query] = $this->extractQueryString($path);

        return $this->format(
            $root, '/'.trim($path.'/'.$tail, '/')
        ).$query;
    }

    /**
     * Generate a secure, absolute URL to the given path.
     */
    public function secure(string $path, array $parameters = []): string
    {
        return $this->to($path, $parameters, true);
    }

    /**
     * Generate the URL to an application asset.
     */
    public function asset(string $path, ?bool $secure = null): string
    {
        if ($this->isValidUrl($path)) {
            return $path;
        }

        // Once we get the root URL, we will check to see if it contains an index.php
        // file in the paths. If it does, we will remove it since it is not needed
        // for asset paths, but only for routes to endpoints in the application.
        $root = $this->assetRoot ?: $this->formatRoot($this->formatScheme($secure));

        return $this->removeIndex($root).'/'.trim($path, '/');
    }

    /**
     * Generate the URL to a secure asset.
     */
    public function secureAsset(string $path): string
    {
        return $this->asset($path, true);
    }

    /**
     * Generate the URL to an asset from a custom root domain such as CDN, etc.
     */
    public function assetFrom(string $root, string $path, ?bool $secure = null): string
    {
        // Once we get the root URL, we will check to see if it contains an index.php
        // file in the paths. If it does, we will remove it since it is not needed
        // for asset paths, but only for routes to endpoints in the application.
        $root = $this->formatRoot($this->formatScheme($secure), $root);

        return $this->removeIndex($root).'/'.trim($path, '/');
    }

    /**
     * Remove the index.php file from a path.
     */
    protected function removeIndex(string $root): string
    {
        $i = 'index.php';

        return Text::contains($root, $i) ? str_replace('/'.$i, '', $root) : $root;

$i of type string is incompatible with the type iterable expected by parameter $needles of BlitzPHP\Utilities\String\Text::contains().

    }

    /**
     * Get the default scheme for a raw URL.
     */
    public function formatScheme(?bool $secure = null): string
    {
        if (null !== $secure) {
            return $secure ? 'https://' : 'http://';
        }

        if (null === $this->cachedScheme) {
            $this->cachedScheme = $this->forceScheme ?: $this->request->getScheme().'://';
        }

        return $this->cachedScheme;
    }

    /**
     * Get the URL to a named route.
	 * 
     * @return string|false
     */
    public function route(string $name, array $parameters = [], bool $absolute = true)
    {
		$route = $this->routes->reverseRoute($name, ...$parameters);

        if (! $route) {
            throw HttpException::invalidRedirectRoute($route);

It seems like $route can also be of type false; however, parameter $route of BlitzPHP\Exceptions\HttpException::invalidRedirectRoute() does only seem to accept string, maybe add an additional type check?

        }

		return $absolute ? site_url($route) : $route;
    }
	

    /**
     * Format the array of URL parameters.
     */
    public function formatParameters(mixed $parameters): array
    {
        $parameters = Arr::wrap($parameters);

        return $parameters;
    }

    /**
     * Extract the query string from the given path.
     */
    protected function extractQueryString(string $path): array
    {
        if (($queryPosition = strpos($path, '?')) !== false) {
            return [
                substr($path, 0, $queryPosition),
                substr($path, $queryPosition),
            ];
        }

        return [$path, ''];
    }

    /**
     * Get the base URL for the request.
     */
    public function formatRoot(string $scheme, ?string $root = null): string
    {
        if (is_null($root)) {
            if (is_null($this->cachedRoot)) {
                $this->cachedRoot = $this->forcedRoot ?: $this->request->root();
            }

            $root = $this->cachedRoot;
        }

        $start = Text::startsWith($root, 'http://') ? 'http://' : 'https://';

It seems like $root can also be of type null; however, parameter $haystack of BlitzPHP\Utilities\String\Text::startsWith() does only seem to accept string, maybe add an additional type check?

'http://' of type string is incompatible with the type iterable expected by parameter $needles of BlitzPHP\Utilities\String\Text::startsWith().

        return preg_replace('~'.$start.'~', $scheme, $root, 1);
    }

    /**
     * Format the given URL segments into a single URL.
     *
     * @param  string  $root
     * @param  string  $path
     * @param  \Illuminate\Routing\Route|null  $route

The type Illuminate\Routing\Route was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return string
     */
    public function format($root, $path, $route = null)
    {
        $path = '/'.trim($path, '/');

        if ($this->formatHostUsing) {
            $root = call_user_func($this->formatHostUsing, $root, $route);
        }

        if ($this->formatPathUsing) {
            $path = call_user_func($this->formatPathUsing, $path, $route);
        }

        return trim($root.$path, '/');
    }

    /**
     * Determine if the given path is a valid URL.
     */
    public function isValidUrl(string $path): bool
    {
        if (! preg_match('~^(#|//|https?://|(mailto|tel|sms):)~', $path)) {
            return filter_var($path, FILTER_VALIDATE_URL) !== false;
        }

        return true;
    }

    /**
     * Force the scheme for URLs.
     */
    public function forceScheme(?string $scheme): void
    {
        $this->cachedScheme = null;

        $this->forceScheme = $scheme ? $scheme.'://' : null;
    }

    /**
     * Set the forced root URL.
     */
    public function forceRootUrl(?string $root): void
    {
        $this->forcedRoot = $root ? rtrim($root, '/') : null;

        $this->cachedRoot = null;
    }

    /**
     * Set a callback to be used to format the host of generated URLs.
     *
     * @param  \Closure  $callback
     * @return $this
     */
    public function formatHostUsing(Closure $callback)
    {
        $this->formatHostUsing = $callback;

        return $this;
    }

    /**
     * Set a callback to be used to format the path of generated URLs.
     *
     * @param  \Closure  $callback
     * @return $this
     */
    public function formatPathUsing(Closure $callback)
    {
        $this->formatPathUsing = $callback;

        return $this;
    }

    /**
     * Get the path formatter being used by the URL generator.
     *
     * @return \Closure
     */
    public function pathFormatter()
    {
        return $this->formatPathUsing ?: function ($path) {
            return $path;
        };
    }

    /**
     * Get the request instance.
     */
    public function getRequest(): Request
    {
        return $this->request;
    }

    /**
     * Set the current request instance.
     */
    public function setRequest(Request $request): self
    {
        $this->request = $request;

        $this->cachedRoot = null;
        $this->cachedScheme = null;

		return $this;
    }

    /**
     * Set the route collection.
     */
    public function setRoutes(RouteCollectionInterface $routes): self
    {
        $this->routes = $routes;

        return $this;
    }

    /**
     * Get the session implementation from the resolver.
     */
    protected function getSession(): ?Store
    {
        if ($this->sessionResolver) {
            return call_user_func($this->sessionResolver);
        }

		return Services::session();
    }

    /**
     * Set the session resolver for the generator.
     *
     * @param  callable  $sessionResolver
     * @return $this
     */
    public function setSessionResolver(callable $sessionResolver)
    {
        $this->sessionResolver = $sessionResolver;

        return $this;
    }

    /**
     * Set the encryption key resolver.
     *
     * @param  callable  $keyResolver
     * @return $this
     */
    public function setKeyResolver(callable $keyResolver)
    {
        $this->keyResolver = $keyResolver;

        return $this;
    }

    /**
     * Set the root controller namespace.
     *
     * @param  string  $rootNamespace
     * @return $this
     */
    public function setRootControllerNamespace($rootNamespace)
    {
        $this->rootNamespace = $rootNamespace;

        return $this;
    }
}