Dgame\Iterator\Iterator

Complexity

Total Complexity

46

Size/Duplication

Total Lines	391
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

85%

Importance

Changes

0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	implode()	0	4	1
A	collect()	0	4	1
A	isEmpty()	0	4	1
A	length()	0	4	1
A	values()	0	4	1
A	keys()	0	4	1
A	first()	0	4	1
A	last()	0	4	1
A	next()	0	4	1
A	previous()	0	4	1
A	peek()	0	7	1
A	popBack()	0	4	1
A	popFront()	0	4	1
A	take()	0	4	1
A	skip()	0	4	1
A	repeat()	0	9	2
A	slice()	0	4	1
A	chunks()	0	4	1
A	fold()	0	4	1
A	filter()	0	8	2
A	map()	0	4	1
A	unique()	0	4	1
A	reverse()	0	4	1
A	countWhile()	0	13	3
A	countUntil()	0	13	3
A	takeWhile()	0	4	1
A	skipWhile()	0	4	1
A	from()	0	8	1
A	until()	0	8	1
A	before()	0	4	1
A	after()	0	4	1
A	keyOf()	0	4	1
A	keysOf()	0	4	1
A	all()	0	10	3
A	any()	0	10	3

<?php

namespace Dgame\Iterator;

/**
 * Class Iterator
 * @package Dgame\Iterator
 */
final class Iterator
{
    /**
     * @var array
     */
    private $values = [];

    /**
     * Iterator constructor.
     *
     * @param array $values
     */
    public function __construct(array $values)
    {
        $this->values = $values;
    }

    /**
     * @param string $glue
     *
     * @return string
     */
    public function implode(string $glue = ''): string
    {
        return implode($glue, $this->values);
    }

    /**
     * @return array
     */
    public function collect(): array
    {
        return $this->values;
    }

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

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

    /**
     * @return Iterator

Should the return type not be \self?

     */
    public function values(): self
    {
        return new self(array_values($this->values));
    }

    /**
     * @return Iterator

Should the return type not be \self?

     */
    public function keys(): self
    {
        return new self(array_keys($this->values));
    }

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

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

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

    /**
     * @return mixed
     */
    public function previous()
    {
        return prev($this->values);
    }

    /**
     * @return mixed
     */
    public function peek()
    {
        $value = $this->next();
        $this->previous();

        return $value;
    }

    /**
     * @return mixed
     */
    public function popBack()
    {
        return array_pop($this->values);
    }

    /**
     * @return mixed
     */
    public function popFront()
    {
        return array_shift($this->values);
    }

    /**
     * @param int $amount
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function take(int $amount): self
    {
        return new self(array_slice($this->values, 0, $amount));
    }

    /**
     * @param int $amount
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function skip(int $amount): self
    {
        return new self(array_slice($this->values, $amount));
    }

    /**
     * @param int $times
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function repeat(int $times): self
    {
        $values = [];
        for ($i = 0; $i < $times; $i++) {
            $values = array_merge($values, $this->values);
        }

        return new self($values);
    }

    /**
     * @param int $from
     * @param int $too
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function slice(int $from, int $too): self
    {
        return new self(array_slice($this->values, $from, $too - $from));
    }

    /**
     * @param int $size
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function chunks(int $size): self
    {
        return new self(array_chunk($this->values, $size));
    }

    /**
     * @param callable $callback
     * @param null     $initial
     *
     * @return mixed
     */
    public function fold(callable $callback, $initial = null)
    {
        return array_reduce($this->values, $callback, $initial);
    }

    /**
     * @param callable|null $callback
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function filter(callable $callback = null): self
    {
        if ($callback === null) {
            return new self(array_filter($this->values));
        }

        return new self(array_filter($this->values, $callback));
    }

    /**
     * @param callable $callback
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function map(callable $callback): self
    {
        return new self(array_map($callback, $this->values));
    }

    /**
     * @return Iterator

Should the return type not be \self?

     */
    public function unique(): self
    {
        return new self(array_unique($this->values));
    }

    /**
     * @return Iterator

Should the return type not be \self?

     */
    public function reverse(): self
    {
        return new self(array_reverse($this->values));
    }

    /**
     * @param callable $callback
     *
     * @return int
     */
    private function countWhile(callable $callback): int
    {
        $index = 0;
        foreach ($this->values as $key => $value) {
            if (!$callback($value, $key)) {
                break;
            }

            $index++;
        }

        return $index;
    }

    /**
     * @param callable $callback
     *
     * @return int
     */
    private function countUntil(callable $callback): int
    {
        $index = 0;
        foreach ($this->values as $key => $value) {
            if ($callback($value, $key)) {
                break;
            }

            $index++;
        }

        return $index;
    }

    /**
     * @param callable $callback
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function takeWhile(callable $callback): self
    {
        return $this->take($this->countWhile($callback));
    }

    /**
     * @param callable $callback
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function skipWhile(callable $callback): self
    {
        return $this->skip($this->countWhile($callback));
    }

    /**
     * @param $value
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function from($value): self
    {
        $amount = $this->countUntil(function ($val) use ($value) {
            return $val === $value;
        });

        return $this->skip($amount);
    }

    /**
     * @param $value
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function until($value): self
    {
        $amount = $this->countUntil(function ($val) use ($value) {
            return $val === $value;
        });

        return $this->take($amount + 1);
    }

    /**
     * @param $value
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function before($value): self
    {
        return $this->until($value)->take(-1);
    }

    /**
     * @param $value
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function after($value): self
    {
        return $this->from($value)->skip(1);
    }

    /**
     * @param $value
     *
     * @return mixed

Consider making the return type a bit more specific; maybe use false|integer|string.

     */
    public function keyOf($value)
    {
        return array_search($value, $this->values);
    }

    /**
     * @param $value
     *
     * @return Iterator

Should the return type not be \self?

     */
    public function keysOf($value): self
    {
        return new self(array_keys($this->values, $value));
    }

    /**
     * @param callable $callback
     *
     * @return bool
     */
    public function all(callable $callback): bool
    {
        foreach ($this->values as $key => $value) {
            if (!$callback($value, $key)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param callable $callback
     *
     * @return bool
     */
    public function any(callable $callback): bool
    {
        foreach ($this->values as $key => $value) {
            if ($callback($value, $key)) {
                return true;
            }
        }

        return false;
    }
}