Uri::getHost() - Code Metrics - dmt-software/aura-web-psr - Measure and Improve Code Quality continuously with Scrutinizer

Uri::getHost() A
last analyzed 2021-12-31 16:34 UTC

↳ Parent: Uri
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php

namespace DMT\Aura\Psr\Message;

use Aura\Web\Exception\InvalidComponent;
use Aura\Web\Request\Url as AuraUrl;
use DMT\Aura\Psr\Helpers\HelperFactory;
use InvalidArgumentException;
use Psr\Http\Message\UriInterface;

/**
 * Class Uri
 *
 * @package DMT\Aura\Psr\Message
 */
class Uri implements UriInterface
{
    /** Url components */
    const URI_COMPONENTS = [
        PHP_URL_SCHEME => 'scheme',
        PHP_URL_HOST => 'host',
        PHP_URL_PORT => 'port',
        PHP_URL_USER => 'user',
        PHP_URL_PASS => 'pass',
        PHP_URL_PATH => 'path',
        PHP_URL_QUERY => 'query',
        PHP_URL_FRAGMENT => 'fragment',
    ];

    /** Default ports for schemes. */
    const DEFAULT_PORTS = [
        'http' => 80,
        'https' => 443,
    ];

    /** @var AuraUrl $object */
    protected $object;

    /**
     * Uri constructor.
     *
     * @param string|null $uri
     */
    public function __construct(string $uri = null)
    {
        $object = $this->getInnerObject();

        if ($uri) {
            (new HelperFactory())
                ->createHelper($object)
                ->setObjectProperty('parts', parse_url($uri));
        }
    }

    /**
     * @return AuraUrl
     */
    public function getInnerObject(): AuraUrl
    {
        if (!$this->object) {
            $this->object = new AuraUrl([]);
        }
        return $this->object;
    }


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

    /**
     * Retrieve the authority component of the URI.
     *
     * @return string
     */
    public function getAuthority(): string
    {
        $authority = '';

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

            $authority .= $host;

            $port = $this->getPort();
            if ($port !== null) {
                $authority .= ':' . $port;
            }
        }

        return $authority;
    }

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

        $userInfo = '';
        if ($user !== '') {
            $userInfo .= $user;
            if ($pass !== '') {
                $userInfo .= ':' . $pass;
            }
        }


        return $userInfo;
    }

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

    /**
     * Retrieve the port component of the URI.
     *
     * @return null|int
     */
    public function getPort()
    {
        $port = $this->urlGet(PHP_URL_PORT, null);
        if ($port == (self::DEFAULT_PORTS[$this->getScheme()] ?? null)) {
            $port = null;
        }

        return $port > 0 ? (int)$port : null;
    }

    /**
     * Retrieve the path component of the URI.
     *
     * @return string
     */
    public function getPath(): string
    {
        $path = $this->urlGet(PHP_URL_PATH);
        if (empty($path)) {
            return '';
        }

        $paths = array_map([$this, 'decode'], explode('/', $path));

        return implode('/', array_map('rawurlencode', $paths));
    }

    /**
     * Retrieve the query string of the URI.
     *
     * @return string
     */
    public function getQuery(): string
    {
        $query = $this->urlGet(PHP_URL_QUERY);
        if ($query === '') {
            return '';
        }

        parse_str($query, $params);

        $params = array_map([$this, 'decode'], $params);

        return preg_replace('~=(&|$)~', "$1", http_build_query($params, '', '&', PHP_QUERY_RFC3986));
    }

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

    /**
     * Return an instance with the specified scheme.
     *
     * @param string $scheme
     * @return static
     * @throws InvalidArgumentException
     */
    public function withScheme($scheme): self
    {
        if (!is_string($scheme) || !preg_match('~[a-z]~i', $scheme)) {

            throw new InvalidArgumentException('invalid scheme given');
        }

        return  $this->urlSet(PHP_URL_SCHEME, strtolower($scheme) . '://');
    }

    /**
     * Return an instance with the specified user information.
     *
     * @param string $user
     * @param null|string $password
     * @return static
     */
    public function withUserInfo($user, $password = null): self
    {
        if (!is_string($user) || $user === '') {

            throw new InvalidArgumentException('invalid user given');
        }

        if (!is_string($password) && !is_null($password)) {

            throw new InvalidArgumentException('invalid password given');
        }

        return $this
            ->urlSet(PHP_URL_USER, $user)
            ->urlSet(PHP_URL_PASS, $password);
            ->urlSet(PHP_URL_PASS, /** @scrutinizer ignore-type */ $password);
    }

    /**
     * Return an instance with the specified host.
     *
     * @param string $host
     * @return static
     * @throws InvalidArgumentException
     */
    public function withHost($host): self
    {
        if (!is_string($host)) {

            throw new InvalidArgumentException('invalid host given');
        }

        return $this->urlSet(PHP_URL_HOST, $host);
    }

    /**
     * Return an instance with the specified port.
     *
     * @param null|int $port
     * @return static
     * @throws InvalidArgumentException
     */
    public function withPort($port): self
    {
        if (is_null($port)) {
            return $this->urlSet('port', '');
            return $this->urlSet(/** @scrutinizer ignore-type */ 'port', '');
        }

        if (!is_int($port) || $port < 1) {

            throw new InvalidArgumentException('invalid post given');
        }

        return $this->urlSet(PHP_URL_PORT, $port);
    }

    /**
     * Return an instance with the specified path.
     *
     * @param string $path
     * @return static
     * @throws InvalidArgumentException
     */
    public function withPath($path): self
    {
        if (!is_string($path)) {

            throw new InvalidArgumentException('invalid path given');
        }

        return $this->urlSet(PHP_URL_PATH, $path);
    }

    /**
     * Return an instance with the specified query string.
     *
     * @param string $query
     * @return static
     * @throws InvalidArgumentException
     */
    public function withQuery($query): self
    {
        if (!is_string($query)) {

            throw new InvalidArgumentException('invalid path given');
        }

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

    /**
     * Return an instance with the specified URI fragment.
     *
     * @param string $fragment
     * @return static
     */
    public function withFragment($fragment): self
    {
        if (!is_string($fragment)) {

            throw new InvalidArgumentException('invalid fragment given');
        }

        return $this->urlSet(PHP_URL_FRAGMENT, $fragment);
    }

    /**
     * Return the string representation as a URI reference.
     *
     * @return string
     */
    public function __toString(): string
    {
        $scheme = $this->getScheme();
        $authority = $this->getAuthority();
        $path = $this->getPath();
        $query = $this->getQuery();
        $fragment = $this->getFragment();

        $uri = '';
        if ($scheme !== '') {
            $uri .= $scheme . ':';
        }

        if ($authority !== '') {
            $uri .= '//' . $authority;
        }

        $uri .= '/' . ltrim($path, ' /');

        if ($query !== '') {
            $uri .= '?' . $query;
        }

        if ($fragment !== '') {
            $uri .= '#' . $fragment;
        }

        return $uri;
    }

    /**
     * Decode a value.
     *
     * @param array|string $data
     * @return array|string
     */
    protected function decode($data)
    {
        if (is_array($data)) {
            return array_map([$this, __FUNCTION__], $data);
        }
        return rawurldecode((string)$data);
    }

    /**
     * Get a url part.
     *
     * @param int $component
     * @param string|null $default
     * @return string|null
     */
    private function urlGet(int $component, $default = '')
    {
        try {
            return $this->object->get($component) ?? $default;
        } catch (InvalidComponent $exception) {
            return $default;
        }
    }

    /**
     * Store a url part.
     *
     * @param string|int $component
     * @param string|null $value
     * @return static
     */
    private function urlSet(int $component, string $value): self
    {
        $component = [self::URI_COMPONENTS[$component] => $value];

        $instance = clone($this);

        $helper = (new HelperFactory())->createHelper($instance->getInnerObject());
        $helper->setObjectProperty('parts', $component + $helper->getObjectProperty('parts', []));
        $helper->setObjectProperty('string', (string)$instance);
        if ($component === PHP_URL_SCHEME) {

            $helper->getObjectProperty('secure', stripos($value, 'https') === 0);
        }

        return $instance;
    }
}

dmt-software / aura-web-psr

Uri::getHost() A last analyzed 2021-12-31 16:34 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Uri::getHost() A
last analyzed 2021-12-31 16:34 UTC
