Primitive::toMapOf() - Code Metrics - Inspection of "fix tests" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — develop ( 3d4c79...7ab88f )

by Baptiste
created 2019-12-06 19:43 UTC
Primitive::toMapOf() A

↳ Parent: Primitive
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

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

namespace Innmind\Immutable\Set;

use Innmind\Immutable\{
    Map,
    Sequence,
    Set,
    Type,
    ValidateArgument,
    Str,
    Exception\CannotGroupEmptyStructure,
};
use function Innmind\Immutable\unwrap;

/**
 * @template T
 */
final class Primitive implements Implementation
{
    private string $type;
    private ValidateArgument $validate;
    private Sequence $values;

    /**
     * @param T $values
filter:
    dependency_paths: ["lib/*"]
     */
    public function __construct(string $type, ...$values)
    {
        $this->type = $type;
        $this->validate = Type::of($type);
        $this->values = Sequence::of($type, ...$values)->distinct();
    }

    public function isOfType(string $type): bool
    {
        return $this->type === $type;
    }

    public function type(): string
    {
        return $this->type;
    }

    public function size(): int
    {
        return $this->values->size();
    }

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

    /**
     * @return list<T>
filter:
    dependency_paths: ["lib/*"]
     */
    public function toArray(): array
    {
        return unwrap($this->values);
        return unwrap(/** @scrutinizer ignore-type */ $this->values);
    }

    /**
     * @param Implementation<T> $set
     *
     * @return self<T>
     */
    public function intersect(Implementation $set): self
    {
        $self = $this->clear();
        $self->values = $this->values->intersect(
            Sequence::of($this->type, ...$set->toArray())
        );

        return $self;
    }

    /**
     * @param T $element
     *
     * @return self<T>
     */
    public function add($element): self
    {
        if ($this->contains($element)) {
            return $this;
        }

        $set = clone $this;
        $set->values = ($this->values)($element);

        return $set;
    }

    /**
     * @param T $element
     */
    public function contains($element): bool
    {
        return $this->values->contains($element);
    }

    /**
     * @param T $element
     *
     * @return self<T>
     */
    public function remove($element): self
    {
        if (!$this->contains($element)) {
            return $this;
        }

        $index = $this->values->indexOf($element);
        $set = clone $this;
        $set->values = $this
            ->values
            ->clear()
            ->append($this->values->slice(0, $index))
            ->append($this->values->slice($index + 1, $this->size()));

        return $set;
    }

    /**
     * @param Implementation<T> $set
     *
     * @return self<T>
     */
    public function diff(Implementation $set): self
    {
        $self = clone $this;
        $self->values = $this->values->diff(
            Sequence::of($this->type, ...$set->toArray())
        );

        return $self;
    }

    /**
     * @param Implementation<T> $set
     */
    public function equals(Implementation $set): bool
    {
        if ($this->size() !== $set->size()) {
            return false;
        }

        return $this->intersect($set)->size() === $this->size();
    }

    /**
     * @param callable(T): bool $predicate
     *
     * @return self<T>
     */
    public function filter(callable $predicate): self
    {
        $set = clone $this;
        $set->values = $this->values->filter($predicate);

        return $set;
    }

    /**
     * @param callable(T): void $function
     */
    public function foreach(callable $function): void
    {
        $this->values->foreach($function);
    }

    /**
     * @template D
     * @param callable(T): D $discriminator
     *
     * @throws CannotGroupEmptyStructure
     *
     * @return Map<D, Set<T>>
     */
    public function groupBy(callable $discriminator): Map
    {
        /** @var Map<D, Sequence<T>> */
        $map = $this->values->groupBy($discriminator);

        /**
         * @psalm-suppress MixedReturnTypeCoercion
         * @var Map<D, Set<T>>
         */
        return $map->reduce(
            Map::of($map->keyType(), Set::class),
            function(Map $carry, $key, Sequence $values): Map {
                return ($carry)(
                    $key,
                    Set::of($this->type, ...unwrap($values)),
                    Set::of($this->type, ...unwrap(/** @scrutinizer ignore-type */ $values)),
                );
            }
        );
    }

    /**
     * @param callable(T): T $function
     *
     * @return self<T>
     */
    public function map(callable $function): self
    {
        /**
         * @psalm-suppress MissingClosureParamType
         * @psalm-suppress MissingClosureReturnType
         */
        $function = function($value) use ($function) {
            /** @var T $value */
            $returned = $function($value);
            ($this->validate)($returned, 1);

            return $returned;
        };

        return $this->reduce(
            $this->clear(),
            function(self $carry, $value) use ($function): self {
                return $carry->add($function($value));
            }
        );
    }

    /**
     * @param callable(T): bool $predicate
     *
     * @return Map<bool, Set<T>>
     */
    public function partition(callable $predicate): Map
    {
        $partitions = $this->values->partition($predicate);
        /** @var Set<T> */
        $truthy = Set::of($this->type, ...unwrap($partitions->get(true)));
        /** @var Set<T> */
        $falsy = Set::of($this->type, ...unwrap($partitions->get(false)));

        /**
         * @psalm-suppress InvalidScalarArgument
         * @psalm-suppress InvalidArgument
         */
        return Map::of('bool', Set::class)
            (true, $truthy)
            (false, $falsy);
    }

    /**
     * @param callable(T, T): int $function
     *
     * @return Sequence<T>
     */
    public function sort(callable $function): Sequence
    {
        return $this->values->sort($function);
    }

    /**
     * @param Implementation<T> $set
     *
     * @return self<T>
     */
    public function merge(Implementation $set): self
    {
        return $set->reduce(
            $this,
            function(self $carry, $value): self {
                return $carry->add($value);
            }
        );
    }

    /**
     * @template R
     * @param R $carry
filter:
    dependency_paths: ["lib/*"]
     * @param callable(R, T): R $reducer
     *
     * @return R
     */
    public function reduce($carry, callable $reducer)
    {
        return $this->values->reduce($carry, $reducer);
    }

    /**
     * @return self<T>
     */
    public function clear(): self
    {
        return new self($this->type);
    }

    public function empty(): bool
    {
        return $this->values->empty();
    }

    /**
     * @template ST
     *
     * @param callable(T): \Generator<ST> $mapper
     *
     * @return Sequence<ST>
     */
    public function toSequenceOf(string $type, callable $mapper): Sequence
    {
        return $this->values->toSequenceOf($type, $mapper);
    }

    /**
     * @template ST
     *
     * @param callable(T): \Generator<ST> $mapper
     *
     * @return Set<ST>
     */
    public function toSetOf(string $type, callable $mapper): Set
    {
        return $this->values->toSetOf($type, $mapper);
    }

    /**
     * @template MT
     * @template MS
     *
     * @param callable(T): \Generator<MT, MS> $mapper
     *
     * @return Map<MT, MS>
     */
    public function toMapOf(string $key, string $value, callable $mapper): Map
    {
        return $this->values->toMapOf($key, $value, $mapper);
    }
}

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 3d4c79...7ab88f )

Primitive::toMapOf() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
