Seboettg\Collection\Map\MapTrait

Complexity

Total Complexity

44

Size/Duplication

Total Lines	320
Duplicated Lines	0 %

Test Coverage

Coverage

46.23%

Importance

Changes	1
Bugs	0	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	toList()	0	7	2
A	values()	0	3	1
A	containsKey()	0	3	1
A	iterableContainsKey()	0	8	3
A	get()	0	3	1
A	getEntries()	0	5	1
A	clear()	0	4	1
A	isEmpty()	0	3	1
A	mapNotNull()	0	9	1
A	plus()	0	8	2
A	put()	0	4	1
A	getKeys()	0	3	1
A	contains()	0	4	1
A	minus()	0	9	3
A	getIterator()	0	3	1
A	putAll()	0	4	2
A	any()	0	3	1
B	filter()	0	30	9
A	toMap()	0	5	1
A	size()	0	3	1
A	remove()	0	3	1
A	containsValue()	0	3	1
A	all()	0	3	1
A	map()	0	5	1
A	setArray()	0	3	1
A	forEach()	0	4	2
A	getOrElse()	0	3	1
A	count()	0	3	1

<?php
declare(strict_types=1);
/*
 * Copyright (C) 2022 Sebastian Böttger <seboettg@gmail.com>
 * You may use, distribute and modify this code under the
 * terms of the MIT license.
 *
 * You should have received a copy of the MIT license with
 * this file. If not, please visit: https://opensource.org/licenses/mit-license.php
 */

namespace Seboettg\Collection\Map;

use ArrayIterator;
use Iterator;
use ReflectionException;
use ReflectionFunction;
use Seboettg\Collection\Assert\Exception\NotApplicableCallableException;
use Seboettg\Collection\Lists;
use Seboettg\Collection\Lists\ArrayListTrait;
use Seboettg\Collection\Lists\ListInterface;
use Seboettg\Collection\Map;
use Seboettg\Collection\NativePhp\ArrayAccessTrait;
use function Seboettg\Collection\Assert\assertScalar;
use function Seboettg\Collection\Assert\assertValidCallable;
use function Seboettg\Collection\Lists\emptyList;
use function Seboettg\Collection\Lists\listOf;

/**
 * @property array $array base array of this data structure
 */
trait MapTrait
{
    use ArrayAccessTrait;

    /**
     * @inheritDoc
     */
    public function getEntries(): ListInterface
    {
        return listOf(...array_map(function (string $key, $value) {
            return pair($key, $value);
        }, array_keys($this->array), $this->array));

    }

Function closing brace must go on the next line following the body; found 1 blank lines before brace

    /**
     * @inheritDoc
     */
    public function getKeys(): ListInterface
    {
        return listOf(...array_keys($this->array));
    }

    /**
     * @inheritDoc
     */
    public function values(): ListInterface
    {
        return listOf(...array_values($this->array));
    }

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

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

    /**
     * @inheritDoc
     */
    public function clear(): void
    {
        unset($this->array);
        $this->array = [];
    }

    /**
     * @inheritDoc
     * @param scalar $key
     * @return bool
     */
    public function contains($key): bool
    {
        assertScalar($key, "Key must be a scalar value");
        return array_key_exists($key, $this->array);
    }

    /**
     * @inheritDoc
     * @param array $array
     */
    public function setArray(array $array): void
    {
        $this->array = $array;
    }

    /**
     * @inheritDoc
     * @param scalar
     * @return string
     */
    public function containsKey($key): bool
    {
        return $this->contains($key);

The expression return $this->contains($key) returns the type boolean which is incompatible with the documented return type string.

    }

    /**
     * @inheritDoc
     * @param mixed $value
     * @return bool
     */
    public function containsValue($value): bool
    {
        return in_array($value, $this->array, true) !== false;
    }

    /**
     * @inheritDoc
     * @return bool
     */
    public function isEmpty(): bool
    {
        return $this->count() === 0;
    }

    /**
     * @inheritDoc
     * @param scalar
     * @return mixed
     */
    public function get($key)
    {
        return $this->array[$key] ?? null;
    }

    /**
     * @inheritDoc
     * @param scalar $key
     * @param mixed $value
     */
    public function put($key, $value): void
    {
        assertScalar($key, "Key must be a scalar value");
        $this->array[$key] = $value;
    }

    /**
     * @param MapInterface<scalar, mixed> $map
     * @return void
     */
    public function putAll(MapInterface $map): void
    {
        foreach ($map as $key => $value) {
            $this->array[$key] = $value;
        }
    }

    /**
     * @inheritDoc
     * @param scalar $key
     * @return void
     */
    public function remove($key): void
    {
        unset($this->array[$key]);
    }

    /**
     * @inheritDoc
     * @param callable $predicate
     * @return bool
     */
    public function all(callable $predicate): bool
    {
        return $this->count() === $this->filter($predicate)->count();
    }

    /**
     * @inheritDoc
     * @param callable $predicate
     * @return bool
     */
    public function any(callable $predicate): bool
    {
        return $this->filter($predicate)->count() > 0;
    }

    /**
     * @inheritDoc
     * @param callable|null $predicate
     * @return MapInterface
     */
    public function filter(callable $predicate = null): MapInterface
    {
        $map = emptyMap();
        if ($predicate !== null) {
            try {
                $reflected = new ReflectionFunction($predicate);
                if (count($reflected->getParameters()) === 1) {
                    assertValidCallable($predicate, [Pair::class]);
                    foreach ($this->array as $key => $value) {
                        if ($predicate(pair($key, $value)) === true) {
                            $map->put($key, $value);
                        }
                    }
                } else {
                    if (count($reflected->getParameters()) === 2) {
                        assertValidCallable($predicate, ["scalar", "mixed"]);
                    }
                    foreach ($this->array as $key => $value) {
                        if ($predicate($key, $value) === true) {
                            $map->put($key, $value);
                        }
                    }
                }
            } catch (ReflectionException $ex) {
                throw new NotApplicableCallableException("Invalid callback.");
            }
        } else {
            $map->array = array_filter($this->array, $predicate);

The property array is declared private in anonymous//src/Map/Functions.php$0 and cannot be accessed from this context.

        }
        return $map;
    }

    /**
     * @inheritDoc
     * @param scalar $key
     * @param callable $default
     * @return mixed
     */
    public function getOrElse($key, callable $default)
    {
        return $this[$key] ?? $default();
    }

    /**
     * @inheritDoc
     * @param callable $transform
     * @return ListInterface
     */
    public function map(callable $transform): ListInterface
    {
        $list = emptyList();
        $list->array = array_map($transform, $this->array);

The property array is declared private in anonymous//src/Lists/Functions.php$0 and cannot be accessed from this context.

        return $list;
    }

    /**
     * @inheritDoc
     * @param callable $transform
     * @return ListInterface
     */
    public function mapNotNull(callable $transform): ListInterface
    {
        $newInstance = emptyList();
        $newInstance->setArray(array_values(
            array_filter(array_map($transform, $this->array), function ($item) {
                return $item !== null;
            })
        ));
        return $newInstance;
    }

    /**
     * @inheritDoc
     * @param iterable<scalar> $keys
     * @param MapInterface
     */
    public function minus(iterable $keys): MapInterface
    {
        $newInstance = emptyMap();
        foreach ($this->array as $key => $value) {
            if (!$this->iterableContainsKey($key, $keys)) {
                $newInstance[$key] = $value;
            }
        }
        return $newInstance;
    }

    private function iterableContainsKey(string $key, iterable $keys): bool
    {
        foreach ($keys as $k) {
            if ($k === $key) {
                return true;
            }
        }
        return false;
    }

    /**
     * @inheritDoc
     * @param iterable<Pair<scalar, mixed>> $pairs
     * @return MapInterface<scalar, mixed>
     */
    public function plus(iterable $pairs): MapInterface
    {
        $map = emptyMap();
        $map->array = $this->array;

The property array is declared private in anonymous//src/Map/Functions.php$0 and cannot be accessed from this context.

        foreach ($pairs as $pair) {
            $map[$pair->getKey()] = $pair->getValue();
        }
        return $map;
    }

    /**
     * @inheritDoc
     * @param callable $action f(entry: Pair<scalar, mixed>) -> mixed|void
     * @return void
     */
    public function forEach(callable $action): void
    {
        foreach ($this->array as $key => $value) {
            $action(pair($key, $value));
        }
    }

    /**
     * @inheritDoc
     * @return ListInterface<Pair<scalar, mixed>>
     */
    public function toList(): ListInterface
    {
        $list = emptyList();
        foreach ($this->array as $key => $value) {
            $list->add(pair($key, $value));
        }
        return $list;
    }

    public function toMap(): MapInterface
    {
        $newInstance = emptyMap();
        $newInstance->array = $this->array;

The property array is declared private in anonymous//src/Map/Functions.php$0 and cannot be accessed from this context.

        return $newInstance;
    }


    public function getIterator(): Iterator
    {
        return new ArrayIterator($this->array);
    }
}