Subreality\Dilmun\Anshar\Http\UriParts\Path

Complexity

Total Complexity

14

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	toUriString()	0	10	2
A	validatePathAgainstAuthority()	0	10	3
A	checkPathIsString()	0	6	2
A	startsWithSlash()	0	8	1
A	normalizePathWithAuthority()	0	14	3
A	collapseStartingSlashes()	0	10	2

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

use Subreality\Dilmun\Anshar\Utils\StringHelper;

/**
 * Class Path
 * @package Subreality\Dilmun\Anshar\Http\UriParts
 */
class Path extends AbstractUriPart
{
    protected static $unencoded_characters = array('/');

    protected static $compositions = array(
        "unreserved_characters",
        "sub_delims_characters",
        "pchar_characters",
    );

    protected static $part_pattern;

    /**
     * Host constructor. Accepts a string representing a URI host component. Construction will throw an exception if
     * the host is not a string.
     *
     * path-abempty  = *( "/" segment )
     * path-absolute = "/" [ segment-nz *( "/" segment ) ]
     * path-noscheme = segment-nz-nc *( "/" segment )
     * path-rootless = segment-nz *( "/" segment )
     * path-empty    = 0<pchar>
     *
     * segment       = *pchar
     * segment-nz    = 1*pchar
     * segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
     * ; non-zero-length segment without any colon ":"
     *
     * pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
     *
     * @param string $path
     */
    public function __construct($path)
    {
        parent::__construct($path, "Path");
    }

    /**
     * Returns a string representation of the path formatted so that it can be compiled into a complete URI string
     * per the Uri object's string specification.
     *
     * If the path is empty, toUriString returns an empty string; if the path is not empty, toUriString returns the
     * path with one or more rules applied against an optional Authority to determine starting slashes:
     *
     * - If the path is rootless and an authority is present, the path MUST be prefixed by "/".
     * - If the path is starting with more than one "/" and no authority is present, the starting slashes MUST be
     *   reduced to one.
     *
     * @see Uri::__toString
     *
     * @param Authority|null $authority     [optional] An authority against which to derive starting slash rules
     *
     * @return string                       A string representation of the path formatted for a complete URI string
     */
    public function toUriString(Authority $authority = null)
    {
        $path_string = parent::toUriString();

        if (!empty($this->data)) {
            $path_string = $this->normalizePathWithAuthority($authority);
        }

        return $path_string;
    }

    /**
     * Validates whether a given path string conforms to the URI specification for a path provided an optional
     * authority. If a non-empty path is provide along with a non-empty authority, the path must begin with a slash.
     *
     * Note that validatePathAgainstAuthority only validates that a path conforms to the slash requirement and not the
     * validity of the path in general. For general path validation, use Path::isValid.
     *
     * @see Path::isValid
     * @see Uri::withPath
     *
     * @throws \InvalidArgumentException provided a non-string path.
     *
     * @param string $path_string           A path string
     * @param Authority|null $authority     [optional] An authority against which to check the path for validity
     *
     * @return bool
     */
    public static function validatePathAgainstAuthority($path_string, Authority $authority = null)
    {
        self::checkPathIsString($path_string);

        if (!empty((string) $path_string) && !empty((string) $authority)) {
            return self::startsWithSlash($path_string);
        }

        return true;
    }

    /**
     * Throws an InvalidArgumentException if the given path is not a string.
     *
     * @throws \InvalidArgumentException given a non-string path.
     *
     * @param string $path  The path to be checked
     *
     * @return void
     */
    private static function checkPathIsString($path)
    {
        if (!is_string($path)) {
            throw new \InvalidArgumentException("Path must be a string");
        }
    }

    /**
     * Checks whether a given path string starts with a slash.
     *
     * @throws \InvalidArgumentException given a non-string path.
     *
     * @param string $path  The path to be checked
     *
     * @return bool         Returns true if the path starts with a slash
     *                      Returns false if the path does not start with a slash
     */
    private static function startsWithSlash($path)
    {
        self::checkPathIsString($path);

        $path = new StringHelper($path);

        return $path->startsWith("/");
    }

    /**
     * Determines whether a given authority should begin with a slash provided an Authority.
     *
     * @see Path::toUriString
     *
     * @param Authority|null $authority     [optional] An authority against which to derive starting slash rules
     *
     * @return string                       The path string with appropriate starting slash rules applied
     */
    private function normalizePathWithAuthority(Authority $authority = null)
    {
        $path_string = $this->collapseStartingSlashes($this->data, $authority);

        $path_string = new StringHelper($path_string);

        if (!empty((string) $authority)) {
            if (!$path_string->startsWith("/")) {
                $path_string = "/" . $this->data;
            }
        }

        return (string) $path_string;
    }

    /**
     * Collapses starting slashes within a path if necessary given rules associated with an optional Authority.
     *
     * @see Path::toUriString
     *
     * @param string $path_string           The path string to process
     * @param Authority|null $authority     [optional] An authority against which to derive starting slash rules
     *
     * @return string                       The path string with appropriate starting slash rules applied
     */
    private function collapseStartingSlashes($path_string, Authority $authority = null)
    {
        $path_string = new StringHelper($path_string);

        if (empty((string) $authority)) {
            $path_string = $path_string->collapseStartingRepetition("/");
        }

        return (string) $path_string;
    }
}