Thinktomorrow\Url\Url

Complexity

Total Complexity

26

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	delocalizePath()	0	14	3
A	hasHost()	0	3	1
A	secure()	0	3	1
A	getPort()	0	3	1
A	hasHash()	0	4	1
A	getHash()	0	4	1
A	hasScheme()	0	3	1
A	getPath()	0	4	1
A	get()	0	3	1
A	getScheme()	0	3	1
A	nonSecure()	0	3	1
A	__construct()	0	3	1
A	__toString()	0	3	1
A	hasPath()	0	4	1
A	hasPort()	0	3	1
A	isAbsolute()	0	3	1
A	setCustomRoot()	0	5	1
A	fromString()	0	3	1
A	getQuery()	0	4	1
A	localize()	0	11	1
A	hasQuery()	0	4	1
A	scheme()	0	5	2
A	getHost()	0	3	1

<?php
declare(strict_types=1);

namespace Thinktomorrow\Url;

use JetBrains\PhpStorm\Pure;

class Url
{
    private ParsedUrl $parsedUrl;

    private function __construct(ParsedUrl $parsedUrl)
    {
        $this->parsedUrl = $parsedUrl;
    }

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

    public function setCustomRoot(Root $root): self
    {
        $this->parsedUrl = $this->parsedUrl->replaceRoot($root);

        return $this;
    }

    public function secure(): self
    {
        return $this->scheme();
    }

    public function nonSecure(): self
    {
        return $this->scheme(false);
    }

    private function scheme(bool $secure = true): self
    {
        $this->parsedUrl = $this->parsedUrl->replaceScheme($secure ? 'https' : 'http');

        return $this;
    }

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

    public function getScheme(): ?string
    {
        return $this->parsedUrl->scheme();
    }

    public function getHost(): ?string
    {
        return $this->parsedUrl->host();
    }

    public function getPort(): ?string
    {
        return $this->parsedUrl->port();
    }

    #[Pure]
    public function getPath(): ?string
    {
        return $this->parsedUrl->path();
    }

    #[Pure]
    public function getQuery(): ?string
    {
        return $this->parsedUrl->query();
    }

    #[Pure]
    public function getHash(): ?string
    {
        return $this->parsedUrl->hash();
    }

    public function hasScheme(): bool
    {
        return $this->parsedUrl->hasScheme();
    }

    public function hasHost(): bool
    {
        return $this->parsedUrl->hasHost();
    }

    public function hasPort(): bool
    {
        return $this->parsedUrl->hasPort();
    }

    #[Pure]
    public function hasPath(): bool
    {
        return $this->parsedUrl->hasPath();
    }

    #[Pure]
    public function hasQuery(): bool
    {
        return $this->parsedUrl->hasQuery();
    }

    #[Pure]
    public function hasHash(): bool
    {
        return $this->parsedUrl->hasHash();
    }

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

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

        $this->parsedUrl = $this->parsedUrl->replacePath($localizedPath);

        return $this;
    }

    private function delocalizePath(array $available_locales): string
    {
        if (! $this->parsedUrl->hasPath()) {
            return '';
        }

        $path_segments = explode('/', trim($this->parsedUrl->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);
    }

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