Subreality\Dilmun\Anshar\Http\UriParts\AbstractUriPart

Complexity

Total Complexity

14

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

82%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	4	1
A	__construct()	0	10	3
A	getValidPattern()	0	6	1
A	isValid()	0	8	1
A	toUriString()	0	4	1
A	encode()	0	12	2
A	compileValidPattern()	0	21	2
A	compileUnencodedCharacters()	0	12	3

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

use Subreality\Dilmun\Anshar\Utils\StringHelper;

/**
 * Class AbstractUriPart
 * @package Subreality\Dilmun\Anshar\Http\UriParts
 */
abstract class AbstractUriPart implements UriPartInterface
{
    protected static $unreserved_pattern  = '\w\-\.~';
    protected static $pct_encoded_pattern = '%[A-Fa-f0-9]{2}';
    protected static $sub_delims_pattern  = '\!\$&\'\(\)\*\+,;\=';
    protected static $pchar_pattern       = '\:@';

    protected static $unreserved_characters = array("_", "-", ".", "~");
    protected static $pchar_characters      = array(":", "@");

    protected static $sub_delims_characters = array(
        "!",
        "$",
        "&",
        "'",
        "(",
        ")",
        "*",
        "+",
        ",",
        ";",
        "=",
    );

    protected $data = "";

    protected static $part_pattern;

    /**
     * Provides a common composition of allowed characters for validation and encoding.
     *
     * @see AbstractUriPart::compileUnencodedCharacters()
     * @see AbstractUriPart::compileValidPattern()
     *
     * @var array
     */
    protected static $compositions = array(
        "unreserved_characters",
        "pchar_characters",
        "sub_delims_characters",
    );

    protected static $unencoded_characters = array();

    protected static $valid_pattern;

    /**
     * Constructor for URI parts.
     *
     * Note that, if overriding the abstract class's constructor, care should be taken to compile unencoded characters
     * prior to compiling the part's valid pattern, as the default behavior of the abstract class is to base the part's
     * validation pattern on compiled unencoded characters.
     *
     * @see AbstractUriPart::compileUnencodedCharacters()
     * @see AbstractUriPart::compileValidPattern()
     *
     * @param string $part_data The data used to construct a URI part
     * @param string $part_name The name of the URI part for exception reporting
     * @param string $part_type [optional] The expected type of the URI part
     */
    public function __construct($part_data, $part_name, $part_type = "string")
    {
        if (gettype($part_data) != $part_type) {
            throw new \InvalidArgumentException("{$part_name} must be a {$part_type}");
        } elseif (!static::isValid($part_data)) {
            $part_data = $this->encode($part_data);
        }

        $this->data = $part_data;
    }

    /**
     * Returns a string representation of the URI component
     *
     * @return string   A string representation of the URI component
     */
    public function __toString()
    {
        return (string) $this->data;
    }

    /**
     * Returns a string representing a valid pattern for the URI component
     *
     * @return string
     */
    public static function getValidPattern()
    {
        static::compileValidPattern();

        return static::$part_pattern;
    }

    /**
     * Determines whether a given string adheres to the RFC3986 specification for the extending URI part.
     *
     * Requires extending classes to define self::$valid_pattern.
     *
     * @see https://tools.ietf.org/html/rfc3986#appendix-A
     *
     * @param mixed $data   The data to check for validity
     *
     * @return bool         Returns true if the provided query matches the RFC3986 specification
     *                      Returns false otherwise
     */
    public static function isValid($data)
    {
        static::compileValidPattern();

        $pattern_found = preg_match(static::$valid_pattern, $data, $matches);

        return (bool) $pattern_found;
    }

    /**
     * @return string
     */
    public function toUriString()
    {
        return (string) $this;
    }

    /**
     * Percent-encodes invalid characters within a given string. Percent-encoding ignores valid as defined by the
     * component per RFC3986.
     *
     * @see https://tools.ietf.org/html/rfc3986#appendix-A
     *
     * @param string $string     The query string to be percent-encoded
     *
     * @return string            The query string with invalid characters percent-encoded
     */
    protected function encode($string)
    {
        $encoded_query = $string;

        if (!empty(static::$unencoded_characters)) {
            $string_helper = new StringHelper($string);

            $encoded_query = $string_helper->affectChunks("rawurlencode", ...static::$unencoded_characters);
        }

        return $encoded_query;
    }

    /**
     * Creates a validation pattern based upon a URI part's unencoded characters, allowing for empty strings (^$),
     * word characters (\w), and percent encoding by default.
     *
     * @see AbstractUriPart::compileUnencodedCharacters()
     *
     * @return void
     */
    protected static function compileValidPattern()
    {
        static::compileUnencodedCharacters();

        $valid_characters = implode(static::$unencoded_characters);

        if (empty(static::$part_pattern)) {
            static::$part_pattern = '([\w';   //start decoded group

            static::$part_pattern = static::$part_pattern . preg_quote($valid_characters, "/");

            static::$part_pattern = static::$part_pattern .
                ']|' .                          //predefined patterns or percent-encoding
                self::$pct_encoded_pattern .
                ')*';
        }

        static::$valid_pattern = '/^$|^' . //allows part to be empty
            static::$part_pattern .
            '$/';
    }

    /**
     * Compiles unencoded characters provided a URI part's composition, as defined by its compositions property.
     * Note that unencoded characters form the basis for the URI part's validation pattern.
     *
     * @see AbstractUriPart::compileValidPattern()
     *
     * @return void
     */
    protected static function compileUnencodedCharacters()
    {
        foreach (static::$compositions as $composition) {
            $composition_characters = self::${$composition};

            $delta = array_diff($composition_characters, static::$unencoded_characters);

            if (!empty($delta)) {
                static::$unencoded_characters = array_merge(static::$unencoded_characters, self::${$composition});
            }
        }
    }
}