Philae\Utils\UriResolver

Complexity

Total Complexity

39

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
C	uri()	0	31	7
A	getBaseUri()	0	8	2
A	setBaseUri()	0	6	1
A	setBaseUriPath()	0	6	1
A	getBaseUriPath()	0	8	2
A	getServerParam()	0	6	2
C	detectBaseUri()	0	66	19
A	detectBaseUriPath()	0	18	4

<?php

namespace Philae\Utils;

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\UriInterface;

/**
 * Base URL and base path resolver based on Zend Http Request
 * and compatible with PSR-7.
 *
 * @link https://github.com/zendframework/zend-http/blob/master/src/PhpEnvironment/Request.php
 *
 */
class UriResolver implements UriResolverInterface
{
    /**
     * @var ServerRequestInterface
     */
    protected $request;

    /**
     * @var string
     */
    protected $baseUri;

    /**
     * @var string
     */
    protected $baseUriPath;

    public function __construct(ServerRequestInterface $request)
    {
        $this->request = $request;
    }

    /**
     * Returns a new uri object, a clone of the current request one, with the given modifications.
     *
     * @param string $to If the path is absolute, the base url path won't be prepended,
     *   if it is a relative path it will be prepended.
     * @param array $query If null, the current query will be preserved
     * @return UriInterface
     */
    public function uri(string $to = null, array $query = null): UriInterface
    {
        $baseUrl = $this->getBaseUriPath();
        $uri     = clone $this->request->getUri();

        if (is_null($to) && is_null($query)) {
            return $uri;
        }

        if (strpos($to, '?') !== false) {
            $queryString = explode('?', $to, 2);
            $to          = $queryString[0];
            if (isset($queryString[1])) {
                parse_str($queryString[1], $queryString);
                $query = array_merge($queryString, (array)$query);
            }
        }

        if (strpos($to, '/') !== 0) {
            $baseUrl = rtrim($baseUrl, '/');
            $to      = rtrim($baseUrl . '/' . trim($to, '/'), '/');
        }

        $uri = $uri->withPath($to);

        if (!is_null($query)) {
            $uri = $uri->withQuery(http_build_query($query));
        }

        return $uri;
    }

    public function getBaseUri(): string
    {
        if ($this->baseUri === null) {
            $this->setBaseUri($this->detectBaseUri());
        }

        return $this->baseUri;
    }

    /**
     * @param string $baseUri
     * @return $this
     */
    public function setBaseUri(string $baseUri)
    {
        $this->baseUri = $baseUri;

        return $this;
    }

    /**
     * Set the base path.
     *
     * @param  string $baseUriPath
     * @return self
     */
    public function setBaseUriPath(string $baseUriPath)
    {
        $this->baseUriPath = rtrim($baseUriPath, '/');

        return $this;
    }

    public function getBaseUriPath(): string
    {
        if ($this->baseUriPath === null) {
            $this->setBaseUriPath($this->detectBaseUriPath($this->getBaseUri()));
        }

        return $this->baseUriPath;
    }

    /**
     * @param string $name
     * @param mixed $default
     * @return string|mixed
     */
    protected function getServerParam(string $name, $default = '')
    {
        $params = $this->request->getServerParams();

        return isset($params[$name]) ? $params[$name] : $default;
    }

    /**
     * Auto-detect the base path from the request environment
     *
     * Uses a variety of criteria in order to detect the base URL of the request
     * (i.e., anything additional to the document root).
     *
     *
     * @return string
     */
    protected function detectBaseUri(): string
    {
        $filename       = $this->getServerParam('SCRIPT_FILENAME', '');
        $scriptName     = $this->getServerParam('SCRIPT_NAME');
        $phpSelf        = $this->getServerParam('PHP_SELF');
        $origScriptName = $this->getServerParam('ORIG_SCRIPT_NAME');

        if ($scriptName !== null && basename($scriptName) === $filename) {
            $baseUri = $scriptName;
        } elseif ($phpSelf !== null && basename($phpSelf) === $filename) {
            $baseUri = $phpSelf;
        } elseif ($origScriptName !== null && basename($origScriptName) === $filename) {
            // 1and1 shared hosting compatibility.
            $baseUri = $origScriptName;
        } else {
            // Backtrack up the SCRIPT_FILENAME to find the portion
            // matching PHP_SELF.
            $baseUri  = '/';
            $basename = basename($filename);
            if ($basename) {
                $path    = ($phpSelf ? trim($phpSelf, '/') : '');
                $basePos = strpos($path, $basename) ?: 0;
                $baseUri .= substr($path, 0, $basePos) . $basename;
            }
        }

        // If the baseUri is empty, then simply return it.
        if (empty($baseUri)) {
            return '';
        }

        // Does the base URL have anything in common with the request URI?
        $requestUri = $this->request->getUri()->getPath();

        // Full base URL matches.
        if (0 === strpos($requestUri, $baseUri)) {
            return $baseUri;
        }

        // Directory portion of base path matches.
        $baseDir = str_replace('\\', '/', dirname($baseUri));
        if (0 === strpos($requestUri, $baseDir)) {
            return $baseDir;
        }
        $truncatedRequestUri = $requestUri;
        if (false !== ($pos = strpos($requestUri, '?'))) {
            $truncatedRequestUri = substr($requestUri, 0, $pos);
        }
        $basename = basename($baseUri);

        // No match whatsoever
        if (empty($basename) || false === strpos($truncatedRequestUri, $basename)) {
            return '';
        }

        // If using mod_rewrite or ISAPI_Rewrite strip the script filename
        // out of the base path. $pos !== 0 makes sure it is not matching a
        // value from PATH_INFO or QUERY_STRING.
        if (strlen($requestUri) >= strlen($baseUri)
            && (false !== ($pos = strpos($requestUri, $baseUri)) && $pos !== 0)
        ) {
            $baseUri = substr($requestUri, 0, $pos + strlen($baseUri));
        }

        return $baseUri;
    }

    /**
     * Autodetect the base path of the request, without the filename if any.
     *
     * Uses several criteria to determine the base path of the request.
     *
     * @param string|null $baseUri
     * @return string
     */
    protected function detectBaseUriPath(string $baseUri = null): string
    {
        $baseUri = is_null($baseUri) ? $this->getBaseUri() : $baseUri;

        // Empty base url detected
        if ($baseUri === '') {
            return '';
        }
        $filename = basename($this->getServerParam('SCRIPT_FILENAME', ''));

        // basename() matches the script filename; return the directory
        if (basename($baseUri) === $filename) {
            return str_replace('\\', '/', dirname($baseUri));
        }

        // Base path is identical to base URL
        return $baseUri;
    }
}