Collection - Code Metrics - Inspection of "add method to interface" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( c7b612...cf2f60 )

by Baptiste

created 2015-12-16 07:46 UTC

Collection B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	443
Duplicated Lines	7.45 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	50
c	2
b	0
f	0
lcom	1
cbo	2
dl	33
loc	443
ccs	0
cts	260
cp	0
rs	8.6207

41 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	toPrimitive()	0	4	1
A	filter()	0	10	2
A	intersect()	0	7	1
A	chunk()	0	4	1
A	shift()	0	7	1
A	reduce()	0	4	1
A	search()	0	4	1
A	uintersect()	0	8	1
A	keyIntersect()	0	7	1
A	map()	0	4	1
A	pad()	0	4	1
A	pop()	0	7	1
A	sum()	0	4	1
A	diff()	0	4	1
A	flip()	0	4	1
A	keys()	0	4	1
A	push()	0	7	1
A	rand()	0	17	3
A	merge()	0	7	1
A	slice()	0	9	2
A	udiff()	0	8	1
A	column()	0	8	1
A	splice()	0	7	1
A	unique()	0	4	1
A	values()	0	4	1
A	product()	0	4	1
A	replace()	0	7	1
A	reverse()	0	4	1
A	unshift()	0	7	1
A	keyDiff()	0	7	1
A	ukeyDiff()	0	8	1
A	associativeDiff()	0	7	1
A	hasKey()	0	10	2
A	countValues()	0	4	1
A	ukeyIntersect()	0	8	1
A	associativeIntersect()	0	7	1
A	sort()	11	11	2
A	associativeSort()	11	11	2
A	keySort()	11	11	2
A	ukeySort()	0	11	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Collection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Collection, and based on these observations, apply Extract Interface, too.

<?php

namespace Innmind\Immutable;

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);
        }

        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)
    {
        return new self(array_keys($this->values, $search, (bool) $strict));
    }

    /**
     * {@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()->toPrimitive()) {

            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 new BooleanPrimitive($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 \Exception('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 \Exception('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 \Exception('Sort failure');
        }

        return new self($values);
    }

    /**
     * {@inheritdoc}
     */
    public function ukeySort(callable $sorter)
    {
        $values = $this->values;
        $bool = uksort($values, $sorter);

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

        return new self($values);
    }
}


1		<?php
2
3		namespace Innmind\Immutable;
4
5		class Collection implements CollectionInterface
		0 ignored issues – show Bug introduced 2015-12-16 07:48 UTC by Report Bug Copy Issue Report There is at least one abstract method in this class. Maybe declare it as abstract, or implement the remaining methods: append, associativeReverseSort, count, current, each, first, join, key, keyReverseSort, last, naturalSort, next, offsetExists, offsetGet, offsetSet, offsetUnset, reverseSort, rewind, shuffle, take, uassociativeSort, usort, valid Loading history...
6		{
7		private $values;
8
9		public function __construct(array $values)
10		{
11		$this->values = $values;
12		}
13
14		/**
15		* {@inheritdoc}
16		*/
17		public function toPrimitive()
18		{
19		return $this->values;
20		}
21
22		/**
23		* {@inheritdoc}
24		*/
25		public function filter(callable $filter = null)
26		{
27		if ($filter === null) {
28		$values = array_filter($this->values);
29		} else {
30		$values = array_filter($this->values, $filter);
31		}
32
33		return new self($values);
34		}
35
36		/**
37		* {@inheritdoc}
38		*/
39		public function intersect(CollectionInterface $collection)
40		{
41		return new self(array_intersect(
42		$this->values,
43		$collection->toPrimitive()
44		));
45		}
46
47		/**
48		* {@inheritdoc}
49		*/
50		public function chunk($size)
51		{
52		return new self(array_chunk($this->values, (int) $size));
53		}
54
55		/**
56		* {@inheritdoc}
57		*/
58		public function shift()
59		{
60		$values = $this->values;
61		array_shift($values);
62
63		return new self($values);
64		}
65
66		/**
67		* {@inheritdoc}
68		*/
69		public function reduce(callable $reducer, $initial = null)
70		{
71		return array_reduce($this->values, $reducer, $initial);
72		}
73
74		/**
75		* {@inheritdoc}
76		*/
77		public function search($needle, $strict = true)
78		{
79		return array_search($needle, $this->values, (bool) $strict);
80		}
81
82		/**
83		* {@inheritdoc}
84		*/
85		public function uintersect(CollectionInterface $collection, callable $intersecter)
86		{
87		return new self(array_uintersect(
88		$this->values,
89		$collection->toPrimitive(),
90		$intersecter
91		));
92		}
93
94		/**
95		* {@inheritdoc}
96		*/
97		public function keyIntersect(CollectionInterface $collection)
98		{
99		return new self(array_intersect_key(
100		$this->values,
101		$collection->toPrimitive()
102		));
103		}
104
105		/**
106		* {@inheritdoc}
107		*/
108		public function map(callable $mapper)
109		{
110		return new self(array_map($mapper, $this->values));
111		}
112
113		/**
114		* {@inheritdoc}
115		*/
116		public function pad($size, $value)
117		{
118		return new self(array_pad($this->values, (int) $size, $value));
119		}
120
121		/**
122		* {@inheritdoc}
123		*/
124		public function pop()
125		{
126		$values = $this->values;
127		array_pop($values);
128
129		return new self($values);
130		}
131
132		/**
133		* {@inheritdoc}
134		*/
135		public function sum()
136		{
137		return array_sum($this->values);
138		}
139
140		/**
141		* {@inheritdoc}
142		*/
143		public function diff(CollectionInterface $collection)
144		{
145		return new self(array_diff($this->values, $collection->toPrimitive()));
146		}
147
148		/**
149		* {@inheritdoc}
150		*/
151		public function flip()
152		{
153		return new self(array_flip($this->values));
154		}
155
156		/**
157		* {@inheritdoc}
158		*/
159		public function keys($search = null, $strict = true)
160		{
161		return new self(array_keys($this->values, $search, (bool) $strict));
162		}
163
164		/**
165		* {@inheritdoc}
166		*/
167		public function push($value)
168		{
169		$values = $this->values;
170		array_push($values, $value);
171
172		return new self($values);
173		}
174
175		/**
176		* {@inheritdoc}
177		*/
178		public function rand($num = 1)
179		{
180		if ((int) $num > $this->count()->toPrimitive()) {
		0 ignored issues – show Bug introduced 2015-12-16 07:48 UTC by Report Bug Copy Issue Report The method `toPrimitive` cannot be called on `$this->count()` (of type `integer`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
181		throw new OutOfBoundException(
182		'Trying to return a wider collection than the current one'
183		);
184		}
185
186		$keys = (array) array_rand($this->values, $num);
187		$values = [];
188
189		foreach ($keys as $key) {
190		$values[$key] = $this->values[$key];
191		}
192
193		return new self($values);
194		}
195
196		/**
197		* {@inheritdoc}
198		*/
199		public function merge(CollectionInterface $collection)
200		{
201		return new self(array_merge(
202		$this->values,
203		$collection->toPrimitive()
204		));
205		}
206
207		/**
208		* {@inheritdoc}
209		*/
210		public function slice($offset, $length = null, $preserveKeys = false)
211		{
212		return new self(array_slice(
213		$this->values,
214		(int) $offset,
215		$length === null ? null : (int) $length,
216		(bool) $preserveKeys
217		));
218		}
219
220		/**
221		* {@inheritdoc}
222		*/
223		public function udiff(CollectionInterface $collection, callable $differ)
224		{
225		return new self(array_udiff(
226		$this->values,
227		$collection->toPrimitive(),
228		$differ
229		));
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235		public function column($key, $indexKey = null)
236		{
237		return new self(array_column(
238		$this->values,
239		$key,
240		$indexKey
241		));
242		}
243
244		/**
245		* {@inheritdoc}
246		*/
247		public function splice($offset, $length = 0, $replacement = [])
248		{
249		$values = $this->values;
250		array_splice($values, (int) $offset, (int) $length, $replacement);
251
252		return new self($values);
253		}
254
255		/**
256		* {@inheritdoc}
257		*/
258		public function unique($flags = SORT_REGULAR)
259		{
260		return new self(array_unique($this->values, (int) $flags));
261		}
262
263		/**
264		* {@inheritdoc}
265		*/
266		public function values()
267		{
268		return new self(array_values($this->values));
269		}
270
271		/**
272		* {@inheritdoc}
273		*/
274		public function product()
275		{
276		return array_product($this->values);
277		}
278
279		/**
280		* {@inheritdoc}
281		*/
282		public function replace(CollectionInterface $collection)
283		{
284		return new self(array_replace(
285		$this->values,
286		$collection->toPrimitive()
287		));
288		}
289
290		/**
291		* {@inheritdoc}
292		*/
293		public function reverse($preserveKeys = false)
294		{
295		return new self(array_reverse($this->values, (bool) $preserveKeys));
296		}
297
298		/**
299		* {@inheritdoc}
300		*/
301		public function unshift($value)
302		{
303		$values = $this->values;
304		array_unshift($values, $value);
305
306		return new self($values);
307		}
308
309		/**
310		* {@inheritdoc}
311		*/
312		public function keyDiff(CollectionInterface $collection)
313		{
314		return new self(array_diff_key(
315		$this->values,
316		$collection->toPrimitive()
317		));
318		}
319
320		/**
321		* {@inheritdoc}
322		*/
323		public function ukeyDiff(CollectionInterface $collection, callable $differ)
324		{
325		return new self(array_diff_ukey(
326		$this->values,
327		$collection->toPrimitive(),
328		$differ
329		));
330		}
331
332		/**
333		* {@inheritdoc}
334		*/
335		public function associativeDiff(CollectionInterface $collection)
336		{
337		return new self(array_diff_assoc(
338		$this->values,
339		$collection->toPrimitive()
340		));
341		}
342
343		/**
344		* {@inheritdoc}
345		*/
346		public function hasKey($key, $strict = true)
347		{
348		if ((bool) $strict === true) {
349		$bool = array_key_exists($key, $this->values);
350		} else {
351		$bool = isset($this->values[$key]);
352		}
353
354		return new BooleanPrimitive($bool);
355		}
356
357		/**
358		* {@inheritdoc}
359		*/
360		public function countValues()
361		{
362		return new self(array_count_values($this->values));
363		}
364
365		/**
366		* {@inheritdoc}
367		*/
368		public function ukeyIntersect(CollectionInterface $collection, callable $intersecter)
369		{
370		return new self(array_intersect_ukey(
371		$this->values,
372		$collection->toPrimitive(),
373		$intersecter
374		));
375		}
376
377		/**
378		* {@inheritdoc}
379		*/
380		public function associativeIntersect(CollectionInterface $collection)
381		{
382		return new self(array_intersect_assoc(
383		$this->values,
384		$collection->toPrimitive()
385		));
386		}
387
388		/**
389		* {@inheritdoc}
390		*/
391	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 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...
392		{
393		$values = $this->values;
394		$bool = sort($values, (int) $flags);
395
396		if ($bool === false) {
397		throw new \Exception('Sort failure');
398		}
399
400		return new self($values);
401		}
402
403		/**
404		* {@inheritdoc}
405		*/
406	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 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...
407		{
408		$values = $this->values;
409		$bool = asort($values, (int) $flags);
410
411		if ($bool === false) {
412		throw new \Exception('Sort failure');
413		}
414
415		return new self($values);
416		}
417
418		/**
419		* {@inheritdoc}
420		*/
421	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 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...
422		{
423		$values = $this->values;
424		$bool = ksort($values, (int) $flags);
425
426		if ($bool === false) {
427		throw new \Exception('Sort failure');
428		}
429
430		return new self($values);
431		}
432
433		/**
434		* {@inheritdoc}
435		*/
436		public function ukeySort(callable $sorter)
437		{
438		$values = $this->values;
439		$bool = uksort($values, $sorter);
440
441		if ($bool === false) {
442		throw new \Exception('Sort failure');
443		}
444
445		return new self($values);
446		}
447		}
448

Innmind / Immutable

GitHub Access Token became invalid