ForeachMethodCollection::reduce() - Code Metrics - Inspection of "add Scrutimizer" - Novactive/NovaCollection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — develop (05114b)

by Sébastien

created 2017-02-06 02:54 UTC

ForeachMethodCollection::reduce() A

↳ Parent: ForeachMethodCollection

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	10
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	2
dl	10
loc	10
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * Novactive Collection.
 *
 * @author    Luke Visinoni <[email protected], [email protected]>
 * @author    Sébastien Morel <[email protected], [email protected]>
 * @copyright 2017 Novactive
 * @license   MIT
 */

namespace Novactive\Tests\Perfs;

use Novactive\Collection\Collection;
use Novactive\Collection\Factory;
use Traversable;

/**
 * Class ForeachMethodCollection.
 */
class ForeachMethodCollection extends Collection
{
    /**
     * {@inheritdoc}
     */
    public function map(callable $callback)

    {
        $collection = Factory::create();
        $index      = 0;
        foreach ($this->items as $key => $value) {
            $collection->set($key, $callback($value, $key, $index++));
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $callback)

    {
        $collection = Factory::create();
        $index      = 0;
        foreach ($this->items as $key => $value) {
            if ($callback($value, $key, $index++)) {
                $collection->set($key, $value);
            }
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function reduce(callable $callback, $initial = null)

    {
        $accumulator = $initial;
        $index       = 0;
        foreach ($this->items as $key => $value) {
            $accumulator = $callback($accumulator, $value, $key, $index++);
        }

        return $accumulator;
    }

    /**
     * {@inheritdoc}
     */
    public function combine($values, $inPlace = false)
    {
        if (!is_array($values) && !($values instanceof Traversable)) {
            $this->doThrow('Invalid input type for '.($inPlace ? 'replace' : 'combine').'.', $values);
        }

        if (count($values) != count($this->items)) {
            $this->doThrow(
                'Invalid input for '.($inPlace ? 'replace' : 'combine').', number of items does not match.',
                $values
            );
        }
        $values     = Factory::getArrayForItems($values);
        $collection = Factory::create([], static::class);
        $this->rewind();
        foreach ($values as $value) {
            $collection->set($this->current(), $value);
            $this->next();
        }
        $this->rewind();

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function each(callable $callback)

    {
        $index = 0;
        foreach ($this->items as $key => $value) {
            $callback($value, $key, $index++);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function flip()

    {
        $collection = Factory::create([], static::class);
        foreach ($this->items as $key => $value) {
            $collection->set($value, $key);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function values()

    {
        $collection = Factory::create([], static::class);
        foreach ($this->items as $value) {
            $collection->add($value);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function keys()

    {
        $collection = Factory::create([], static::class);
        foreach ($this->items as $key => $value) {
            $collection->add($key);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function unique()
    {
        $collection = Factory::create([], static::class);
        foreach ($this->items as $value) {
            // testing with in_array to not be dependant as in_array is faster and this collection would use foreach
            // we want to test unique here, not in_array
            if (!in_array($value, $this->items, true)) {
                $collection->add($value);
            }
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function contains($value)
    {
        foreach ($this->items as $val) {
            if ($value === $val) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function merge($items, $inPlace = false)

    {
        if (!is_array($items) && !($items instanceof Traversable)) {
            $this->doThrow('Invalid input type for '.__METHOD__.', cannot merge.', $items);
        }
        $collection = $inPlace ? $this : clone $this;
        foreach ($items as $key => $value) {
            $collection->set($key, $value);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function union($items, $inPlace = false)

    {
        if (!is_array($items) && !($items instanceof Traversable)) {
            $this->doThrow('Invalid input type for '.__METHOD__.', cannot union.', $items);
        }
        $collection = $inPlace ? $this : clone $this;
        foreach ($items as $key => $value) {
            if (!$collection->containsKey($key)) {
                $collection->set($key, $value);
            }
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function reverse()
    {
        $collection = Factory::create([], static::class);
        $count      = $this->count();
        $keys       = $this->keys();
        $values     = $this->values();

        for ($i = $count - 1; $i >= 0; $i--) {
            $collection->set($keys[$i], $values[$i]);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function shift()
    {
        reset($this->items);

        return $this->pull($this->key());
    }

    /**
     * {@inheritdoc}
     */
    public function pop()
    {
        end($this->items);

        return $this->pull($this->key());
    }

    /**
     * {@inheritdoc}
     */
    public function chunk($size)
    {
        $collection = Factory::create();
        $chunk      = Factory::create();
        foreach ($this->items as $key => $value) {
            $chunk->set($key, $value);
            if ($chunk->count() == $size) {
                $collection->add($chunk);
                $chunk = Factory::create();
            }
        }
        if (!$chunk->isEmpty()) {
            $collection->add($chunk);
        }

        return $collection;
    }

    /**
     * {@inheritdoc}
     */
    public function slice($offset, $length = PHP_INT_MAX)
    {
        if ($offset < 0) {
            $offset = $this->count() + $offset;
        }

        return $this->filter(
            function ($value, $key, $index) use ($offset, $length) {
                return ($index >= $offset) && ($index < $offset + $length);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function diff($items)
    {
        $itemsCollection = Factory::create($items);

        return $this->filter(
            function ($value, $key, $index) use ($itemsCollection) {

                return !$itemsCollection->contains($value);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function diffKeys($items)
    {
        $itemsCollection = Factory::create($items);

        return $this->filter(
            function ($value, $key, $index) use ($itemsCollection) {

                return !$itemsCollection->containsKey($key);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function intersect($items)
    {
        $itemsCollection = Factory::create($items);

        return $this->filter(
            function ($value, $key, $index) use ($itemsCollection) {

                return $itemsCollection->contains($value);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function intersectKeys($items)
    {
        $itemsCollection = Factory::create($items);

        return $this->filter(
            function ($value, $key, $index) use ($itemsCollection) {

                return $itemsCollection->containsKey($key);
            }
        );
    }
}


1		<?php
2		/**
3		* Novactive Collection.
4		*
5		* @author Luke Visinoni <[email protected], [email protected]>
6		* @author Sébastien Morel <[email protected], [email protected]>
7		* @copyright 2017 Novactive
8		* @license MIT
9		*/
10
11		namespace Novactive\Tests\Perfs;
12
13		use Novactive\Collection\Collection;
14		use Novactive\Collection\Factory;
15		use Traversable;
16
17		/**
18		* Class ForeachMethodCollection.
19		*/
20		class ForeachMethodCollection extends Collection
21		{
22		/**
23		* {@inheritdoc}
24		*/
25	View Code Duplication	public function map(callable $callback)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
26		{
27		$collection = Factory::create();
28		$index = 0;
29		foreach ($this->items as $key => $value) {
30		$collection->set($key, $callback($value, $key, $index++));
31		}
32
33		return $collection;
34		}
35
36		/**
37		* {@inheritdoc}
38		*/
39	View Code Duplication	public function filter(callable $callback)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
40		{
41		$collection = Factory::create();
42		$index = 0;
43		foreach ($this->items as $key => $value) {
44		if ($callback($value, $key, $index++)) {
45		$collection->set($key, $value);
46		}
47		}
48
49		return $collection;
50		}
51
52		/**
53		* {@inheritdoc}
54		*/
55	View Code Duplication	public function reduce(callable $callback, $initial = null)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
56		{
57		$accumulator = $initial;
58		$index = 0;
59		foreach ($this->items as $key => $value) {
60		$accumulator = $callback($accumulator, $value, $key, $index++);
61		}
62
63		return $accumulator;
64		}
65
66		/**
67		* {@inheritdoc}
68		*/
69		public function combine($values, $inPlace = false)
70		{
71		if (!is_array($values) && !($values instanceof Traversable)) {
72		$this->doThrow('Invalid input type for '.($inPlace ? 'replace' : 'combine').'.', $values);
73		}
74
75		if (count($values) != count($this->items)) {
76		$this->doThrow(
77		'Invalid input for '.($inPlace ? 'replace' : 'combine').', number of items does not match.',
78		$values
79		);
80		}
81		$values = Factory::getArrayForItems($values);
82		$collection = Factory::create([], static::class);
83		$this->rewind();
84		foreach ($values as $value) {
85		$collection->set($this->current(), $value);
86		$this->next();
87		}
88		$this->rewind();
89
90		return $collection;
91		}
92
93		/**
94		* {@inheritdoc}
95		*/
96	View Code Duplication	public function each(callable $callback)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
97		{
98		$index = 0;
99		foreach ($this->items as $key => $value) {
100		$callback($value, $key, $index++);
101		}
102
103		return $this;
104		}
105
106		/**
107		* {@inheritdoc}
108		*/
109	View Code Duplication	public function flip()
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
110		{
111		$collection = Factory::create([], static::class);
112		foreach ($this->items as $key => $value) {
113		$collection->set($value, $key);
114		}
115
116		return $collection;
117		}
118
119		/**
120		* {@inheritdoc}
121		*/
122	View Code Duplication	public function values()
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
123		{
124		$collection = Factory::create([], static::class);
125		foreach ($this->items as $value) {
126		$collection->add($value);
127		}
128
129		return $collection;
130		}
131
132		/**
133		* {@inheritdoc}
134		*/
135	View Code Duplication	public function keys()
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
136		{
137		$collection = Factory::create([], static::class);
138		foreach ($this->items as $key => $value) {
139		$collection->add($key);
140		}
141
142		return $collection;
143		}
144
145		/**
146		* {@inheritdoc}
147		*/
148		public function unique()
149		{
150		$collection = Factory::create([], static::class);
151		foreach ($this->items as $value) {
152		// testing with in_array to not be dependant as in_array is faster and this collection would use foreach
153		// we want to test unique here, not in_array
154		if (!in_array($value, $this->items, true)) {
155		$collection->add($value);
156		}
157		}
158
159		return $collection;
160		}
161
162		/**
163		* {@inheritdoc}
164		*/
165		public function contains($value)
166		{
167		foreach ($this->items as $val) {
168		if ($value === $val) {
169		return true;
170		}
171		}
172
173		return false;
174		}
175
176		/**
177		* {@inheritdoc}
178		*/
179	View Code Duplication	public function merge($items, $inPlace = false)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
180		{
181		if (!is_array($items) && !($items instanceof Traversable)) {
182		$this->doThrow('Invalid input type for '.__METHOD__.', cannot merge.', $items);
183		}
184		$collection = $inPlace ? $this : clone $this;
185		foreach ($items as $key => $value) {
186		$collection->set($key, $value);
187		}
188
189		return $collection;
190		}
191
192		/**
193		* {@inheritdoc}
194		*/
195	View Code Duplication	public function union($items, $inPlace = false)
		0 ignored issues – show Duplication introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
196		{
197		if (!is_array($items) && !($items instanceof Traversable)) {
198		$this->doThrow('Invalid input type for '.__METHOD__.', cannot union.', $items);
199		}
200		$collection = $inPlace ? $this : clone $this;
201		foreach ($items as $key => $value) {
202		if (!$collection->containsKey($key)) {
203		$collection->set($key, $value);
204		}
205		}
206
207		return $collection;
208		}
209
210		/**
211		* {@inheritdoc}
212		*/
213		public function reverse()
214		{
215		$collection = Factory::create([], static::class);
216		$count = $this->count();
217		$keys = $this->keys();
218		$values = $this->values();
219
220		for ($i = $count - 1; $i >= 0; $i--) {
221		$collection->set($keys[$i], $values[$i]);
222		}
223
224		return $collection;
225		}
226
227		/**
228		* {@inheritdoc}
229		*/
230		public function shift()
231		{
232		reset($this->items);
233
234		return $this->pull($this->key());
235		}
236
237		/**
238		* {@inheritdoc}
239		*/
240		public function pop()
241		{
242		end($this->items);
243
244		return $this->pull($this->key());
245		}
246
247		/**
248		* {@inheritdoc}
249		*/
250		public function chunk($size)
251		{
252		$collection = Factory::create();
253		$chunk = Factory::create();
254		foreach ($this->items as $key => $value) {
255		$chunk->set($key, $value);
256		if ($chunk->count() == $size) {
257		$collection->add($chunk);
258		$chunk = Factory::create();
259		}
260		}
261		if (!$chunk->isEmpty()) {
262		$collection->add($chunk);
263		}
264
265		return $collection;
266		}
267
268		/**
269		* {@inheritdoc}
270		*/
271		public function slice($offset, $length = PHP_INT_MAX)
272		{
273		if ($offset < 0) {
274		$offset = $this->count() + $offset;
275		}
276
277		return $this->filter(
278		function ($value, $key, $index) use ($offset, $length) {
279		return ($index >= $offset) && ($index < $offset + $length);
280		}
281		);
282		}
283
284		/**
285		* {@inheritdoc}
286		*/
287		public function diff($items)
288		{
289		$itemsCollection = Factory::create($items);
290
291		return $this->filter(
292		function ($value, $key, $index) use ($itemsCollection) {
		0 ignored issues – show Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$key` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$index` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
293		return !$itemsCollection->contains($value);
294		}
295		);
296		}
297
298		/**
299		* {@inheritdoc}
300		*/
301		public function diffKeys($items)
302		{
303		$itemsCollection = Factory::create($items);
304
305		return $this->filter(
306		function ($value, $key, $index) use ($itemsCollection) {
		0 ignored issues – show Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$index` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
307		return !$itemsCollection->containsKey($key);
308		}
309		);
310		}
311
312		/**
313		* {@inheritdoc}
314		*/
315		public function intersect($items)
316		{
317		$itemsCollection = Factory::create($items);
318
319		return $this->filter(
320		function ($value, $key, $index) use ($itemsCollection) {
		0 ignored issues – show Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$key` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$index` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
321		return $itemsCollection->contains($value);
322		}
323		);
324		}
325
326		/**
327		* {@inheritdoc}
328		*/
329		public function intersectKeys($items)
330		{
331		$itemsCollection = Factory::create($items);
332
333		return $this->filter(
334		function ($value, $key, $index) use ($itemsCollection) {
		0 ignored issues – show Unused Code introduced 2017-02-06 02:57 UTC by Report Bug Copy Issue Report The parameter `$index` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
335		return $itemsCollection->containsKey($key);
336		}
337		);
338		}
339		}
340

Novactive / NovaCollection

GitHub Access Token became invalid

Branch — develop (05114b)

ForeachMethodCollection::reduce() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like