Thinktomorrow\Locale\Values\Url

Complexity

Total Complexity

39

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	fromString()	0	4	1
A	setCustomRoot()	0	6	1
A	secure()	0	6	1
A	get()	0	15	4
A	isAbsolute()	0	4	1
A	localize()	0	14	1
A	delocalizePath()	0	15	3
B	parse()	0	21	5
A	__toString()	0	4	1
C	reassemble()	0	19	14
B	reassembleWithoutRoot()	0	16	6

<?php

namespace Thinktomorrow\Locale\Values;

use Thinktomorrow\Locale\Exceptions\InvalidUrl;

class Url

Since you have declared the constructor as private, maybe you should also declare the class as final.

{
    private $parsed;
    private $root;

    private $secure;
    private $schemeless = false;
    private $absolute = false;

    private function __construct(string $url)
    {
        $this->parse($url);
    }

    public static function fromString(string $url)
    {
        return new self($url);
    }

    public function setCustomRoot(Root $root)
    {
        $this->root = $root;

        return $this;
    }

    public function secure($secure = true)
    {
        $this->secure = (bool)$secure;

        return $this;
    }

    public function get()
    {
        if($this->root)
        {
            if($this->secure) $this->root->secure($this->secure);

The call to Root::secure() has too many arguments starting with $this->secure.

            // Path is reconstructed. Taken care of possible double slashes
            $path = str_replace('//','/','/'. trim($this->reassembleWithoutRoot(),'/'));
            if($path == '/') $path = '';

            return $this->root->get() . $path;
        }

        return $this->reassemble();
    }

    public function isAbsolute(): bool
    {
        return $this->absolute;
    }

    public function localize(string $localeSegment = null, array $available_locales = [])
    {
        $this->parsed['path'] = str_replace('//', '/',
            rtrim(
                '/'.trim($localeSegment.$this->delocalizePath($available_locales),'/'),
                '/'
            )

        );



        return $this;
    }

    private function delocalizePath(array $available_locales)
    {
        if (!isset($this->parsed['path'])) {
            return;
        }

        $path_segments = explode('/', trim($this->parsed['path'], '/'));

        // Remove the locale segment if present
        if (in_array($path_segments[0], array_keys($available_locales))){
            unset($path_segments[0]);
        }

        return '/'.implode('/', $path_segments);
    }

    private function parse(string $url)
    {
        // Sanitize url input a bit to remove double slashes, but do not remove first slashes
        if ($url == '//') {
            $url = '/';
        }

        $this->parsed = parse_url($url);

        if (false === $this->parsed) {
            throw new InvalidUrl('Failed to parse url. Invalid url [' . $url . '] passed as parameter.');
        }

        // If a schemeless url is passed, parse_url will ignore this and strip the first tags
        // so we keep a reminder to explicitly reassemble the 'anonymous scheme' manually
        $this->schemeless = (0 === strpos($url, '//') && isset($this->parsed['host']));

        $this->absolute = (! preg_match('~^(#|//|https?://|mailto:|tel:)~', $url))
                ? filter_var($url, FILTER_VALIDATE_URL) !== false
                : true;
    }

    public function __toString(): string
    {
        return $this->get();
    }

    private function reassemble(): string
    {
        $scheme = (isset($this->parsed['scheme']))
            ? $this->parsed['scheme'].'://'
            : ($this->schemeless ? '//' : '');

        // Convert to secure scheme if needed or vice versa
        if($scheme == 'http://' && $this->secure) $scheme = 'https://';
        else if($scheme == 'https://' && false === $this->secure) $scheme = 'http://';

        return
            $scheme
            .((isset($this->parsed['user'])) ? $this->parsed['user'].((isset($this->parsed['pass'])) ? ':'.$this->parsed['pass'] : '').'@' : '')
            .((isset($this->parsed['host'])) ? $this->parsed['host'] : '')
            .((isset($this->parsed['port'])) ? ':'.$this->parsed['port'] : '')
            .((isset($this->parsed['path'])) ? $this->parsed['path'] : '')
            .((isset($this->parsed['query'])) ? '?'.$this->parsed['query'] : '')
            .((isset($this->parsed['fragment'])) ? '#'.$this->parsed['fragment'] : '');
    }

    /**
     * Construct a full url with the parsed url elements
     * resulted from a parse_url() function call.
     *
     * @return string
     */
    private function reassembleWithoutRoot()
    {
        if(!$this->root) return $this->reassemble();

        /**
         * In some rare conditions the path in interpreted as the host when there is no domain.tld format given.
         * This is still considered a valid url, be it with only a tld as indication.
         */
        $path = (isset($this->parsed['path']) && $this->parsed['path'] != $this->root->host())
                    ? $this->parsed['path']
                    : '';

        return $path
            . ((isset($this->parsed['query'])) ? '?' . $this->parsed['query'] : '')
            . ((isset($this->parsed['fragment'])) ? '#' . $this->parsed['fragment'] : '');
    }
}