F500\Equatable\Map

Complexity

Total Complexity

50

Size/Duplication

Total Lines	275
Duplicated Lines	46.91 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	__clone()	14	14	3
A	get()	0	8	2
A	containsKey()	0	4	1
A	search()	10	10	3
B	equals()	0	22	6
A	values()	0	6	1
A	keys()	0	6	1
A	add()	0	12	2
A	replace()	9	9	1
A	replaceAll()	0	15	3
A	replaceKey()	12	12	2
A	remove()	9	9	1
A	removeAll()	15	15	3
A	removeKey()	12	12	2
A	merge()	0	6	1
A	intersect()	12	12	3
A	intersectKeys()	12	12	3
A	diff()	12	12	3
A	diffKeys()	12	12	3
A	filter()	0	6	1
A	map()	0	6	1
A	guardAgainstInvalidKey()	0	6	2

<?php

/**
 * @license https://github.com/f500/equatable/blob/master/LICENSE MIT
 */

declare(strict_types=1);

namespace F500\Equatable;

use F500\Equatable\Exceptions\InRangeException;
use F500\Equatable\Exceptions\InvalidArgumentException;
use F500\Equatable\Exceptions\OutOfRangeException;

/**
 * @copyright Copyright (c) 2015 Future500 B.V.
 * @author    Jasper N. Brouwer <jasper@future500.nl>
 */
final class Map extends Collection
{
    public function __construct(array $values = [])
    {
        foreach ($values as $key => $value) {
            $this->guardAgainstInvalidKey($key);
            $this->guardAgainstInvalidValue($value);
            $this->items[$key] = $value;
        }
    }

    public function __clone()

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $key => $item) {
            if (is_object($item)) {
                $items[$key] = clone $item;
            } else {
                $items[$key] = $item;
            }
        }

        $this->items = $items;
    }

    public function get(string $key)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (!$this->containsKey($key)) {
            throw OutOfRangeException::doesNotContainKey($key);
        }

        return $this->items[$key];
    }

    public function containsKey(string $key): bool
    {
        return isset($this->items[$key]);
    }

    public function search($value): string

This method seems to be duplicated in your project.

    {
        foreach ($this->items as $key => $item) {
            if ($this->theseAreEqual($item, $value)) {
                return $key;
            }
        }

        throw OutOfRangeException::doesNotContainValue($value);
    }

    public function equals($other): bool
    {
        if (!$other instanceof static) {
            return false;
        }

        if ($this->count() !== $other->count()) {
            return false;
        }

        foreach ($this->items as $key => $item) {
            if (!$other->containsKey($key)) {
                return false;
            }

            if (!$this->theseAreEqual($item, $other->get($key))) {
                return false;
            }
        }

        return true;
    }

    public function values(): Vector
    {
        $items = array_values($this->items);

        return new Vector($items);
    }

    public function keys(): Vector
    {
        $items = array_keys($this->items);

        return new Vector($items);
    }

    public function add(string $key, $value): self
    {
        if ($this->containsKey($key)) {
            throw InRangeException::alreadyContainsKey($key);
        }

        $items = $this->items;

        $items[$key] = $value;

        return new self($items);
    }

    public function replace($searchValue, $replacementValue): self

This method seems to be duplicated in your project.

    {
        $items = $this->items;
        $key   = $this->search($searchValue);

        $items[$key] = $replacementValue;

        return new self($items);
    }

    public function replaceAll($searchValue, $replacementValue): self
    {
        $items = $this->items;
        $keys  = $this->searchAll($searchValue);

        if ($keys->isEmpty()) {
            return $this;
        }

        foreach ($keys as $key) {
            $items[$key] = $replacementValue;
        }

        return new self($items);
    }

    public function replaceKey(string $key, $replacementValue): self

This method seems to be duplicated in your project.

    {
        if (!$this->containsKey($key)) {
            throw OutOfRangeException::doesNotContainKey($key);
        }

        $items = $this->items;

        $items[$key] = $replacementValue;

        return new self($items);
    }

    public function remove($value): self

This method seems to be duplicated in your project.

    {
        $items = $this->items;
        $key   = $this->search($value);

        unset($items[$key]);

        return new self($items);
    }

    public function removeAll($value): self

This method seems to be duplicated in your project.

    {
        $items = $this->items;
        $keys  = $this->searchAll($value);

        if ($keys->isEmpty()) {
            return $this;
        }

        foreach ($keys as $key) {
            unset($items[$key]);
        }

        return new self($items);
    }

    public function removeKey(string $key): self

This method seems to be duplicated in your project.

    {
        if (!$this->containsKey($key)) {
            throw OutOfRangeException::doesNotContainKey($key);
        }

        $items = $this->items;

        unset($items[$key]);

        return new self($items);
    }

    public function merge(self $other): self
    {
        $items = array_merge($this->items, $other->items);

        return new self($items);
    }

    public function intersect(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $key => $item) {
            if ($other->contains($item)) {
                $items[$key] = $item;
            }
        }

        return new self($items);
    }

    public function intersectKeys(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $key => $item) {
            if ($other->containsKey($key)) {
                $items[$key] = $item;
            }
        }

        return new self($items);
    }

    public function diff(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $key => $item) {
            if (!$other->contains($item)) {
                $items[$key] = $item;
            }
        }

        return new self($items);
    }

    public function diffKeys(self $other): self

This method seems to be duplicated in your project.

    {
        $items = [];

        foreach ($this->items as $key => $item) {
            if (!$other->containsKey($key)) {
                $items[$key] = $item;
            }
        }

        return new self($items);
    }

    /**
     * The filter callable is given an item and it's key, and should
     * return a boolean indicating whether the item remains or not.
     *
     * function ($item, $key): bool {
     *     return true;
     * }
     */
    public function filter(callable $filter): self
    {
        $items = array_filter($this->items, $filter, ARRAY_FILTER_USE_BOTH);

        return new self($items);
    }

    /**
     * The mapper callable is given an item, and should return
     * a new value to use in it's place.
     *
     * function ($item) {
     *     return $item;
     * }
     */
    public function map(callable $mapper): self
    {
        $items = array_map($mapper, $this->items);

        return new self($items);
    }

    private function guardAgainstInvalidKey($key)
    {
        if (!is_string($key)) {
            throw InvalidArgumentException::invalidKeyInArray('values', 'string', $key);
        }
    }
}