Issues in Collection.php - All Issues - Inspection of "add missing classes" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( e9c41b...f51db1 )

by Baptiste

created 2015-12-19 14:56 UTC

Collection.php (12 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\SortException;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use Innmind\Immutable\Exception\OutOfBoundException;
use Innmind\Immutable\Exception\RuntimeException;
use Innmind\Immutable\Exception\InvalidArgumentException;
use Innmind\Immutable\Exception\LogicException;

class Collection implements CollectionInterface
{
    private $values;

    public function __construct(array $values)
    {
        $this->values = $values;
    }

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

    /**
     * {@inheritdoc}
     */
    public function filter(callable $filter = null)
    {
        if ($filter === null) {
            $values = array_filter($this->values);
        } else {
            $values = array_filter(
                $this->values,
                $filter,
                ARRAY_FILTER_USE_BOTH
            );
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(CollectionInterface $collection)
    {
        return new self(array_intersect(
            $this->values,
            $collection->toPrimitive()
        ));
    }

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

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

        return new self($values);
    }

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

    /**
     * {@inheritdoc}
     */
    public function search($needle, $strict = true)
    {
        return array_search($needle, $this->values, (bool) $strict);
    }

    /**
     * {@inheritdoc}
     */
    public function uintersect(CollectionInterface $collection, callable $intersecter)
    {
        return new self(array_uintersect(
            $this->values,
            $collection->toPrimitive(),
            $intersecter
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function keyIntersect(CollectionInterface $collection)
    {
        return new self(array_intersect_key(
            $this->values,
            $collection->toPrimitive()
        ));
    }

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

    /**
     * {@inheritdoc}
     */
    public function pad($size, $value)
    {
        return new self(array_pad($this->values, (int) $size, $value));
    }

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

        return new self($values);
    }

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

    /**
     * {@inheritdoc}
     */
    public function diff(CollectionInterface $collection)
    {
        return new self(array_diff($this->values, $collection->toPrimitive()));
    }

    /**
     * {@inheritdoc}
     */
    public function flip()
    {
        return new self(array_flip($this->values));
    }

    /**
     * {@inheritdoc}
     */
    public function keys($search = null, $strict = true)
    {
        $args = func_get_args();

        if (count($args) > 0) {
            $keys = array_keys($this->values, $search, (bool) $strict);
        } else {
            $keys = array_keys($this->values);
        }

        return new self($keys);
    }

    /**
     * {@inheritdoc}
     */
    public function push($value)
    {
        $values = $this->values;
        array_push($values, $value);

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function rand($num = 1)
    {
        if ((int) $num > $this->count()) {
            throw new OutOfBoundException(
                'Trying to return a wider collection than the current one'
            );
        }

        $keys = (array) array_rand($this->values, $num);
        $values = [];

        foreach ($keys as $key) {
            $values[$key] = $this->values[$key];
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function merge(CollectionInterface $collection)
    {
        return new self(array_merge(
            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function slice($offset, $length = null, $preserveKeys = false)
    {
        return new self(array_slice(
            $this->values,
            (int) $offset,
            $length === null ? null : (int) $length,
            (bool) $preserveKeys
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function udiff(CollectionInterface $collection, callable $differ)
    {
        return new self(array_udiff(
            $this->values,
            $collection->toPrimitive(),
            $differ
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function column($key, $indexKey = null)
    {
        return new self(array_column(
            $this->values,
            $key,
            $indexKey
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function splice($offset, $length = 0, $replacement = [])
    {
        $values = $this->values;
        array_splice($values, (int) $offset, (int) $length, $replacement);

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function unique($flags = SORT_REGULAR)
    {
        return new self(array_unique($this->values, (int) $flags));
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function replace(CollectionInterface $collection)
    {
        return new self(array_replace(
            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function reverse($preserveKeys = false)
    {
        return new self(array_reverse($this->values, (bool) $preserveKeys));
    }

    /**
     * {@inheritdoc}
     */
    public function unshift($value)
    {
        $values = $this->values;
        array_unshift($values, $value);

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function keyDiff(CollectionInterface $collection)
    {
        return new self(array_diff_key(
            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function ukeyDiff(CollectionInterface $collection, callable $differ)
    {
        return new self(array_diff_ukey(
            $this->values,
            $collection->toPrimitive(),
            $differ
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function associativeDiff(CollectionInterface $collection)
    {
        return new self(array_diff_assoc(
            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function hasKey($key, $strict = true)
    {
        if ((bool) $strict === true) {
            $bool = array_key_exists($key, $this->values);
        } else {
            $bool = isset($this->values[$key]);
        }

        return $bool;
    }

    /**
     * {@inheritdoc}
     */
    public function countValues()
    {
        return new self(array_count_values($this->values));
    }

    /**
     * {@inheritdoc}
     */
    public function ukeyIntersect(CollectionInterface $collection, callable $intersecter)
    {
        return new self(array_intersect_ukey(
            $this->values,
            $collection->toPrimitive(),
            $intersecter
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function associativeIntersect(CollectionInterface $collection)
    {
        return new self(array_intersect_assoc(
            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function sort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = sort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function associativeSort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = asort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function keySort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = ksort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function ukeySort(callable $sorter)

    {
        $values = $this->values;
        $bool = uksort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function reverseSort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = rsort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function usort(callable $sorter)

    {
        $values = $this->values;
        $bool = usort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function associativeReverseSort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = arsort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function keyReverseSort($flags = SORT_REGULAR)

    {
        $values = $this->values;
        $bool = krsort($values, (int) $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function uassociativeSort(callable $sorter)

    {
        $values = $this->values;
        $bool = uasort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function naturalSort()
    {
        $values = $this->values;
        $bool = natsort($values);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);
    }

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

    {
        if ($this->count() === 0) {
            throw new OutOfBoundException('There is no first item');
        }

        return array_values($this->values)[0];
    }

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

    {
        if ($this->count() === 0) {
            throw new OutOfBoundException('There is no last item');
        }

        $values = array_values($this->values);

        return end($values);
    }

    /**
     * {@inheritdoc}
     */
    public function each(callable $callback)
    {
        foreach ($this->values as $key => $value) {
            $callback($key, $value);
        }

        return $this;
    }

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

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

        if ($result === false) {
            throw new RuntimeException('Shuffle operation failed');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function take($size, $preserveKeys = false)
    {
        $took = [];
        $keys = array_keys($this->values);
        $size = (int) $size;

        while (count($took) < $size) {
            $random = mt_rand(0, count($keys) - 1);
            $key = $keys[$random];
            $took[$key] = $this->values[$key];
            unset($keys[$random]);
        }

        if ($preserveKeys === false) {
            $took = array_values($took);
        }

        return new self($took);
    }

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function valid()
    {
        return $this->key() !== null;
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        if (!$this->hasKey($offset)) {
            throw new InvalidArgumentException(sprintf(
                'Unknown index %s',
                $offset
            ));
        }

        return $this->values[$offset];
    }

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

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


GitHub Access Token became invalid

Push — develop ( e9c41b...f51db1 )

Collection.php (12 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

1			<?php
2
3			namespace Innmind\Immutable;
4
5			use Innmind\Immutable\Exception\SortException;
			0 ignored issues – show Bug introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this This use statement conflicts with another class in this namespace, `Innmind\Immutable\SortException`. Let’s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let’s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
6			use Innmind\Immutable\Exception\OutOfBoundException;
7			use Innmind\Immutable\Exception\RuntimeException;
8			use Innmind\Immutable\Exception\InvalidArgumentException;
9			use Innmind\Immutable\Exception\LogicException;
10
11			class Collection implements CollectionInterface
12			{
13			private $values;
14
15	37		public function __construct(array $values)
16			{
17	37		$this->values = $values;
18	37		}
19
20			/**
21			* {@inheritdoc}
22			*/
23	33		public function toPrimitive()
24			{
25	33		return $this->values;
26			}
27
28			/**
29			* {@inheritdoc}
30			*/
31	1		public function filter(callable $filter = null)
32			{
33	1		if ($filter === null) {
34	1		$values = array_filter($this->values);
35	1		} else {
36	1		$values = array_filter(
37	1		$this->values,
38	1		$filter,
39			ARRAY_FILTER_USE_BOTH
40	1		);
41			}
42
43	1		return new self($values);
44			}
45
46			/**
47			* {@inheritdoc}
48			*/
49	1		public function intersect(CollectionInterface $collection)
50			{
51	1		return new self(array_intersect(
52	1		$this->values,
53	1		$collection->toPrimitive()
54	1		));
55			}
56
57			/**
58			* {@inheritdoc}
59			*/
60	1		public function chunk($size)
61			{
62	1		return new self(array_chunk($this->values, (int) $size));
63			}
64
65			/**
66			* {@inheritdoc}
67			*/
68	1		public function shift()
69			{
70	1		$values = $this->values;
71	1		array_shift($values);
72
73	1		return new self($values);
74			}
75
76			/**
77			* {@inheritdoc}
78			*/
79	1		public function reduce(callable $reducer, $initial = null)
80			{
81	1		return array_reduce($this->values, $reducer, $initial);
82			}
83
84			/**
85			* {@inheritdoc}
86			*/
87	1		public function search($needle, $strict = true)
88			{
89	1		return array_search($needle, $this->values, (bool) $strict);
90			}
91
92			/**
93			* {@inheritdoc}
94			*/
95	1		public function uintersect(CollectionInterface $collection, callable $intersecter)
96			{
97	1		return new self(array_uintersect(
98	1		$this->values,
99	1		$collection->toPrimitive(),
100			$intersecter
101	1		));
102			}
103
104			/**
105			* {@inheritdoc}
106			*/
107	1		public function keyIntersect(CollectionInterface $collection)
108			{
109	1		return new self(array_intersect_key(
110	1		$this->values,
111	1		$collection->toPrimitive()
112	1		));
113			}
114
115			/**
116			* {@inheritdoc}
117			*/
118	1		public function map(callable $mapper)
119			{
120	1		return new self(array_map($mapper, $this->values));
121			}
122
123			/**
124			* {@inheritdoc}
125			*/
126	1		public function pad($size, $value)
127			{
128	1		return new self(array_pad($this->values, (int) $size, $value));
129			}
130
131			/**
132			* {@inheritdoc}
133			*/
134	1		public function pop()
135			{
136	1		$values = $this->values;
137	1		array_pop($values);
138
139	1		return new self($values);
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145	1		public function sum()
146			{
147	1		return array_sum($this->values);
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153	1		public function diff(CollectionInterface $collection)
154			{
155	1		return new self(array_diff($this->values, $collection->toPrimitive()));
156			}
157
158			/**
159			* {@inheritdoc}
160			*/
161	1		public function flip()
162			{
163	1		return new self(array_flip($this->values));
164			}
165
166			/**
167			* {@inheritdoc}
168			*/
169	1		public function keys($search = null, $strict = true)
170			{
171	1		$args = func_get_args();
172
173	1		if (count($args) > 0) {
174	1		$keys = array_keys($this->values, $search, (bool) $strict);
175	1		} else {
176	1		$keys = array_keys($this->values);
177			}
178
179	1		return new self($keys);
180			}
181
182			/**
183			* {@inheritdoc}
184			*/
185	1		public function push($value)
186			{
187	1		$values = $this->values;
188	1		array_push($values, $value);
189
190	1		return new self($values);
191			}
192
193			/**
194			* {@inheritdoc}
195			*/
196	2		public function rand($num = 1)
197			{
198	2		if ((int) $num > $this->count()) {
199	1		throw new OutOfBoundException(
200			'Trying to return a wider collection than the current one'
201	1		);
202			}
203
204	1		$keys = (array) array_rand($this->values, $num);
205	1		$values = [];
206
207	1		foreach ($keys as $key) {
208	1		$values[$key] = $this->values[$key];
209	1		}
210
211	1		return new self($values);
212			}
213
214			/**
215			* {@inheritdoc}
216			*/
217	1		public function merge(CollectionInterface $collection)
218			{
219	1		return new self(array_merge(
220	1		$this->values,
221	1		$collection->toPrimitive()
222	1		));
223			}
224
225			/**
226			* {@inheritdoc}
227			*/
228	1		public function slice($offset, $length = null, $preserveKeys = false)
229			{
230	1		return new self(array_slice(
231	1		$this->values,
232	1		(int) $offset,
233	1		$length === null ? null : (int) $length,
234			(bool) $preserveKeys
235	1		));
236			}
237
238			/**
239			* {@inheritdoc}
240			*/
241	1		public function udiff(CollectionInterface $collection, callable $differ)
242			{
243	1		return new self(array_udiff(
244	1		$this->values,
245	1		$collection->toPrimitive(),
246			$differ
247	1		));
248			}
249
250			/**
251			* {@inheritdoc}
252			*/
253	1		public function column($key, $indexKey = null)
254			{
255	1		return new self(array_column(
256	1		$this->values,
257	1		$key,
258			$indexKey
259	1		));
260			}
261
262			/**
263			* {@inheritdoc}
264			*/
265	1		public function splice($offset, $length = 0, $replacement = [])
266			{
267	1		$values = $this->values;
268	1		array_splice($values, (int) $offset, (int) $length, $replacement);
269
270	1		return new self($values);
271			}
272
273			/**
274			* {@inheritdoc}
275			*/
276	1		public function unique($flags = SORT_REGULAR)
277			{
278	1		return new self(array_unique($this->values, (int) $flags));
279			}
280
281			/**
282			* {@inheritdoc}
283			*/
284	1		public function values()
285			{
286	1		return new self(array_values($this->values));
287			}
288
289			/**
290			* {@inheritdoc}
291			*/
292	1		public function product()
293			{
294	1		return array_product($this->values);
295			}
296
297			/**
298			* {@inheritdoc}
299			*/
300	1		public function replace(CollectionInterface $collection)
301			{
302	1		return new self(array_replace(
303	1		$this->values,
304	1		$collection->toPrimitive()
305	1		));
306			}
307
308			/**
309			* {@inheritdoc}
310			*/
311	1		public function reverse($preserveKeys = false)
312			{
313	1		return new self(array_reverse($this->values, (bool) $preserveKeys));
314			}
315
316			/**
317			* {@inheritdoc}
318			*/
319	1		public function unshift($value)
320			{
321	1		$values = $this->values;
322	1		array_unshift($values, $value);
323
324	1		return new self($values);
325			}
326
327			/**
328			* {@inheritdoc}
329			*/
330	1		public function keyDiff(CollectionInterface $collection)
331			{
332	1		return new self(array_diff_key(
333	1		$this->values,
334	1		$collection->toPrimitive()
335	1		));
336			}
337
338			/**
339			* {@inheritdoc}
340			*/
341	1		public function ukeyDiff(CollectionInterface $collection, callable $differ)
342			{
343	1		return new self(array_diff_ukey(
344	1		$this->values,
345	1		$collection->toPrimitive(),
346			$differ
347	1		));
348			}
349
350			/**
351			* {@inheritdoc}
352			*/
353	1		public function associativeDiff(CollectionInterface $collection)
354			{
355	1		return new self(array_diff_assoc(
356	1		$this->values,
357	1		$collection->toPrimitive()
358	1		));
359			}
360
361			/**
362			* {@inheritdoc}
363			*/
364	1		public function hasKey($key, $strict = true)
365			{
366	1		if ((bool) $strict === true) {
367	1		$bool = array_key_exists($key, $this->values);
368	1		} else {
369	1		$bool = isset($this->values[$key]);
370			}
371
372	1		return $bool;
373			}
374
375			/**
376			* {@inheritdoc}
377			*/
378	1		public function countValues()
379			{
380	1		return new self(array_count_values($this->values));
381			}
382
383			/**
384			* {@inheritdoc}
385			*/
386	1		public function ukeyIntersect(CollectionInterface $collection, callable $intersecter)
387			{
388	1		return new self(array_intersect_ukey(
389	1		$this->values,
390	1		$collection->toPrimitive(),
391			$intersecter
392	1		));
393			}
394
395			/**
396			* {@inheritdoc}
397			*/
398	1		public function associativeIntersect(CollectionInterface $collection)
399			{
400	1		return new self(array_intersect_assoc(
401	1		$this->values,
402	1		$collection->toPrimitive()
403	1		));
404			}
405
406			/**
407			* {@inheritdoc}
408			*/
409		View Code Duplication	public function sort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-16 07:48 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
410			{
411			$values = $this->values;
412			$bool = sort($values, (int) $flags);
413
414			if ($bool === false) {
415			throw new SortException('Sort failure');
416			}
417
418			return new self($values);
419			}
420
421			/**
422			* {@inheritdoc}
423			*/
424		View Code Duplication	public function associativeSort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-16 07:48 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
425			{
426			$values = $this->values;
427			$bool = asort($values, (int) $flags);
428
429			if ($bool === false) {
430			throw new SortException('Sort failure');
431			}
432
433			return new self($values);
434			}
435
436			/**
437			* {@inheritdoc}
438			*/
439		View Code Duplication	public function keySort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-16 07:48 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
440			{
441			$values = $this->values;
442			$bool = ksort($values, (int) $flags);
443
444			if ($bool === false) {
445			throw new SortException('Sort failure');
446			}
447
448			return new self($values);
449			}
450
451			/**
452			* {@inheritdoc}
453			*/
454		View Code Duplication	public function ukeySort(callable $sorter)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
455			{
456			$values = $this->values;
457			$bool = uksort($values, $sorter);
458
459			if ($bool === false) {
460			throw new SortException('Sort failure');
461			}
462
463			return new self($values);
464			}
465
466			/**
467			* {@inheritdoc}
468			*/
469		View Code Duplication	public function reverseSort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
470			{
471			$values = $this->values;
472			$bool = rsort($values, (int) $flags);
473
474			if ($bool === false) {
475			throw new SortException('Sort failure');
476			}
477
478			return new self($values);
479			}
480
481			/**
482			* {@inheritdoc}
483			*/
484		View Code Duplication	public function usort(callable $sorter)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
485			{
486			$values = $this->values;
487			$bool = usort($values, $sorter);
488
489			if ($bool === false) {
490			throw new SortException('Sort failure');
491			}
492
493			return new self($values);
494			}
495
496			/**
497			* {@inheritdoc}
498			*/
499		View Code Duplication	public function associativeReverseSort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
500			{
501			$values = $this->values;
502			$bool = arsort($values, (int) $flags);
503
504			if ($bool === false) {
505			throw new SortException('Sort failure');
506			}
507
508			return new self($values);
509			}
510
511			/**
512			* {@inheritdoc}
513			*/
514		View Code Duplication	public function keyReverseSort($flags = SORT_REGULAR)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
515			{
516			$values = $this->values;
517			$bool = krsort($values, (int) $flags);
518
519			if ($bool === false) {
520			throw new SortException('Sort failure');
521			}
522
523			return new self($values);
524			}
525
526			/**
527			* {@inheritdoc}
528			*/
529		View Code Duplication	public function uassociativeSort(callable $sorter)
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
530			{
531			$values = $this->values;
532			$bool = uasort($values, $sorter);
533
534			if ($bool === false) {
535			throw new SortException('Sort failure');
536			}
537
538			return new self($values);
539			}
540
541			/**
542			* {@inheritdoc}
543			*/
544			public function naturalSort()
545			{
546			$values = $this->values;
547			$bool = natsort($values);
548
549			if ($bool === false) {
550			throw new SortException('Sort failure');
551			}
552
553			return new self($values);
554			}
555
556			/**
557			* {@inheritdoc}
558			*/
559		View Code Duplication	public function first()
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
560			{
561			if ($this->count() === 0) {
562			throw new OutOfBoundException('There is no first item');
563			}
564
565			return array_values($this->values)[0];
566			}
567
568			/**
569			* {@inheritdoc}
570			*/
571		View Code Duplication	public function last()
			0 ignored issues – show Duplication introduced 2015-12-17 07:53 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
572			{
573			if ($this->count() === 0) {
574			throw new OutOfBoundException('There is no last item');
575			}
576
577			$values = array_values($this->values);
578
579			return end($values);
580			}
581
582			/**
583			* {@inheritdoc}
584			*/
585			public function each(callable $callback)
586			{
587			foreach ($this->values as $key => $value) {
588			$callback($key, $value);
589			}
590
591			return $this;
592			}
593
594			/**
595			* {@inheritdoc}
596			*/
597			public function join($separator)
598			{
599			return implode((string) $separator, $this->values);
600			}
601
602			/**
603			* {@inheritdoc}
604			*/
605			public function shuffle()
606			{
607			$values = $this->values;
608			$result = shuffle($values);
609
610			if ($result === false) {
611			throw new RuntimeException('Shuffle operation failed');
612			}
613
614			return new self($values);
615			}
616
617			/**
618			* {@inheritdoc}
619			*/
620			public function take($size, $preserveKeys = false)
621			{
622			$took = [];
623			$keys = array_keys($this->values);
624			$size = (int) $size;
625
626			while (count($took) < $size) {
627			$random = mt_rand(0, count($keys) - 1);
628			$key = $keys[$random];
629			$took[$key] = $this->values[$key];
630			unset($keys[$random]);
631			}
632
633			if ($preserveKeys === false) {
634			$took = array_values($took);
635			}
636
637			return new self($took);
638			}
639
640			/**
641			* {@inheritdoc}
642			*/
643	2		public function count()
644			{
645	2		return count($this->values);
646			}
647
648			/**
649			* {@inheritdoc}
650			*/
651			public function current()
652			{
653			return current($this->values);
654			}
655
656			/**
657			* {@inheritdoc}
658			*/
659			public function key()
660			{
661			return key($this->values);
662			}
663
664			/**
665			* {@inheritdoc}
666			*/
667			public function next()
668			{
669			next($this->values);
670			}
671
672			/**
673			* {@inheritdoc}
674			*/
675			public function rewind()
676			{
677			reset($this->values);
678			}
679
680			/**
681			* {@inheritdoc}
682			*/
683			public function valid()
684			{
685			return $this->key() !== null;
686			}
687
688			/**
689			* {@inheritdoc}
690			*/
691			public function offsetExists($offset)
692			{
693			return $this->hasKey($offset);
694			}
695
696			/**
697			* {@inheritdoc}
698			*/
699			public function offsetGet($offset)
700			{
701			if (!$this->hasKey($offset)) {
702			throw new InvalidArgumentException(sprintf(
703			'Unknown index %s',
704			$offset
705			));
706			}
707
708			return $this->values[$offset];
709			}
710
711			/**
712			* {@inheritdoc}
713			*/
714			public function offsetSet($offset, $value)
715			{
716			throw new LogicException('You can\'t modify an immutable collection');
717			}
718
719			/**
720			* {@inheritdoc}
721			*/
722			public function offsetUnset($offset)
723			{
724			throw new LogicException('You can\'t modify an immutable collection');
725			}
726			}
727

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( e9c41b...f51db1 )

Collection.php (12 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like