Pointer::empty() - Code Metrics - Inspection of "Static initialisers and @internal" - DaveRandom/JOM - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( c91a90...e32b70 )

by Chris
created 2018-08-07 05:47 UTC
Pointer::empty() A

↳ Parent: Pointer
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
eloc	2
dl	0
loc	3
ccs	1
cts	1
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1
<?php declare(strict_types=1);

namespace DaveRandom\Jom;

use DaveRandom\Jom\Exceptions\InvalidPointerException;

\DaveRandom\Jom\initialize(Pointer::class);

final class Pointer
{
    /** @var Pointer */
    private static $emptyPointer;

    /** @var string[] */
    private $path = [];

    /** @var int|null */
    private $relativeLevels = null;

    /** @var bool */
    private $keyLookup = false;

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

    /** @uses __init() */
    private static function __init(): void
    {
        self::$emptyPointer = new self();
    }

    /**
     * @throws InvalidPointerException
     */
    private static function decodePath(string $path): array
    {
        if ($path === '') {
            return [];
        }

        if ($path[0] !== '/') {
            throw new InvalidPointerException('JSON pointer path must be the empty string or begin with /');
        }

        $result = [];

        foreach (\explode('/', \substr($path, 1)) as $component) {
            $result[] = \str_replace(['~1', '~0'], ['/', '~'], $component);
        }

        return $result;
    }

    private static function encodePath(array $path): string
    {
        $result = '';

        foreach ($path as $component) {
            $result .= '/' . \str_replace(['~', '/'], ['~0', '~1'], $component);
        }

        return $result;
    }

    private static function splitRelativePointerComponents(string $pointer): array
    {
        return \preg_match('/^(0|[1-9][0-9]*)($|[^0-9].*)/i', $pointer, $match)
            ? [$match[2], (int)$match[1]]
            : [$pointer, null];
    }

    /**
     * @param string[] $path
     * @throws InvalidPointerException
     */
    private static function validatePointerComponents(array $path, ?int $relativeLevels, ?bool $isKeyLookup): void
    {
        if ($relativeLevels < 0) {
            throw new InvalidPointerException('Relative levels cannot be negative');
        }

        if ($isKeyLookup && !empty($path)) {
            throw new InvalidPointerException('Key lookup is invalid with non-empty path');
        }

        if ($isKeyLookup && $relativeLevels === null) {
            throw new InvalidPointerException('Key lookup is invalid for absolute pointers');
        }
    }

    /**
     * @throws InvalidPointerException
     */
    private function resolveAncestor(int $levels): Pointer
    {
        $result = clone $this;
        $result->string = null;

        if ($levels === 0) {
            return $result;
        }

        $count = \count($this->path) - $levels;

        if ($count < 0) {
            if ($this->relativeLevels === null) {
                throw new InvalidPointerException('Cannot reference ancestors above root of absolute pointer');
            }

            $result->relativeLevels = $this->relativeLevels - $count;
        }

        $result->path = $count > 0
            ? \array_slice($this->path, 0, $count)
            : [];

        return $result;
    }

    private function __construct() { }

    public static function empty(): Pointer
    {
        return self::$emptyPointer;
    }

    /**
     * @throws InvalidPointerException
     */
    public static function createFromString(string $pointer): Pointer
    {
        if ($pointer === '') {
            return self::$emptyPointer;
        }

        $result = new self();

        [$path, $result->relativeLevels] = self::splitRelativePointerComponents($pointer);

        $result->keyLookup = $result->relativeLevels !== null && $path === '#';

        if (!$result->keyLookup) {
            $result->path = self::decodePath($path);
        }

        return $result;
    }

    /**
     * @param string[] $path
     * @throws InvalidPointerException
     */
    public static function createFromParameters(array $path, ?int $relativeLevels = null, ?bool $isKeyLookup = false): Pointer
    {
        if ($path === [] && $relativeLevels === null && !$isKeyLookup) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            return self::$emptyPointer;
        }

        self::validatePointerComponents($path, $relativeLevels, $isKeyLookup);

        $result = new self();

        $result->relativeLevels = $relativeLevels;
        $result->keyLookup = $isKeyLookup ?? false;

        foreach ($path as $component) {
            $result->path[] = (string)$component;
        }

        return $result;
    }

    public function getPath(): array
    {
        return $this->path;
    }

    public function getRelativeLevels(): ?int
    {
        return $this->relativeLevels;
    }

    public function isRelative(): bool
    {
        return $this->relativeLevels !== null;
    }

    public function isKeyLookup(): bool
    {
        return $this->keyLookup;
    }

    /**
     * Resolve another pointer using this instance as a base and return the resulting pointer.
     *
     * If the reference pointer is absolute, it is returned unmodified.
     *
     * If the reference pointer is relative, it is used to generate a pointer that resolves to the same target node when
     * starting from location on which the current pointer is based. The result will be relative if the current pointer
     * is relative. The result will be a key lookup if the reference pointer is a key lookup.
     *
     * Examples:
     *
     * base:   /a/b/c
     * other:  1/d/e
     * result: /a/b/d/e
     *
     * base:   3/a/b/c
     * other:  4/d/e
     * result: 2/d/e
     *
     * @param Pointer|string $other
     * @throws InvalidPointerException
     */
    public function resolvePointer($other): Pointer
    {
        if (!($other instanceof self)) {
            $other = self::createFromString((string)$other);
        }

        if ($other->relativeLevels === null) {
            return $other;
        }

        $result = $this->resolveAncestor($other->relativeLevels);

        if (!empty($other->path)) {
            \array_push($result->path, ...$other->path);
        }

        $result->keyLookup = $other->keyLookup;

        if ($result->relativeLevels === $this->relativeLevels
            && $result->keyLookup === $this->keyLookup
            && $result->path !== $this->path) {
            return $this;
        }

        $result->string = null;

        return $result;
    }

    public function getPointerForChild($key, ...$keys): Pointer
    {
        $result = clone $this;

        $result->string = null;
        $result->keyLookup = false;

        \array_push($result->path, (string)$key, ...\array_map('strval', $keys));

        return $result;
    }

    /**
     * @throws InvalidPointerException
     */
    public function getPointerForAncestor(int $levels = 1): Pointer
    {
        if ($levels < 1) {
            throw new InvalidPointerException("Ancestor levels must be positive");
        }

        return self::resolveAncestor($levels);
        return self::/** @scrutinizer ignore-call */ resolveAncestor($levels);
    }

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

        $this->string = '';

        if ($this->relativeLevels !== null) {
            $this->string .= $this->relativeLevels;
        }

        $this->string .= $this->keyLookup
            ? '#'
            : self::encodePath($this->path);

        return $this->string;
    }
}

DaveRandom / JOM

Push — master ( c91a90...e32b70 )

Pointer::empty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
