Subreality\Dilmun\Anshar\Http\UriParts\Authority

Complexity

Total Complexity

11

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	getUserInfo()	0	4	1
A	getHost()	0	4	1
A	getPort()	0	4	1
A	__toString()	0	4	1
A	toUriString()	0	12	2
A	compileValidPattern()	0	16	1
A	explodeAuthority()	0	18	2

<?php
namespace Subreality\Dilmun\Anshar\Http\UriParts;

/**
 * Class Authority
 * @package Subreality\Dilmun\Anshar\Http\UriParts
 */
class Authority extends AbstractUriPart
{
    /** @var  UserInfo */
    protected $user_info;
    /** @var  Host */
    protected $host;
    /** @var  Port */
    protected $port;

    protected $authority_parts = array(
        "user_info" => "",
        "host"      => "",
        "port"      => null,
    );

    protected static $part_pattern;
    protected static $valid_pattern;

    /** @noinspection PhpMissingParentConstructorInspection */
    /**
     * Authority constructor. Accepts a string representing a URI authority component. Construction will throw an
     * exception if the authority is not a string.
     *
     * Construction splits a given authority string into its component objects, UserInfo, Host, and Port, whose
     * individual constructors may throw exceptions provided invalid component strings.
     *
     * Construction accepts strings for UserInfo and Host that have been percent-encoded as well as strings that have
     * not been percent-encoded and will encode invalid characters.
     *
     * Construction with a string that includes both encoded and decoded characters will be assumed to be an encoded
     * string, resulting in double-encoding.
     *
     * authority = [ userinfo "@" ] host [ ":" port ]
     *
     * @see UserInfo
     * @see Host
     * @see Port
     * @see https://tools.ietf.org/html/rfc3986#appendix-A
     *
     * @throws \InvalidArgumentException given a non-string
     *
     * @param string $authority A string representing a URI authority
     */
    public function __construct($authority)
    {
        if (!is_string($authority)) {
            throw new \InvalidArgumentException("Authority must be a string");
        } else {
            $exploded_authority = $this->explodeAuthority($authority);

            $this->authority_parts = array_merge($this->authority_parts, $exploded_authority);

            $this->user_info = new UserInfo($this->authority_parts["user_info"]);
            $this->host      = new Host($this->authority_parts["host"]);
            $this->port      = new Port($this->authority_parts["port"]);
        }
    }

    /**
     * Returns the authority's UserInfo object
     *
     * @return UserInfo
     */
    public function getUserInfo()
    {
        return $this->user_info;
    }

    /**
     * Returns the authority's Host object
     *
     * @return Host
     */
    public function getHost()
    {
        return $this->host;
    }

    /**
     * Returns the authority's Port object
     *
     * @return Port
     */
    public function getPort()
    {
        return $this->port;
    }

    /**
     * Returns a string representation of the authority
     *
     * @return string   A string representation of the authority
     */
    public function __toString()
    {
        return $this->user_info->toUriString() . $this->host->toUriString() . $this->port->toUriString();
    }

    /**
     * Returns a string representation of the authority formatted so that it can be compiled into a complete URI string
     * per the Uri object's string specification.
     *
     * If the user info is empty, toUriString returns an authority string with no user info; otherwise, toUriString
     * returns the user info suffixed with an at symbol.
     *
     * If the port is empty, toUriString returns an authority string with no port; otherwise, toUriString returns the
     * port prefixed with a colon.
     *
     * If the authority overall is empty, toUriString returns an empty string; otherwise, toUriString returns the entire
     * authority string prefixed with two slashes.
     *
     * toUriString will also check the port against an optionally-provided scheme; if the port is standard for the given
     * scheme, toUriString will not include the port within the authority string.
     *
     * @see Uri::__toString
     *
     * @param Scheme|null $scheme   [optional] A scheme against which to check if the port is the standard
     *
     * @return string               A string representation of the authority formatted for a complete URI string
     */
    public function toUriString(Scheme $scheme = null)
    {
        $authority_string = $this->user_info->toUriString() .
            $this->host->toUriString() .
            $this->port->toUriString($scheme);

        if (!empty($authority_string)) {
            $authority_string = "//" . $authority_string;
        }

        return $authority_string;
    }

    /**
     * Compiles a valid pattern for an authority based upon valid patterns for user info, host, and port.
     *
     * @return void
     */
    protected static function compileValidPattern()
    {
        $user_info_pattern = UserInfo::getValidPattern();
        $host_pattern      = Host::getValidPattern();
        $port_pattern      = Port::getValidPattern();

        $reg_start = '/^$|^';   //allow for empty authority
        $reg_end   = '$/';

        self::$part_pattern =
            '((?\'user_info\'' . $user_info_pattern . ')@)?' .
            '(?\'host\'' . $host_pattern . ')' .
            '(:(?\'port\'' . $port_pattern . '))?';

        self::$valid_pattern = $reg_start . self::$part_pattern . $reg_end;
    }

    /**
     * Splits URI authority data into user info, host, and port data, returning an array with named keys.
     *
     * For the host component, it will capture everything within brackets to support ipv6 or match all characters until
     * it finds a colon indicating the start of the port component.
     *
     * @param string $authority     The authority part of a URI to be decomposed
     * @return mixed[]              An array with named keys containing the component parts of the supplied

Should the return type not be array<*,string|integer|null>?

     *                              authority
     */
    protected function explodeAuthority($authority)
    {
        $reg_start      = '/^';
        $user_info_part = '(?:(?\'user_info\'.+)@)?';
        $host_part      = '(?\'host\'\[.+\]|.[^:]+)';
        $port_part      = '(?::(?\'port\'[0-9]+))?';
        $reg_end        = '/';

        $authority_syntax = $reg_start . $user_info_part . $host_part . $port_part . $reg_end;

        preg_match($authority_syntax, $authority, $authority_parts);

        if (isset($authority_parts["port"])) {
            $authority_parts["port"] = (int) $authority_parts["port"];
        }

        return $authority_parts;
    }
}