slickframework / http

src/Message/Uri.php

<?php

declare(strict_types=1);

/**
 * This file is part of slick/http
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Http\Message;

use Psr\Http\Message\UriInterface;
use Slick\Http\Message\Exception\InvalidArgumentException;

/**
 * Uri
 *
 * @package Slick\Http\Message
*/
class Uri implements UriInterface
{
    /** @var array<string, int>|int[]  */
    private array $defaultPorts = [
        'http' => 80,
        'https' => 443
    ];

    /**
     * @var string
     */
    private string $scheme = 'https';

    /**
     * @var string
     */
    private string $host = 'localhost';

    /**
     * @var string
     */
    private int|string $port = '';

    /**
     * @var string
     */
    private string $user = '';

    /**
     * @var string
     */
    private string $pass = '';

    /**
     * @var string
     */
    private string $path = '';

    /**
     * @var string
     */
    private string $query = '';

    /**
     * @var string
     */
    private string $fragment = '';

    /**
     * Creates an URI
     *
     * @param string $url
     *
     * @throws InvalidArgumentException if provided URL is not a valid URL
     *      according to PHP FILTER_VALIDATE_URL
     * @see http://php.net/manual/en/filter.filters.validate.php
     */
    public function __construct(string $url)
    {
        if (!filter_var($url, FILTER_VALIDATE_URL)) {
            throw new InvalidArgumentException(
                "The URL entered is invalid. URI cannot be created."
            );
        }

        /** @var array{scheme?: string, host?: string, port?: int<0, 65535>, user?: string, pass?: string,
         *     path?: string, query?: string, fragment?: string}|false $parsedUrl */
        $parsedUrl = parse_url($url);

        if (!\is_array($parsedUrl) || empty($parsedUrl)) {

The condition is_array($parsedUrl) is always true.

            throw new InvalidArgumentException(
                "The URL entered is invalid. URI cannot be created."
            );
        }

        foreach ($parsedUrl as $property => $value) {
            if (property_exists($this, $property)) {
                // Normaliza todos os valores para string antes de atribuir
                $this->$property = (string) $value;
            }
        }

        foreach ($parsedUrl as $property => $value) {
            $this->$property = $value;
        }
    }

    /**
     * Retrieve the scheme component of the URI.
     *
     * @see https://tools.ietf.org/html/rfc3986#section-3.1
     * @return string The URI scheme.
     */
    public function getScheme(): string
    {
        return strtolower($this->scheme);
    }

    /**
     * Retrieve the authority component of the URI.
     *
     * @return string The URI authority, in "[user-info@]host[:port]" format.
     */
    public function getAuthority(): string
    {
        $authority = $this->getUserInfo() !== ''
            ? "{$this->getUserInfo()}@{$this->getHost()}"
            : "{$this->getHost()}";
        return $this->getPort() ? "$authority:{$this->getPort()}" : $authority;
    }

    /**
     * Retrieve the user information component of the URI.
     *
     * @return string The URI user information, in "username[:password]" format.
     */
    public function getUserInfo(): string
    {
        $userInfo = $this->user ?: '';
        return $this->pass ? "$userInfo:$this->pass" : $userInfo;
    }

    /**
     * Retrieve the host component of the URI.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-3.2.2
     * @return string The URI host.
     */
    public function getHost(): string
    {
        return strtolower($this->host);
    }

    /**
     * Retrieve the port component of the URI.
     *
     * @return null|int The URI port.
     */
    public function getPort(): ?int
    {
        $default = \array_key_exists($this->getScheme(), $this->defaultPorts)
            ? $this->defaultPorts[$this->getScheme()]
            : -1;

        if ((string) $default === (string) $this->port) {
            return null;
        }

        return (int) $this->port;
    }

    /**
     * Retrieve the path component of the URI.
     *
     * @see https://tools.ietf.org/html/rfc3986#section-2
     * @see https://tools.ietf.org/html/rfc3986#section-3.3
     * @return string The URI path.
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * Retrieve the query string of the URI.
     *
     * @see https://tools.ietf.org/html/rfc3986#section-2
     * @see https://tools.ietf.org/html/rfc3986#section-3.4
     * @return string The URI query string.
     */
    public function getQuery(): string
    {
        return $this->query;
    }

    /**
     * Retrieve the fragment component of the URI.
     *
     * @see https://tools.ietf.org/html/rfc3986#section-2
     * @see https://tools.ietf.org/html/rfc3986#section-3.5
     * @return string The URI fragment.
     */
    public function getFragment(): string
    {
        return $this->fragment;
    }

    /**
     * Return an instance with the specified scheme.
     *
     * @param string $scheme The scheme to use with the new instance.
     * @return static A new instance with the specified scheme.
     * @throws \InvalidArgumentException for invalid or unsupported schemes.
     */
    public function withScheme(string $scheme): UriInterface
    {
        $this->validateCharacters($scheme);

        $uri = clone $this;
        $uri->scheme = $scheme;
        return $uri;
    }

    /**
     * Return an instance with the specified user information.
     *
     * @param string $user The user name to use for authority.
     * @param string|null $password The password associated with $user.
     * @return static A new instance with the specified user information.
     */
    public function withUserInfo(string $user, ?string $password = null): UriInterface
    {
        $uri = clone $this;
        $uri->user = $user;
        $uri->pass = (string) $password;
        return $uri;
    }

    /**
     * Return an instance with the specified host.
     *
     * @param string $host The hostname to use with the new instance.
     * @return static A new instance with the specified host.
     * @throws \InvalidArgumentException for invalid hostnames.
     */
    public function withHost(string $host): UriInterface
    {
        $this->validateCharacters($host);

        $uri = clone $this;
        $uri->host = $host;
        return $uri;
    }

    /**
     * Return an instance with the specified port.
     *
     * @param int|null $port The port to use with the new instance; a null value
     *     removes the port information.
     * @return static A new instance with the specified port.
     * @throws \InvalidArgumentException for invalid ports.
     */
    public function withPort(?int $port): UriInterface
    {
        $uri = clone $this;
        $uri->port = (int) $port;
        return $uri;
    }

    /**
     * Return an instance with the specified path.
     *
     * @param string $path The path to use with the new instance.
     * @return static A new instance with the specified path.
     * @throws \InvalidArgumentException for invalid paths.
     */
    public function withPath(string $path): UriInterface
    {
        $uri = clone $this;
        $uri->path = $path;
        return $uri;
    }

    /**
     * Return an instance with the specified query string.
     *
     * An empty query string value is equivalent to removing the query string.
     *
     * @param string $query The query string to use with the new instance.
     * @return static A new instance with the specified query string.
     * @throws \InvalidArgumentException for invalid query strings.
     */
    public function withQuery(string $query): UriInterface
    {
        $uri = clone $this;
        $uri->query = $query;
        return $uri;
    }

    /**
     * Return an instance with the specified URI fragment.
     *
     * An empty fragment value is equivalent to removing the fragment.
     *
     * @param string $fragment The fragment to use with the new instance.
     * @return static A new instance with the specified fragment.
     */
    public function withFragment(string $fragment): UriInterface
    {
        $uri = clone $this;
        $uri->fragment = $fragment;
        return $uri;
    }

    /**
     * Return the string representation as a URI reference.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-4.1
     * @return string
     */
    public function __toString(): string
    {
        $text  = $this->scheme ? "{$this->getScheme()}:" : '';
        $text .= $this->getAuthority() !== ''
            ? "//{$this->getAuthority()}"
            : '';
        $text .= '/'. ltrim($this->getPath(), '/');
        $text .= \strlen($this->query) > 0 ? "?$this->query" : '';
        $text .= \strlen($this->fragment) > 0 ? "#$this->fragment" : '';
        return $text;
    }

    /**
     * Check the provided text for invalid characters
     *
     * @param string $text
     */
    private function validateCharacters(string $text): void
    {
        $regex = '/^[a-z][a-z0-9.+\-]*/i';
        if ($text !== '' && ! preg_match($regex, $text)) {
            throw new InvalidArgumentException(
                "Invalid characters used in URI."
            );
        }
    }
}