League\Uri\Modifiers\Relativize

Complexity

Total Complexity

18

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

98%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__invoke()	0	6	1
A	relativizeUri()	0	19	3
B	relativizePath()	0	23	5
A	getSegments()	0	8	3
B	formatPath()	0	17	5

<?php
/**
 * League.Uri (http://uri.thephpleague.com)
 *
 * @package   League.uri
 * @author    Ignace Nyamagana Butera <nyamsprod@gmail.com>
 * @copyright 2013-2015 Ignace Nyamagana Butera
 * @license   https://github.com/thephpleague/uri/blob/master/LICENSE (MIT License)
 * @version   4.2.0
 * @link      https://github.com/thephpleague/uri/
 */
namespace League\Uri\Modifiers;

use League\Uri\Components\Path;
use League\Uri\Interfaces\Uri;
use League\Uri\Modifiers\Filters\Uri as UriFilter;
use Psr\Http\Message\UriInterface;

/**
 * Resolve an URI according to a base URI using
 * RFC3986 rules
 *
 * @package League.uri
 * @author  Ignace Nyamagana Butera <nyamsprod@gmail.com>
 * @since   4.2.0
 */
class Relativize extends AbstractUriModifier
{
    use UriFilter;

    /**
     * New instance
     *
     * @param Uri|UriInterface $uri
     */
    public function __construct($uri)
    {
        $this->uri = $this->filterUri($uri);

It seems like $this->filterUri($uri) can also be of type object<League\Uri\Interfaces\Uri>. However, the property $uri is declared as type object<Psr\Http\Message\UriInterface>. Maybe add an additional type check?

    }

    /**
     * Return a Uri object modified according to the modifier
     *
     * @param Uri|UriInterface $payload
     *
     * @return Uri|UriInterface
     */
    public function __invoke($payload)
    {
        $this->assertUriObject($payload);

        return $this->relativizeUri($payload);
    }

    /**
     * Resolve the payload URI
     *
     * @param Uri|UriInterface $payload
     *
     * @return Uri|UriInterface
     */
    protected function relativizeUri($payload)
    {
        if ($this->uri->getScheme() !== $payload->getScheme()
            || $this->uri->getAuthority() !== $payload->getAuthority()
        ) {
            return $payload;
        }

        $path = $this->relativizePath($payload->getPath());

        return $this->uri
            ->withScheme('')
            ->withPort(null)
            ->withUserInfo('')
            ->withHost('')
            ->withPath($path)
            ->withQuery($payload->getQuery())
            ->withFragment($payload->getFragment());
    }

    /**
     * Relative the URI for a authority-less payload URI
     *
     * @param string $targetPath
     *
     * @return string
     */
    protected function relativizePath($targetPath)
    {
        $targetSegments = $this->getSegments($targetPath);
        $basename = array_pop($targetSegments);
        $basePath = $this->uri->getPath();
        if ($basePath === $targetPath) {
            return $this->formatPath($basename);
        }

        $baseSegments = $this->getSegments($basePath);
        array_pop($baseSegments);

        foreach ($baseSegments as $offset => $segment) {
            if (!isset($targetSegments[$offset]) || $segment !== $targetSegments[$offset]) {
                break;
            }
            unset($baseSegments[$offset], $targetSegments[$offset]);
        }
        $targetSegments[] = $basename;
        $path = str_repeat('../', count($baseSegments)).implode('/', $targetSegments);

        return $this->formatPath($path);
    }

    /**
     * returns the path segments
     *
     * @param string $path
     *
     * @return array
     */
    protected function getSegments($path)
    {
        if ('' !== $path && '/' === $path[0]) {
            $path = mb_substr($path, 1);
        }

        return explode('/', $path);
    }

    /**
     * Post formatting the path to keep a valid URI
     *
     * @param string $path
     *
     * @return string
     */
    protected function formatPath($path)
    {
        if ('' === $path) {
            return './';
        }

        if (false === ($colonPos = strpos($path, ':'))) {
            return $path;
        }

        $slashPos = strpos($path, '/');
        if (false === $slashPos || $colonPos < $slashPos) {
            return "./$path";
        }

        return $path;
    }
}