URI.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\Data;
 
class URI
{
    protected $schema;
    protected $host;
    protected $port;
    protected $path;
    protected $query;
    protected $fragment;
 
    const PATH_DELIM = '/';
 
    const ALPHA = '[A-Za-z]';
    const DIGIT = '[0-9]';
    const ALPHA_DIGIT = '[A-Za-z0-9]';
    const HEXDIG = '[0-9A-Fa-f]';
    const PCTENCODED = '%' . self::HEXDIG . self::HEXDIG;
    const PIMP = '[\\+\\-\\.]';
 
    const SUBDELIMS = '[\\$,;=!&\'\\(\\)\\*\\+]';
    const BASEURI_SUBDELIMS = '[\\$,;&\'\\*]';
 
    const UNRESERVED = self::ALPHA_DIGIT . '|[\\-\\._~]';
    const UNRESERVED_NO_DOT = self::ALPHA_DIGIT . '|[\\-_~]';
 
    const PCHAR = self::UNRESERVED . '|' . self::SUBDELIMS . '|' . self::PCTENCODED . '|:|@';
    const BASEURI_PCHAR = self::UNRESERVED . '|' . self::BASEURI_SUBDELIMS . '|' . self::PCTENCODED . '|:|@';
 
    const SCHEMA = '#^' . self::ALPHA . '(' . self::ALPHA_DIGIT . '|' . self::PIMP . ')*$#';
    const DOMAIN_LABEL = self::ALPHA_DIGIT . '((' . self::UNRESERVED_NO_DOT . '|' . self::PCTENCODED . '|' . self::BASEURI_SUBDELIMS . ')*' . self::ALPHA_DIGIT . ')*';
    const HOST_REG_NAME = '^' . self::DOMAIN_LABEL . '(\\.' . self::DOMAIN_LABEL . ')*$';
    const HOST_IPV4 = '^(' . self::DIGIT . '{1,3})(\\.' . self::DIGIT . '{1,3}){3}$';
    const HOST = '#' . self::HOST_IPV4 . '|' . self::HOST_REG_NAME . '#';
    const PORT = '#^' . self::DIGIT . '+$#';
    const PATH = '#^(?!//)(?!:)(' . self::PCHAR . '|' . self::PATH_DELIM . ')+$#';
    const QUERY = '#^(' . self::PCHAR . '|' . self::PATH_DELIM . '|\\?)+$#';
    const FRAGMENT = '#^(' . self::PCHAR . '|' . self::PATH_DELIM . '|\\?|\\#)+$#';
 
    public function __construct(string $uri_string)
    {
        $this->schema = $this->digestSchema(parse_url($uri_string, PHP_URL_SCHEME));
        $this->host = $this->digestHost(parse_url($uri_string, PHP_URL_HOST));
        $this->port = $this->digestPort(parse_url($uri_string, PHP_URL_PORT));
        $this->path = $this->digestPath(parse_url($uri_string, PHP_URL_PATH));
        $this->query = $this->digestQuery(parse_url($uri_string, PHP_URL_QUERY));
        $this->fragment = $this->digestFragment(parse_url($uri_string, PHP_URL_FRAGMENT));
    }
 
    protected function digestSchema(string $schema) : string
    {
        return $this->checkCorrectFormatOrThrow(self::SCHEMA, (string) $schema);
    }
 
    protected function digestHost(string $host) : string
    {
        return $this->checkCorrectFormatOrThrow(self::HOST, (string) $host);
    }
 
    protected function digestPort(int $port = null)
    {
        if ($port === null) {
            return null;
        }
        return $port;
    }
 
    protected function digestPath(string $path = null)
    {
        if ($path === null) {
            return null;
        }
        $path = trim($this->checkCorrectFormatOrThrow(self::PATH, $path), self::PATH_DELIM);
        if ($path === '') {
            $path = null;
        }
        return $path;
    }
 
    protected function digestQuery(string $query = null)
    {
        if ($query === null) {
            return null;
        }
        return $this->checkCorrectFormatOrThrow(self::QUERY, $query);
    }
 
    protected function digestFragment(string $fragment = null)
    {
        if ($fragment === null) {
            return null;
        }
        return $this->checkCorrectFormatOrThrow(self::FRAGMENT, $fragment);
    }
 
 
    protected function checkCorrectFormatOrThrow(string $regexp, string $string)
    {
        if (preg_match($regexp, (string) $string) === 1) {
            return $string;
        }
        throw new \InvalidArgumentException('ill-formated component "' . $string . '" expected "' . $regexp . '"');
    }
 
    public function getSchema() : string
    {
        return $this->schema;
    }
 
    public function withSchema(string $schema) : URI
    {
        $shema = $this->digestSchema($schema);
        $other = clone $this;
        $other->schema = $schema;
        return $other;
    }
 
 
    public function getAuthority() : string
    {
        $port = $this->getPort();
        if ($port === null) {
            return $this->getHost();
        }
        return $this->getHost() . ':' . $port;
    }
 
 
    public function withAuthority(string $authority) : URI
    {
        $parts = explode(':', $authority);
        if (count($parts) > 2) {
            throw new \InvalidArgumentException('ill-formated component ' . $authority);
        }
        $host = $this->digestHost($parts[0]);
        $port = null;
        if (array_key_exists(1, $parts)) {
            $port = (int) $this->checkCorrectFormatOrThrow(self::PORT, (string) $parts[1]);
        }
        $other = clone $this;
        $other->host = $host;
        $other->port = $port;
        return $other;
    }
 
    public function getPort()
    {
        return $this->port;
    }
 
    public function withPort(int $port = null) : URI
    {
        $port = $this->digestPort($port);
        $other = clone $this;
        $other->port = $port;
        return $other;
    }
 
    public function getHost() : string
    {
        return $this->host;
    }
 
    public function withHost(string $host) : URI
    {
        $host = $this->digestHost($host);
        $other = clone $this;
        $other->host = $host;
        return $other;
    }
 
 
    public function getPath()
    {
        return $this->path;
    }
 
    public function withPath(string $path = null) : URI
    {
        $path = $this->digestPath($path);
        $other = clone $this;
        $other->path = $path;
        return $other;
    }
 
    public function getQuery()
    {
        return $this->query;
    }
 
    public function withQuery(string $query = null) : URI
    {
        $query = $this->digestQuery($query);
        $other = clone $this;
        $other->query = $query;
        return $other;
    }
 
    public function getFragment()
    {
        return $this->fragment;
    }
 
    public function withFragment(string $fragment = null) : URI
    {
        $fragment = $this->digestFragment($fragment);
        $other = clone $this;
        $other->fragment = $fragment;
        return $other;
    }
 
    public function getBaseURI() : string
    {
        $path = $this->getPath();
        if ($path === null) {
            return $this->getSchema() . '://' . $this->getAuthority();
        }
        return $this->getSchema() . '://' . $this->getAuthority() . '/' . $path;
    }
 
    public function __toString() : string
    {
        $uri = $this->getBaseURI();
        $query = $this->getQuery();
        if ($query) {
            $uri .= '?' . $query;
        }
        $fragment = $this->getFragment();
        if ($fragment) {
            $uri .= '#' . $fragment;
        }
        return $uri;
    }
 
    public function getParameters() : array
    {
        $params = [];
        $query = $this->getQuery();
        if (!is_null($query)) {
            parse_str($query, $params);
        }
        return $params;
    }
 
    public function getParameter(string $param)
    {
        $params = $this->getParameters();
        if (!array_key_exists($param, $params)) {
            return null;
        }
        return $params[$param];
    }
 
    public function withParameters(array $parameters) : URI
    {
        return $this->withQuery(
            http_build_query($parameters)
        );
    }
 
    public function withParameter(string $key, $value) : URI
    {
        $params = $this->getParameters();
        $params[$key] = $value;
        return $this->withParameters($params);
    }
}