Borobudur\Http\Uri

Complexity

Total Complexity

28

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	allSegments()	0	4	1
A	getSegment()	0	8	2
A	filterSegment()	0	6	1
C	getPathInfo()	0	25	7
A	getUriForPath()	0	4	1
D	getUri()	0	40	10
A	getBasePath()	0	20	4
A	getRequestUri()	0	4	1

<?php
/*
 * This file is part of the Borobudur-Http package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\Http;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/1/15
 */
class Uri
{
    /**
     * @var ServerBag
     */
    private $server;

    /**
     * @var string
     */
    private $pathInfo;

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

    /**
     * @var string
     */
    private $basePath;

    /**
     * @var array
     */
    private $segments;

    /**
     * Constructor.
     *
     * @param ServerBag $server
     */
    public function __construct(ServerBag $server)
    {
        $this->server = $server;
        $this->baseUri = $this->getUri();
        $this->segments = explode('/', trim($this->getPathInfo(), '/'));
    }

    /**
     * Get all segment.
     *
     * @return array
     */
    public function allSegments()
    {
        return $this->segments;
    }

    /**
     * Get uri segment.
     *
     * @param int   $index
     * @param mixed $default
     *
     * @return string|mixed
     */
    public function getSegment($index, $default = null)
    {
        if (isset($this->segments[$index])) {
            return $this->segments[$index];
        }

        return $default;
    }

    /**
     * Filter uri segment.
     *
     * @param int        $index
     * @param int        $filter
     * @param mixed      $default
     * @param array|null $options
     *
     * @return mixed
     */
    public function filterSegment($index, $filter = FILTER_DEFAULT, $default = null, array $options = null)
    {
        $variable = $this->getSegment($index, $default);

        return filter_var($variable, $filter, $options);
    }

    /**
     * Get path info.
     *
     * @return string
     */
    public function getPathInfo()
    {
        if (null === $this->pathInfo) {
            $requestUri = $this->getRequestUri();
            if (empty($requestUri)) {
                $this->pathInfo = '/';
            } else {
                $baseUri = $this->getUri();

                if ($pos = strpos($requestUri, '?')) {
                    $requestUri = substr($requestUri, 0, $pos);
                }

                if (false === empty($baseUri) && false === $this->pathInfo = substr($requestUri, strlen($baseUri))) {
                    $this->pathInfo = '/';
                } elseif (empty($baseUri)) {
                    $this->pathInfo = $requestUri;
                } else {
                    $this->pathInfo = (string) $this->pathInfo;
                }
            }
        }

        return '/' . ltrim($this->pathInfo, '/');
    }

    /**
     * Get uri for specified path.
     *
     * @param string $path
     *
     * @return string
     */
    public function getUriForPath($path)
    {
        return $this->getUri() . '/' . trim($path, '/');
    }

    /**
     * Get uri.
     *
     * @return string
     */
    public function getUri()
    {
        if (null === $this->baseUri) {
            $filename = basename($this->server->get('SCRIPT_FILENAME'));

            if (basename($this->server->get('SCRIPT_NAME')) === $filename) {
                $baseUri = $this->server->get('SCRIPT_NAME');
            } else {
                $path = $this->server->get('PHP_SELF', '');
                $file = $this->server->get('SCRIPT_FILENAME', '');
                $parts = explode('/', trim($file, '/'));
                $baseUri = '';

                // build base url from last segment.
                for ($i = count($parts) - 1; $i > 0; $i--) {
                    $baseUri = '/' . $parts[$i] . $baseUri;
                    $pos = strpos($path, $baseUri);

                    // stop build when $baseUri not match with path.
                    if (false === $pos || 0 === $pos) {
                        break;
                    }
                }
            }

            $requestUri = $this->getRequestUri();

            // check is base url start with request uri.
            if (!empty($baseUri) && 0 === strpos(rawurldecode($requestUri), $baseUri)) {
                $baseUri = rtrim($baseUri, DIRECTORY_SEPARATOR);
            } elseif (!empty($baseUri)
                && strlen($requestUri) >= $len = strlen(rtrim(dirname($baseUri), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR)) {
                $baseUri = rtrim(substr($requestUri, 0, $len), DIRECTORY_SEPARATOR);
            }

            $this->baseUri = rtrim($baseUri, DIRECTORY_SEPARATOR);
        }

        return $this->baseUri;
    }

    /**
     * Get base path.
     *
     * @return string
     */
    public function getBasePath()
    {
        if (null === $this->basePath) {
            $uri = $this->getUri();
            if (empty($uri)) {
                $this->basePath = '';
            }
            else {
                if (basename($this->getUri()) === basename($this->server->get('SCRIPT_NAME'))) {
                    $basePath = dirname($this->getUri());
                } else {
                    $basePath = $this->getUri();
                }

                $this->basePath = rtrim(str_replace('\\', '/', $basePath), '/');
            }
        }

        return $this->basePath;
    }

    /**
     * Get request uri.
     *
     * @return string
     */
    public function getRequestUri()
    {
        return $this->server->get('REQUEST_URI', '');
    }
}