first commit

system/src/Grav/Framework/Uri/Uri.php

@@ -0,0 +1,213 @@
+<?php
+/**
+ * @package    Grav\Framework\Uri
+ *
+ * @copyright  Copyright (C) 2015 - 2018 Trilby Media, LLC. All rights reserved.
+ * @license    MIT License; see LICENSE file for details.
+ */
+
+namespace Grav\Framework\Uri;
+
+use Grav\Framework\Psr7\AbstractUri;
+use GuzzleHttp\Psr7\Uri as GuzzleUri;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * Implements PSR-7 UriInterface.
+ *
+ * @package Grav\Framework\Uri
+ */
+class Uri extends AbstractUri
+{
+    /** @var array Array of Uri query. */
+    private $queryParams;
+
+    /**
+     * You can use `UriFactory` functions to create new `Uri` objects.
+     *
+     * @param array $parts
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $parts = [])
+    {
+        $this->initParts($parts);
+    }
+
+    /**
+     * @return string
+     */
+    public function getUser()
+    {
+        return parent::getUser();
+    }
+
+    /**
+     * @return string
+     */
+    public function getPassword()
+    {
+        return parent::getPassword();
+    }
+
+    /**
+     * @return array
+     */
+    public function getParts()
+    {
+        return parent::getParts();
+    }
+
+    /**
+     * @return string
+     */
+    public function getUrl()
+    {
+        return parent::getUrl();
+    }
+
+    /**
+     * @return string
+     */
+    public function getBaseUrl()
+    {
+        return parent::getBaseUrl();
+    }
+
+    /**
+     * @param string $key
+     * @return string|null
+     */
+    public function getQueryParam($key)
+    {
+        $queryParams = $this->getQueryParams();
+
+        return isset($queryParams[$key]) ? $queryParams[$key] : null;
+    }
+
+    /**
+     * @param string $key
+     * @return UriInterface
+     */
+    public function withoutQueryParam($key)
+    {
+        return GuzzleUri::withoutQueryValue($this, $key);
+    }
+
+    /**
+     * @param string $key
+     * @param string|null $value
+     * @return UriInterface
+     */
+    public function withQueryParam($key, $value)
+    {
+        return GuzzleUri::withQueryValue($this, $key, $value);
+    }
+
+    /**
+     * @return array
+     */
+    public function getQueryParams()
+    {
+        if ($this->queryParams === null) {
+            $this->queryParams = UriFactory::parseQuery($this->getQuery());
+        }
+
+        return $this->queryParams;
+    }
+
+    /**
+     * @param array $params
+     * @return UriInterface
+     */
+    public function withQueryParams(array $params)
+    {
+        $query = UriFactory::buildQuery($params);
+
+        return $this->withQuery($query);
+    }
+
+    /**
+     * Whether the URI has the default port of the current scheme.
+     *
+     * `$uri->getPort()` may return the standard port. This method can be used for some non-http/https Uri.
+     *
+     * @return bool
+     */
+    public function isDefaultPort()
+    {
+        return $this->getPort() === null || GuzzleUri::isDefaultPort($this);
+    }
+
+    /**
+     * Whether the URI is absolute, i.e. it has a scheme.
+     *
+     * An instance of UriInterface can either be an absolute URI or a relative reference. This method returns true
+     * if it is the former. An absolute URI has a scheme. A relative reference is used to express a URI relative
+     * to another URI, the base URI. Relative references can be divided into several forms:
+     * - network-path references, e.g. '//example.com/path'
+     * - absolute-path references, e.g. '/path'
+     * - relative-path references, e.g. 'subpath'
+     *
+     * @return bool
+     * @link https://tools.ietf.org/html/rfc3986#section-4
+     */
+    public function isAbsolute()
+    {
+        return GuzzleUri::isAbsolute($this);
+    }
+
+    /**
+     * Whether the URI is a network-path reference.
+     *
+     * A relative reference that begins with two slash characters is termed an network-path reference.
+     *
+     * @return bool
+     * @link https://tools.ietf.org/html/rfc3986#section-4.2
+     */
+    public function isNetworkPathReference()
+    {
+        return GuzzleUri::isNetworkPathReference($this);
+    }
+
+    /**
+     * Whether the URI is a absolute-path reference.
+     *
+     * A relative reference that begins with a single slash character is termed an absolute-path reference.
+     *
+     * @return bool
+     * @link https://tools.ietf.org/html/rfc3986#section-4.2
+     */
+    public function isAbsolutePathReference()
+    {
+        return GuzzleUri::isAbsolutePathReference($this);
+    }
+
+    /**
+     * Whether the URI is a relative-path reference.
+     *
+     * A relative reference that does not begin with a slash character is termed a relative-path reference.
+     *
+     * @return bool
+     * @link https://tools.ietf.org/html/rfc3986#section-4.2
+     */
+    public function isRelativePathReference()
+    {
+        return GuzzleUri::isRelativePathReference($this);
+    }
+
+    /**
+     * Whether the URI is a same-document reference.
+     *
+     * A same-document reference refers to a URI that is, aside from its fragment
+     * component, identical to the base URI. When no base URI is given, only an empty
+     * URI reference (apart from its fragment) is considered a same-document reference.
+     *
+     * @param UriInterface|null $base An optional base URI to compare against
+     * @return bool
+     * @link https://tools.ietf.org/html/rfc3986#section-4.4
+     */
+    public function isSameDocumentReference(UriInterface $base = null)
+    {
+        return GuzzleUri::isSameDocumentReference($this, $base);
+    }
+}