drupol\phpvfs\Utils\Path

Complexity

Total Complexity

25

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Test Coverage

Coverage

98.21%

Importance

Changes	5
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	9	3
A	basename()	0	3	2
A	dirname()	0	3	2
A	isAbsolute()	0	3	1
A	fromString()	0	22	3
A	getFragments()	0	9	2
A	shift()	0	7	2
A	isValid()	0	7	2
A	getFirstPart()	0	7	2
A	isRoot()	0	3	1
A	withScheme()	0	7	1
A	getLastPart()	0	7	2
A	getScheme()	0	3	1
A	getIterator()	0	3	1

<?php

declare(strict_types = 1);

namespace drupol\phpvfs\Utils;

class Path implements PathInterface, \IteratorAggregate
{
    /**
     * @var bool
     */
    private $absolute;

    /**
     * @var string[]
     */
    private $fragments;

    /**
     * @var string
     */
    private $scheme = '';

    /**
     * {@inheritdoc}
     */
    public function __toString()
    {
        if ('' !== $this->getScheme()) {
            $root = $this->getScheme() . '://';
        } else {
            $root = $this->isAbsolute() ? '/' : '';
        }

        return $root . \implode('/', $this->getFragments());
    }

    /**
     * {@inheritdoc}
     */
    public function basename(): string
    {
        return \basename(($this->isAbsolute() ? '/' : '') . \implode('/', $this->getFragments()));
    }

    /**
     * {@inheritdoc}
     */
    public function dirname(): string
    {
        return \dirname(($this->isAbsolute() ? '/' : '') . \implode('/', $this->getFragments()));
    }

    /**
     * {@inheritdoc}
     */
    public static function fromString(string $id): Path
    {
        $instance = new self();

        if (false !== $parsed = \parse_url($id)) {
            if (\array_key_exists('scheme', $parsed)) {
                $instance->scheme = $parsed['scheme'];

                $id = \DIRECTORY_SEPARATOR . $parsed['host'] . $parsed['path'];
            }
        }

        $instance->absolute = 0 === \strpos($id, '/');

        $instance->fragments = \array_filter(
            \explode(
                \DIRECTORY_SEPARATOR,
                \ltrim($id, \DIRECTORY_SEPARATOR)
            )
        );

        return $instance;
    }

    /**
     * {@inheritdoc}
     */
    public function getFirstPart(): string
    {
        $first = \reset($this->fragments);

        return empty($first) ?
            \DIRECTORY_SEPARATOR :
            $first;
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        yield from $this->getFragments();
    }

    /**
     * {@inheritdoc}
     */
    public function getLastPart(): string
    {
        if (empty($this->fragments)) {
            return \DIRECTORY_SEPARATOR;
        }

        return \end($this->fragments);
    }

    /**
     * {@inheritdoc}
     */
    public function getScheme(): string
    {
        return $this->scheme;
    }

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

    /**
     * {@inheritdoc}
     */
    public function isRoot(): bool
    {
        return '' === $this->basename();
    }

    /**
     * {@inheritdoc}
     */
    public function isValid(): bool
    {
        if (\preg_match('/^[^*?"<>|:]*$/', \trim((string) $this->withScheme(null), ' /'))) {
            return true;
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function shift(): string
    {
        if (null !== $shift = \array_shift($this->fragments)) {
            return $shift;
        }

        throw new \Exception('Error while shifting the path.');
    }

    /**
     * {@inheritdoc}
     */
    public function withScheme(?string $scheme): Path
    {
        $clone = clone $this;

        $clone->scheme = $scheme ?? '';

        return $clone;
    }

    /**
     * {@inheritdoc}
     */
    protected function getFragments(): array
    {
        $fragments = $this->fragments;

        if (empty($fragments[0])) {
            $fragments[0] = \DIRECTORY_SEPARATOR;
        }

        return $fragments;
    }
}