Subreality\Dilmun\Anshar\Http\UriParts\Port

Complexity

Total Complexity

17

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	4
A	__toString()	0	4	1
A	getPort()	0	4	1
A	getValidPattern()	0	4	1
A	isValid()	0	12	3
A	toUriString()	0	12	2
A	normalizePortAgainstScheme()	0	15	2
A	portIsInValidRange()	0	8	3

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

use Subreality\Dilmun\Anshar\Http\SchemePortsTrait;
use Subreality\Dilmun\Anshar\Utils\ArrayHelper;

/**
 * Class Port
 * @package Subreality\Dilmun\Anshar\Http\UriParts
 */
class Port implements UriPartInterface
{
    use SchemePortsTrait;

    protected $port = null;

    protected static $part_pattern  = '[0-9]{0,4}';
    protected static $valid_pattern = '/^[0-9]{0,4}$/';

    /**
     * Port constructor. Accepts an integer or null value representing a URI port component. Construction will throw an
     * exception if port is not an integer or is not null or if the given integer is outside of the allowed TCP/UDP
     * range of 1 to 65535.
     *
     * port = *DIGIT
     *
     * @see https://tools.ietf.org/html/rfc3986#appendix-A
     *
     * @throws \InvalidArgumentException if the given port is not an integer or null or if the given integer is out of
     * range
     *
     * @param int|null $port    A string representing a URI port
     */
    public function __construct($port)
    {
        if (!is_int($port) && !is_null($port)) {
            throw new \InvalidArgumentException("Port must be an integer or null");
        } elseif (!self::isValid($port)) {
            throw new \InvalidArgumentException("Port must be between 1 and 65535 inclusive");
        }

        $this->port = $port;
    }

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

    /**
     * Returns the raw port data
     *
     * @return int|null
     */
    public function getPort()
    {
        return $this->port;
    }

    /**
     * Returns a string representing a valid pattern for a URI port
     *
     * @return string
     */
    public static function getValidPattern()
    {
        return self::$part_pattern;
    }

    /**
     * Validates a given port. A port is valid if it is either null or an integer between 1 and 65535 inclusive.
     *
     * @param mixed $port   The port to be validated
     * @return bool         Returns true if the given port is valid
     *                      Returns false otherwise
     */
    public static function isValid($port)
    {
        $port_valid = false;

        if (is_int($port)) {
            $port_valid = self::portIsInValidRange($port);
        } elseif (is_null($port)) {
            $port_valid = true;
        }

        return $port_valid;
    }

    /**
     * Returns a string representation of the port formatted so that it can be compiled into a complete URI string
     * per the Uri object's string specification.
     *
     * If the port is empty, toUriString returns an empty string; if the port is not empty, toUriString returns the
     * port prefixed with a colon.
     *
     * toUriString will also check the port against an optionally-provided scheme; if the port is standard for the given
     * scheme, toUriString returns an empty 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 port formatted for a complete URI string
     */
    public function toUriString(Scheme $scheme = null)
    {
        $normalized_port = $this->normalizePortAgainstScheme($scheme);

        $uri_string = (string) $normalized_port;

        if (!is_null($normalized_port)) {
            $uri_string = ":" . $uri_string;
        }

        return $uri_string;
    }

    /**
     * Normalizes the port against a given scheme so that the scheme is reported as null if the port is standard for the
     * scheme.
     *
     * For example, given a http scheme and a port of 80, the normalized port will be reported as null; given a https
     * scheme and a port of 80, the normalized port will be reported as 80.
     *
     * @see Port::toUriString()
     * @see SchemePortsTrait
     *
     * @param Scheme|null $scheme
     * @return int|null
     */
    public function normalizePortAgainstScheme(Scheme $scheme = null)
    {
        $scheme_port_array = new ArrayHelper($this->scheme_ports);
        $scheme_string     = (string) $scheme;

        $standard_port = $scheme_port_array->valueLookup($scheme_string);

        if ($this->port == $standard_port) {
            $normalized_port = null;
        } else {
            $normalized_port = $this->port;
        }

        return $normalized_port;
    }

    /**
     * Validates whether a given port falls within the range of valid ports for TCP/UDP (1 to 65535)
     *
     * @param int $port The port to be validated
     *
     * @return bool     Returns true if the port falls within the valid range
     *                  Returns false otherwise
     */
    private static function portIsInValidRange($port)
    {
        if ($port > 0 && $port < 65536) {
            return true;
        } else {
            return false;
        }
    }
}