Innmind\Immutable\Stream

Complexity

Total Complexity

51

Size/Duplication

Total Lines	495
Duplicated Lines	14.75 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

98.84%

Importance

Changes

0

44 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	type()	0	4	1
A	size()	0	4	1
A	count()	0	4	1
A	toPrimitive()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	get()	0	4	1
A	diff()	0	11	1
A	distinct()	0	7	1
A	drop()	0	7	1
A	dropEnd()	0	7	1
A	equals()	0	8	1
A	filter()	0	7	1
A	foreach()	0	6	1
A	first()	0	4	1
A	last()	0	4	1
A	contains()	0	4	1
A	indexOf()	0	4	1
A	indices()	0	7	1
A	map()	0	11	1
A	pad()	9	9	1
A	partition()	0	17	3
A	slice()	0	7	1
A	splitAt()	0	11	1
A	take()	0	7	1
A	takeEnd()	0	7	1
A	append()	11	11	1
A	intersect()	11	11	1
A	join()	0	4	1
A	add()	9	9	1
A	sort()	0	7	1
A	reduce()	0	4	1
A	clear()	0	7	1
B	groupBy()	33	33	5
A	reverse()	0	7	1
A	validate()	0	8	2

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\{
    LogicException,
    GroupEmptySequenceException,
    InvalidArgumentException
};

/**
 * {@inheritdoc}
 */
class Stream implements StreamInterface
{
    use Type;

    private $type;
    private $spec;
    private $values;

    public function __construct(string $type)
    {
        $this->type = new Str($type);
        $this->spec = $this->getSpecificationFor($type);
        $this->values = new Sequence;
    }

    /**
     * {@inheritdoc}
     */
    public function type(): Str
    {
        return $this->type;
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function toPrimitive()
    {
        return $this->values->toPrimitive();
    }

    /**
     * {@inheritdoc}
     */
    public function current()
    {
        return $this->values->current();
    }

    /**
     * {@inheritdoc}
     */
    public function key()
    {
        return $this->values->key();
    }

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        $this->values->next();
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        $this->values->rewind();
    }

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return $this->values->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        return $this->values->offsetExists($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new LogicException('You can\'t modify a stream');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new LogicException('You can\'t modify a stream');
    }

    /**
     * {@inheritdoc}
     */
    public function get(int $index)
    {
        return $this->values->get($index);
    }

    /**
     * {@inheritdoc}
     */
    public function diff(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $newStream = clone $this;
        $newStream->values = $this->values->diff(
            new Sequence(...$stream)

new \Innmind\Immutable\Sequence(...$stream) is of type object<Innmind\Immutable\Sequence>, but the function expects a object<self>.

        );

        return $newStream;
    }

    /**
     * {@inheritdoc}
     */
    public function distinct(): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->distinct();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->drop($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->dropEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(StreamInterface $stream): bool
    {
        $this->validate($stream);

        return $this->values->equals(
            new Sequence(...$stream)

new \Innmind\Immutable\Sequence(...$stream) is of type object<Innmind\Immutable\Sequence>, but the function expects a object<self>.

        );
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->filter($predicate);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): StreamInterface
    {
        $this->values->foreach($function);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface

This method seems to be duplicated in your project.

    {
        if ($this->size() === 0) {
            throw new GroupEmptySequenceException;
        }

        $map = null;

        foreach ($this->values as $value) {
            $key = $discriminator($value);

            if ($map === null) {
                $map = new Map(
                    $this->determineType($key),
                    StreamInterface::class
                );
            }

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->add($value)
                );
            } else {
                $map = $map->put(
                    $key,
                    (new self((string) $this->type))->add($value)
                );
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function first()
    {
        return $this->values->first();
    }

    /**
     * {@inheritdoc}
     */
    public function last()
    {
        return $this->values->last();
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function indices(): StreamInterface
    {
        $stream = new self('int');
        $stream->values = $this->values->indices();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): StreamInterface
    {
        return $this
            ->values
            ->reduce(
                new self((string) $this->type),
                function(self $carry, $element) use($function): StreamInterface {
                    return $carry->add($function($element));
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function pad(int $size, $element): StreamInterface

This method seems to be duplicated in your project.

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->pad($size, $element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = new self((string) $this->type);
        $falsy = new self((string) $this->type);

        foreach ($this->values as $value) {
            if ($predicate($value) === true) {
                $truthy = $truthy->add($value);
            } else {
                $falsy = $falsy->add($value);
            }
        }

        return (new Map('bool', StreamInterface::class))
            ->put(true, $truthy)

true is of type boolean, but the function expects a object<Innmind\Immutable\T>.

$truthy is of type object<Innmind\Immutable\Stream>, but the function expects a object<Innmind\Immutable\S>.

            ->put(false, $falsy);

false is of type boolean, but the function expects a object<Innmind\Immutable\T>.

$falsy is of type object<Innmind\Immutable\Stream>, but the function expects a object<Innmind\Immutable\S>.

    }

    /**
     * {@inheritdoc}
     */
    public function slice(int $from, int $until): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->slice($from, $until);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function splitAt(int $position): StreamInterface
    {
        $stream = new self(StreamInterface::class);
        $splitted = $this->values->splitAt($position);
        $first = new self((string) $this->type);
        $second = new self((string) $this->type);
        $first->values = $splitted->first();
        $second->values = $splitted->last();

        return $stream->add($first)->add($second);

$first is of type object<Innmind\Immutable\Stream>, but the function expects a object<Innmind\Immutable\T>.

$second is of type object<Innmind\Immutable\Stream>, but the function expects a object<Innmind\Immutable\T>.

    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->take($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->takeEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function append(StreamInterface $stream): StreamInterface

This method seems to be duplicated in your project.

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->append(
            new Sequence(...$stream)

new \Innmind\Immutable\Sequence(...$stream) is of type object<Innmind\Immutable\Sequence>, but the function expects a object<self>.

        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(StreamInterface $stream): StreamInterface

This method seems to be duplicated in your project.

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->intersect(
            new Sequence(...$stream)

new \Innmind\Immutable\Sequence(...$stream) is of type object<Innmind\Immutable\Sequence>, but the function expects a object<self>.

        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function join(string $separator): Str
    {
        return new Str((string) $this->values->join($separator));
    }

    /**
     * {@inheritdoc}
     */
    public function add($element): StreamInterface

This method seems to be duplicated in your project.

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->add($element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function sort(callable $function): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->sort($function);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        return $this->values->reduce($carry, $reducer);
    }

    /**
     * {@inheritdoc}
     */
    public function clear(): StreamInterface
    {
        $self = clone $this;
        $self->values = new Sequence;

        return $self;

The return type of return $self; (Innmind\Immutable\Stream) is incompatible with the return type declared by the interface Innmind\Immutable\StreamInterface::clear of type self.

    }

    /**
     * {@inheritdoc}
     */
    public function reverse(): StreamInterface
    {
        $self = clone $this;
        $self->values = $this->values->reverse();

        return $self;
    }

    /**
     * Make sure the stream is compatible with the current one
     *
     * @param StreamInterface $stream
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    private function validate(StreamInterface $stream)
    {
        if (!$stream->type()->equals($this->type)) {

$this->type is of type object<Innmind\Immutable\Str>, but the function expects a object<self>.

            throw new InvalidArgumentException(
                'The 2 streams does not reference the same type'
            );
        }
    }
}