Helldar\Support\Helpers\Http\Builder

Complexity

Total Complexity

55

Size/Duplication

Total Lines	538
Duplicated Lines	0 %

Test Coverage

Coverage

99.35%

Importance

Changes	3
Bugs	1	Features	0

39 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	9	1
A	removeFragment()	0	3	1
A	withQuery()	0	3	1
A	withScheme()	0	3	1
A	getQuery()	0	7	3
A	getSubDomain()	0	5	2
A	getDomain()	0	3	1
A	getPassword()	0	3	1
A	withHost()	0	3	1
A	prepare()	0	17	3
A	removeQuery()	0	7	1
A	getPort()	0	3	1
A	toArray()	0	11	1
A	getBaseUrl()	0	6	1
A	getUser()	0	3	1
A	__toString()	0	3	1
A	getHost()	0	3	1
A	componentNameByIndex()	0	5	1
A	fromPsr()	0	21	1
A	getAuthority()	0	7	1
A	resolveSame()	0	3	2
A	withPort()	0	3	1
A	getFragment()	0	3	1
A	withPath()	0	3	1
A	parsed()	0	13	1
A	same()	0	3	1
A	getUserInfo()	0	6	1
A	validateComponentIndex()	0	6	3
A	validate()	0	5	1
A	get()	0	5	1
A	getValidationType()	0	3	1
A	getPath()	0	7	2
A	withFragment()	0	3	1
A	toUrl()	0	12	2
A	getScheme()	0	3	1
A	parse()	0	13	4
A	withUserInfo()	0	5	1
A	toPsr()	0	3	1
A	putQuery()	0	12	4

<?php
/*
 * This file is part of the "andrey-helldar/support" project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @author Andrey Helldar <helldar@ai-rus.com>
 *
 * @copyright 2021 Andrey Helldar
 *
 * @license MIT
 *
 * @see https://github.com/andrey-helldar/support
 */

namespace Helldar\Support\Helpers\Http;

use Helldar\Contracts\Http\Builder as BuilderContract;
use Helldar\Support\Concerns\Castable;
use Helldar\Support\Concerns\Validation;
use Helldar\Support\Exceptions\UnknownUrlComponentIndexException;
use Helldar\Support\Facades\Helpers\Ables\Arrayable;
use Helldar\Support\Facades\Helpers\Arr;
use Helldar\Support\Facades\Helpers\Str;
use Helldar\Support\Facades\Http\Url as UrlHelper;
use Helldar\Support\Tools\HttpBuilderPrepare;
use Psr\Http\Message\UriInterface;

class Builder implements BuilderContract
{
    use Castable;
    use Validation;

    protected $parsed = [];

    protected $components = [
        PHP_URL_SCHEME   => 'scheme',
        PHP_URL_HOST     => 'host',
        PHP_URL_PORT     => 'port',
        PHP_URL_USER     => 'user',
        PHP_URL_PASS     => 'pass',
        PHP_URL_QUERY    => 'query',
        PHP_URL_PATH     => 'path',
        PHP_URL_FRAGMENT => 'fragment',
    ];

    protected $casts = [
        'query' => 'array',
        'port'  => 'integer',
    ];

    protected $validate = [
        PHP_URL_SCHEME   => ['null', 'string'],
        PHP_URL_HOST     => ['null', 'string'],
        PHP_URL_PORT     => ['null', 'integer'],
        PHP_URL_USER     => ['null', 'string'],
        PHP_URL_PASS     => ['null', 'string'],
        PHP_URL_QUERY    => ['null', 'string', 'array'],
        PHP_URL_PATH     => ['null', 'string'],
        PHP_URL_FRAGMENT => ['null', 'string'],
    ];

    /**
     * Return the string representation as a URI reference.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->toUrl();
    }

    /**
     * Gets the current instance of the object.
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function same(): self
    {
        return $this;
    }

    /**
     * Parse a URL.
     *
     * @param  \Psr\Http\Message\UriInterface|string|null  $url
     * @param  int  $component
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function parse($url, int $component = self::PHP_URL_ALL): BuilderContract
    {
        if ($component === self::PHP_URL_ALL) {
            UrlHelper::validate($url);
        }

        $instance = $this->resolveSame($component);

        $key = $this->componentNameByIndex($component);

        return $component === self::PHP_URL_ALL || empty($key)
            ? $instance->parsed(parse_url($url))
            : $instance->parsed([$key => parse_url($url, $component)]);
    }

    /**
     * Populate an object with parsed data.
     *
     * @param  array  $parsed
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function parsed(array $parsed): BuilderContract
    {
        $components = array_values($this->components);

        $filtered = Arr::only($parsed, $components);

        $this->parsed = Arrayable::of($this->parsed)
            ->merge($filtered)
            ->get();

        $this->cast($this->parsed);

        return $this;
    }

    /**
     * Retrieve the domain name of the URI.
     *
     * @return string
     */
    public function getDomain(): string
    {
        return $this->getHost();
    }

    /**
     * Retrieve the subdomain name of the URI.
     *
     * @return string
     */
    public function getSubDomain(): string
    {
        $host = explode('.', $this->getHost());

        return count($host) > 2 ? reset($host) : '';
    }

    /**
     * Retrieve the scheme and host of the URI.
     *
     * @return string
     */
    public function getBaseUrl(): string
    {
        $schema = $this->getScheme();
        $host   = $this->getHost();

        return (string) Str::of("$schema://$host")->trim('://');
    }

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

    /**
     * Retrieve the authority component of the URI.
     *
     * @return string
     */
    public function getAuthority(): string
    {
        $auth = $this->getUserInfo();
        $host = $this->getHost();
        $port = $this->getPort();

        return (string) Str::of("$auth@$host:$port")->trim('@:');
    }

    /**
     * Retrieve the user information component of the URI.
     *
     * @return string
     */
    public function getUserInfo(): string
    {
        $user = $this->getUser();
        $pass = $this->getPassword();

        return (string) Str::of("$user:$pass")->trim(':');
    }

    /**
     * Retrieve the user name component of the URI.
     *
     * @return string
     */
    public function getUser(): string
    {
        return (string) $this->get(PHP_URL_USER);
    }

    /**
     * Retrieve the user password component of the URI.
     *
     * @return string
     */
    public function getPassword(): string
    {
        return (string) $this->get(PHP_URL_PASS);
    }

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

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

    /**
     * Retrieve the path component of the URI.
     *
     * @return string
     */
    public function getPath(): string
    {
        $value = $this->get(PHP_URL_PATH);

        $path = (string) Str::of($value)->trim('/')->start('/');

        return $path !== '/' ? $path : '';
    }

    /**
     * Retrieve the query string of the URI.
     *
     * @return string
     */
    public function getQuery(): string
    {
        if ($value = $this->get(PHP_URL_QUERY)) {
            return is_string($value) ? $value : http_build_query($value);
        }

        return '';
    }

    /**
     * Retrieve the fragment component of the URI.
     *
     * @return string
     */
    public function getFragment(): string
    {
        return (string) $this->get(PHP_URL_FRAGMENT);
    }

    /**
     * Remove the fragment component from the URI.
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function removeFragment(): BuilderContract
    {
        return $this->set(PHP_URL_FRAGMENT, null);
    }

    /**
     * Return an instance with the specified scheme.
     *
     * @param  string  $scheme
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withScheme($scheme): self
    {
        return $this->set(PHP_URL_SCHEME, $scheme);
    }

    /**
     * Return an instance with the specified user information.
     *
     * @param  string  $user
     * @param  string|null  $password
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withUserInfo($user, $password = null): self
    {
        return $this
            ->set(PHP_URL_USER, $user)
            ->set(PHP_URL_PASS, $password);
    }

    /**
     * Return an instance with the specified host.
     *
     * @param  string  $host
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withHost($host): self
    {
        return $this->set(PHP_URL_HOST, $host);
    }

    /**
     * Return an instance with the specified port.
     *
     * @param  int|null  $port
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withPort($port): self
    {
        return $this->set(PHP_URL_PORT, $port);
    }

    /**
     * Return an instance with the specified path.
     *
     * @param  string  $path
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withPath($path): self
    {
        return $this->set(PHP_URL_PATH, $path);
    }

    /**
     * Return an instance with the specified query string.
     *
     * @param  array|string  $query
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withQuery($query): self
    {
        return $this->set(PHP_URL_QUERY, $query);
    }

    /**
     * Return an instance with the specified query object.
     *
     * @param  string  $key
     * @param  mixed  $value
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function putQuery(string $key, $value): BuilderContract
    {
        $query = $this->get(PHP_URL_QUERY);

        if (empty($value)) {
            $value = is_array($value) ? []
                : (! is_numeric($value) ? null : $value);
        }

        $query = Arr::set($query, $key, $value);

        return $this->set(PHP_URL_QUERY, $query);
    }

    /**
     * Return an instance with the specified query object.
     *
     * @param  string  $key
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function removeQuery(string $key): BuilderContract
    {
        $query = $this->get(PHP_URL_QUERY);

        unset($query[$key]);

        return $this->set(PHP_URL_QUERY, $query);
    }

    /**
     * Return an instance with the specified URI fragment.
     *
     * @param  string  $fragment
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function withFragment($fragment): self
    {
        return $this->set(PHP_URL_FRAGMENT, $fragment);
    }

    /**
     * Return an instance with the specified `UriInterface`.
     *
     * @param  \Psr\Http\Message\UriInterface  $uri
     *
     * @return \Helldar\Support\Helpers\Http\Builder
     */
    public function fromPsr(UriInterface $uri): BuilderContract
    {
        $this->parsed = [];

        $this->withScheme($uri->getScheme());
        $this->withHost($uri->getHost());
        $this->withPort($uri->getPort());
        $this->withPath($uri->getPath());
        $this->withQuery($uri->getQuery());
        $this->withFragment($uri->getFragment());

        $auth = explode(':', $uri->getUserInfo());

        $this->withUserInfo(
            $auth[0] ?? null,
            $auth[1] ?? null
        );

        $this->cast($this->parsed);

        return $this;
    }

    /**
     * Return the string representation as a URI reference.
     *
     * @return \Psr\Http\Message\UriInterface
     */
    public function toPsr(): UriInterface
    {
        return $this->same();
    }

    /**
     * Returns parsed data.
     *
     * @return null[]|string[]
     */
    public function toArray(): array
    {
        return [
            'scheme'   => $this->getScheme(),
            'user'     => $this->getUser(),
            'pass'     => $this->getPassword(),
            'host'     => $this->getHost(),
            'port'     => $this->getPort(),
            'path'     => $this->getPath(),
            'query'    => $this->getQuery(),
            'fragment' => $this->getFragment(),
        ];
    }

    /**
     * Return the string representation as a URI reference.
     *
     * @return string
     */
    public function toUrl(): string
    {
        $items = Arrayable::of($this->prepare())
            ->map(function ($value) {
                return (string) $value;
            })
            ->filter()
            ->get();

        $url = implode('', $items);

        return $url === '//' ? '' : $url;
    }

    protected function componentNameByIndex(int $component): ?string
    {
        $this->validateComponentIndex($component);

        return Arr::get($this->components, $component);
    }

    protected function validateComponentIndex(int $component): void
    {
        $components = array_keys($this->components);

        if ($component !== self::PHP_URL_ALL && ! in_array($component, $components, true)) {
            throw new UnknownUrlComponentIndexException($component);
        }
    }

    protected function set(int $component, $value): self
    {
        $this->validate($component, $value);

        $name = $this->componentNameByIndex($component);

        $this->parsed[$name] = $this->castValue($name, $value);

It seems like $name can also be of type null; however, parameter $key of Helldar\Support\Helpers\Http\Builder::castValue() does only seem to accept string, maybe add an additional type check?

        return $this;
    }

    protected function get(int $index)
    {
        $name = $this->componentNameByIndex($index);

        return Arr::get($this->parsed, $name);
    }

    protected function getValidationType(int $component): array
    {
        return Arr::get($this->validate, $component, []);
    }

    protected function validate(int $component, $value): void
    {
        $type = $this->getValidationType($component);

        $this->validateType($value, $type);
    }

    /**
     * Based on code by Maksim (Ellrion) Platonov.
     *
     * @see https://gist.github.com/Ellrion/f51ba0d40ae1d62eeae44fd1adf7b704
     *
     * @return array
     */
    protected function prepare(): array
    {
        return [
            HttpBuilderPrepare::make()->of($this->getScheme())->suffix(':'),

            '//',

            HttpBuilderPrepare::make()->of($this->getUser()),
            HttpBuilderPrepare::make()->of($this->getPassword())->prefix(':'),

            $this->getUser() || $this->getPassword() ? '@' : '',

            HttpBuilderPrepare::make()->of($this->getHost()),
            HttpBuilderPrepare::make()->of($this->getPort())->prefix(':'),
            HttpBuilderPrepare::make()->of($this->getPath()),
            HttpBuilderPrepare::make()->of($this->getQuery())->prefix('?'),
            HttpBuilderPrepare::make()->of($this->getFragment())->prefix('#'),
        ];
    }

    protected function resolveSame(int $component = self::PHP_URL_ALL): self
    {
        return $component === self::PHP_URL_ALL ? new self() : $this;
    }
}