ArrayView::offsetGet() - Code Metrics - Inspection of "More tests, fixes." - Smoren/array-view-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#3)

by Smoren
created 2024-03-10 18:28 UTC
ArrayView::offsetGet() A

↳ Parent: ArrayView
Complexity

Conditions	6
Paths	5
Size

Total Lines	19
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
eloc	10
c	2
b	1
f	0
dl	0
loc	19
rs	9.2222
cc	6
nc	5
nop	1
<?php

declare(strict_types=1);

namespace Smoren\ArrayView\Views;

use Smoren\ArrayView\Exceptions\IndexError;
use Smoren\ArrayView\Exceptions\KeyError;
use Smoren\ArrayView\Exceptions\LengthError;
use Smoren\ArrayView\Exceptions\NotSupportedError;
use Smoren\ArrayView\Exceptions\ReadonlyError;
use Smoren\ArrayView\Exceptions\ValueError;
use Smoren\ArrayView\Interfaces\ArraySelectorInterface;
use Smoren\ArrayView\Interfaces\ArrayViewInterface;
use Smoren\ArrayView\Selectors\MaskSelector;
use Smoren\ArrayView\Selectors\SliceSelector;
use Smoren\ArrayView\Structs\Slice;
use Smoren\ArrayView\Util;

/**
 * @template T
 *
 * @implements ArrayViewInterface<T>
 */
class ArrayView implements ArrayViewInterface
{
    /**
     * @var array<T>|ArrayViewInterface<T>
     */
    protected $source;
    /**
     * @var bool
     */
    protected bool $readonly;
    /**
     * @var ArrayViewInterface<T>|null
     */
    protected ?ArrayViewInterface $parentView;

    /**
     * {@inheritDoc}
     */
    public static function toView(&$source, ?bool $readonly = null): ArrayViewInterface
    {
        if (!($source instanceof ArrayViewInterface)) {
            return new ArrayView($source, $readonly);
        }

        if (!$source->isReadonly() && $readonly) {
            return new ArrayView($source, $readonly);
        }

        return $source;
    }

    /**
     * {@inheritDoc}
     */
    public static function toUnlinkedView($source, ?bool $readonly = null): ArrayViewInterface
    {
        return static::toView($source, $readonly);
    }

    /**
     * @param array<T>|ArrayViewInterface<T> $source
     * @param bool|null $readonly
     * @throws ReadonlyError
     */
    public function __construct(&$source, ?bool $readonly = null)
    {
        if (is_array($source) && !Util::isArraySequential($source)) {
            throw new ValueError('Cannot create view for non-sequential array.');
        }

        $this->source = &$source;
        $this->readonly = $readonly ?? (($source instanceof ArrayViewInterface) ? $source->isReadonly() : false);

        $this->parentView = ($source instanceof ArrayViewInterface) ? $source : null;


        if (($source instanceof ArrayViewInterface) && $source->isReadonly() && !$this->isReadonly()) {
            throw new ReadonlyError("Cannot create non-readonly view for readonly source.");
        }
    }

    /**
     * {@inheritDoc}
     */
    public function toArray(): array
    {
        return [...$this];
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

    /**
     * {@inheritDoc}
     */
    public function filter(callable $predicate): ArrayViewInterface
    {
        return $this->is($predicate)->select($this);
    }

    /**
     * {@inheritDoc}
     */
    public function is(callable $predicate): ArraySelectorInterface
    {
        return new MaskSelector(array_map($predicate, $this->toArray()));
    }

    /**
     * {@inheritDoc}
     */
    public function subview($selector, bool $readonly = null): ArrayViewInterface
    {
        return is_string($selector)
            ? (new SliceSelector($selector))->select($this, $readonly)
            : $selector->select($this, $readonly);
    }

    /**
     * @return ArrayView<T>
     *
     * {@inheritDoc}
     */
    public function apply(callable $mapper): self
    {
        for ($i = 0; $i < \count($this); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            /** @var T $item */
            $item = $this[$i];
            $this[$i] = $mapper($item, $i);
        }
        return $this;
    }

    /**
     * @template U
     *
     * @param array<U>|ArrayViewInterface<U> $data
     * @param callable(T, U, int): T $mapper
     *
     * @return ArrayView<T>
     *
     * {@inheritDoc}
     */
    public function applyWith($data, callable $mapper): self
    {
        [$dataSize, $thisSize] = [\count($data), \count($this)];
        if ($dataSize !== $thisSize) {
            throw new LengthError("Length of values array not equal to view length ({$dataSize} != {$thisSize}).");
        }

        $dataView = ArrayView::toView($data);

        for ($i = 0; $i < \count($this); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            /** @var T $lhs */
            $lhs = $this[$i];
            /** @var U $rhs */
            $rhs = $dataView[$i];
            $this[$i] = $mapper($lhs, $rhs, $i);
        }

        return $this;
    }

    /**
     * {@inheritDoc}
     *
     * @return ArrayView<T>
     */
    public function set($newValues): self
    {
        if (!\is_array($newValues) && !($newValues instanceof ArrayViewInterface)) {
            for ($i = 0; $i < \count($this); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                $this[$i] = $newValues;
            }
            return $this;
        }

        [$dataSize, $thisSize] = [\count($newValues), \count($this)];
        if ($dataSize !== $thisSize) {
            throw new LengthError("Length of values array not equal to view length ({$dataSize} != {$thisSize}).");
        }

        $newValuesView = ArrayView::toView($newValues);

        for ($i = 0; $i < \count($this); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            // @phpstan-ignore-next-line
            $this[$i] = $newValuesView[$i];
        }

        return $this;
    }

    /**
     * @return \Generator<int, T>
     */
    public function getIterator(): \Generator
    {
        for ($i = 0; $i < \count($this); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            /** @var T $item */
            $item = $this[$i];
            yield $item;
        }
    }

    /**
     * @return bool
     */
    public function isReadonly(): bool
    {
        return $this->readonly;
    }

    /**
     * @param numeric|string|ArraySelectorInterface $offset
filter:
    dependency_paths: ["lib/*"]
     * @return bool
     */
    public function offsetExists($offset): bool
    {
        if (\is_numeric($offset)) {
            return $this->numericOffsetExists($offset);
            return $this->numericOffsetExists(/** @scrutinizer ignore-type */ $offset);
        }

        if (\is_string($offset) && Slice::isSlice($offset)) {
            return true;
        }

        if ($offset instanceof ArraySelectorInterface) {
            return true;
        }

        return false;
    }

    /**
     * @param numeric|string|ArraySelectorInterface $offset
     * @return T|array<T>
     */
    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        if (\is_numeric($offset)) {
            if (!$this->numericOffsetExists($offset)) {
            if (!$this->numericOffsetExists(/** @scrutinizer ignore-type */ $offset)) {
                throw new IndexError("Index {$offset} is out of range.");
            }
            return $this->source[$this->convertIndex(\intval($offset))];
        }

        if (\is_string($offset) && Slice::isSlice($offset)) {
            return $this->subview(new SliceSelector($offset))->toArray();

        }

        if ($offset instanceof ArraySelectorInterface) {
            return $this->subview($offset)->toArray();
        }

        throw new KeyError("Invalid key: \"{$offset}\".");
    }

    /**
     * @param numeric|string|ArraySelectorInterface $offset
     * @param T|array<T>|ArrayViewInterface<T> $value
filter:
    dependency_paths: ["lib/*"]
     * @return void
     */
    public function offsetSet($offset, $value): void
    {
        if ($this->isReadonly()) {
            throw new ReadonlyError("Cannot modify a readonly view.");
        }

        if (\is_numeric($offset) && $this->numericOffsetExists($offset)) {
        if (\is_numeric($offset) && $this->numericOffsetExists(/** @scrutinizer ignore-type */ $offset)) {
            // @phpstan-ignore-next-line
            $this->source[$this->convertIndex(\intval($offset))] = $value;
            return;
        }

        if (\is_string($offset) && Slice::isSlice($offset)) {
            /** @var array<T>|ArrayViewInterface<T> $value */
            $this->subview(new SliceSelector($offset))->set($value);
            return;
        }

        if ($offset instanceof ArraySelectorInterface) {
            $this->subview($offset)->set($value);
            return;
        }

        throw new KeyError("Invalid key: \"{$offset}\".");
    }

    /**
     * @param numeric|string|ArraySelectorInterface $offset
     * @return void
     * @throws NotSupportedError
     */
    public function offsetUnset($offset): void
    {
        throw new NotSupportedError();
    }

    /**
     * @return int
     */
    public function count(): int
    {
        return $this->getParentSize();
    }

    protected function getParentSize(): int
    {
        return ($this->parentView !== null)
            ? \count($this->parentView)
            : \count($this->source);
    }

    /**
     * @param int $i
     * @return int
     */
    protected function convertIndex(int $i): int
    {
        return Util::normalizeIndex($i, \count($this->source));
    }

    /**
     * @param numeric $offset
     * @return bool
     */
    private function numericOffsetExists($offset): bool
    {
        try {
            $index = $this->convertIndex(intval($offset));
        } catch (IndexError $e) {
            return false;
        }
        return \is_array($this->source)
            ? \array_key_exists($index, $this->source)
            : $this->source->offsetExists($index);
    }
}

Smoren / array-view-php

Pull Request — master (#3)

ArrayView::offsetGet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
