Sequence - Code Metrics - Inspection of "Merge branch 'develop'" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3fd0c3...e8feac )

by Baptiste

created 2016-03-05 10:36 UTC

Sequence B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	398
Duplicated Lines	1.76 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

98.41%

Metric	Value
wmc	50
lcom	1
cbo	7
dl	7
loc	398
ccs	124
cts	126
cp	0.9841
rs	8.6206

39 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	size()	0	4	1
A	count()	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	11	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	toPrimitive()	0	4	1
A	get()	0	8	2
A	diff()	0	9	1
A	distinct()	0	4	1
A	drop()	0	4	1
A	dropEnd()	0	4	1
A	equals()	0	4	1
A	filter()	0	7	1
A	foreach()	0	8	2
A	first()	0	4	1
A	last()	0	4	1
A	contains()	0	4	1
A	indexOf()	0	10	2
A	indices()	0	4	1
A	map()	0	4	1
A	pad()	0	4	1
A	partition()	0	18	3
A	slice()	0	8	1
A	splitAt()	0	7	1
A	take()	0	4	1
A	takeEnd()	0	4	1
A	append()	0	4	1
A	intersect()	0	4	1
A	join()	0	4	1
A	add()	0	7	1
B	groupBy()	7	31	6
A	sort()	0	7	1

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 Sequence 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 Sequence, and based on these observations, apply Extract Interface, too.

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\{
    Exception\OutOfBoundException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptySequenceException
};

/**
 * A defined set of ordered elements
 */
class Sequence implements SequenceInterface
{
    private $values;
    private $size;

    public function __construct(...$values)
    {
        $this->values = $values;
        $this->size = count($values);
    }

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

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

    /**
     * {@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(): bool
    {
        return $this->key() !== null;
    }

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function get(int $index)
    {
        if ($index >= $this->size()) {
            throw new OutOfBoundException;
        }

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

    /**
     * {@inheritdoc}
     */
    public function diff(SequenceInterface $seq): SequenceInterface
    {
        return new self(
            ...array_diff(
                $this->values,
                $seq->toPrimitive()
            )
        );
    }

    /**
     * {@inheritdoc}
     */
    public function distinct(): SequenceInterface
    {
        return new self(...array_unique($this->values));
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): SequenceInterface
    {
        return new self(...array_slice($this->values, $size));
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): SequenceInterface
    {
        return new self(...array_slice($this->values, 0, $this->size() - $size));
    }

    /**
     * {@inheritdoc}
     */
    public function equals(SequenceInterface $seq): bool
    {
        return $this->values === $seq->toPrimitive();
    }

    /**
     * {@inheritdoc}
     */
    public function filter(\Closure $predicate): SequenceInterface
    {
        return new self(...array_filter(
            $this->values,
            $predicate
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(\Closure $function): SequenceInterface
    {
        foreach ($this->values as $value) {
            $function($value);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(\Closure $discriminator): MapInterface
    {
        if ($this->size() === 0) {
            throw new GroupEmptySequenceException;
        }

        $map = null;

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

            if ($map === null) {

                $type = gettype($key);
                $map = new Map(
                    $type === 'object' ? get_class($key) : $type,
                    SequenceInterface::class
                );
            }

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

        return $map;
    }

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

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

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

    /**
     * {@inheritdoc}
     */
    public function indexOf($element): int
    {
        $index = array_search($element, $this->values, true);

        if ($index === false) {
            throw new ElementNotFoundException;
        }

        return $index;
    }

    /**
     * {@inheritdoc}
     */
    public function indices(): SequenceInterface
    {
        return new self(...array_keys($this->values));
    }

    /**
     * {@inheritdoc}
     */
    public function map(\Closure $function): SequenceInterface
    {
        return new self(...array_map($function, $this->values));
    }

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

    /**
     * {@inheritdoc}
     */
    public function partition(\Closure $predicate): SequenceInterface
    {
        $truthy = [];
        $falsy = [];

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

        return new self(
            new self(...$truthy),
            new self(...$falsy)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function slice(int $from, int $until): SequenceInterface
    {
        return new self(...array_slice(
            $this->values,
            $from,
            $until - $from
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function splitAt(int $index): SequenceInterface
    {
        return new self(
            $this->slice(0, $index),
            $this->slice($index, $this->size())
        );
    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): SequenceInterface
    {
        return $this->slice(0, $size);
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): SequenceInterface
    {
        return $this->slice($this->size() - $size, $this->size());
    }

    /**
     * {@inheritdoc}
     */
    public function append(SequenceInterface $seq): SequenceInterface
    {
        return new self(...$this->values, ...$seq->toPrimitive());
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(SequenceInterface $seq): SequenceInterface
    {
        return new self(...array_intersect($this->values, $seq->toPrimitive()));
    }

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

    /**
     * {@inheritdoc}
     */
    public function add($element): SequenceInterface
    {
        $values = $this->values;
        $values[] = $element;

        return new self(...$values);
    }

    /**
     * {@inheritdoc}
     */
    public function sort(\Closure $function): SequenceInterface
    {
        $values = $this->values;
        usort($values, $function);

        return new self(...$values);
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace Innmind\Immutable;
5
6			use Innmind\Immutable\{
7			Exception\OutOfBoundException,
8			Exception\LogicException,
9			Exception\ElementNotFoundException,
10			Exception\GroupEmptySequenceException
11			};
12
13			/**
14			* A defined set of ordered elements
15			*/
16			class Sequence implements SequenceInterface
17			{
18			private $values;
19			private $size;
20
21	88		public function __construct(...$values)
22			{
23	88		$this->values = $values;
24	88		$this->size = count($values);
25	88		}
26
27			/**
28			* {@inheritdoc}
29			*/
30	30		public function size(): int
31			{
32	30		return $this->size;
33			}
34
35			/**
36			* {@inheritdoc}
37			*/
38	1		public function count(): int
39			{
40	1		return $this->size();
41			}
42
43			/**
44			* {@inheritdoc}
45			*/
46	8		public function current()
47			{
48	8		return current($this->values);
49			}
50
51			/**
52			* {@inheritdoc}
53			*/
54	10		public function key()
55			{
56	10		return key($this->values);
57			}
58
59			/**
60			* {@inheritdoc}
61			*/
62	10		public function next()
63			{
64	10		next($this->values);
65	10		}
66
67			/**
68			* {@inheritdoc}
69			*/
70	8		public function rewind()
71			{
72	8		reset($this->values);
73	8		}
74
75			/**
76			* {@inheritdoc}
77			*/
78	8		public function valid(): bool
79			{
80	8		return $this->key() !== null;
81			}
82
83			/**
84			* {@inheritdoc}
85			*/
86	1		public function offsetExists($offset): bool
87			{
88	1		return array_key_exists($offset, $this->values);
89			}
90
91			/**
92			* {@inheritdoc}
93			*/
94	1		public function offsetGet($offset)
95			{
96	1		if (!$this->offsetExists($offset)) {
97			throw new OutOfBoundException(sprintf(
98			'Unknown index %s',
99			$offset
100			));
101			}
102
103	1		return $this->values[$offset];
104			}
105
106			/**
107			* {@inheritdoc}
108			*/
109	1		public function offsetSet($offset, $value)
110			{
111	1		throw new LogicException('You can\'t modify a sequence');
112			}
113
114			/**
115			* {@inheritdoc}
116			*/
117	1		public function offsetUnset($offset)
118			{
119	1		throw new LogicException('You can\'t modify a sequence');
120			}
121
122			/**
123			* {@inheritdoc}
124			*/
125	40		public function toPrimitive()
126			{
127	40		return $this->values;
128			}
129
130			/**
131			* {@inheritdoc}
132			*/
133	17		public function get(int $index)
134			{
135	17		if ($index >= $this->size()) {
136	1		throw new OutOfBoundException;
137			}
138
139	16		return $this->values[$index];
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145	2		public function diff(SequenceInterface $seq): SequenceInterface
146			{
147	2		return new self(
148	2		...array_diff(
149	2		$this->values,
150	2		$seq->toPrimitive()
151			)
152			);
153			}
154
155			/**
156			* {@inheritdoc}
157			*/
158	1		public function distinct(): SequenceInterface
159			{
160	1		return new self(...array_unique($this->values));
161			}
162
163			/**
164			* {@inheritdoc}
165			*/
166	7		public function drop(int $size): SequenceInterface
167			{
168	7		return new self(...array_slice($this->values, $size));
169			}
170
171			/**
172			* {@inheritdoc}
173			*/
174	2		public function dropEnd(int $size): SequenceInterface
175			{
176	2		return new self(...array_slice($this->values, 0, $this->size() - $size));
177			}
178
179			/**
180			* {@inheritdoc}
181			*/
182	6		public function equals(SequenceInterface $seq): bool
183			{
184	6		return $this->values === $seq->toPrimitive();
185			}
186
187			/**
188			* {@inheritdoc}
189			*/
190	2		public function filter(\Closure $predicate): SequenceInterface
191			{
192	2		return new self(...array_filter(
193	2		$this->values,
194			$predicate
195			));
196			}
197
198			/**
199			* {@inheritdoc}
200			*/
201	3		public function foreach(\Closure $function): SequenceInterface
202			{
203	3		foreach ($this->values as $value) {
204	3		$function($value);
205			}
206
207	3		return $this;
208			}
209
210			/**
211			* {@inheritdoc}
212			*/
213	3		public function groupBy(\Closure $discriminator): MapInterface
214			{
215	3		if ($this->size() === 0) {
216	1		throw new GroupEmptySequenceException;
217			}
218
219	2		$map = null;
220
221	2		foreach ($this->values as $value) {
222	2		$key = $discriminator($value);
223
224	2	View Code Duplication	if ($map === null) {
			0 ignored issues – show Duplication introduced 2016-02-29 07:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
225	2		$type = gettype($key);
226	2		$map = new Map(
227	2		$type === 'object' ? get_class($key) : $type,
228	2		SequenceInterface::class
229			);
230			}
231
232	2		if ($map->contains($key)) {
233	2		$map = $map->put(
234			$key,
235	2		$map->get($key)->add($value)
236			);
237			} else {
238	2		$map = $map->put($key, new self($value));
239			}
240			}
241
242	2		return $map;
243			}
244
245			/**
246			* {@inheritdoc}
247			*/
248	2		public function first()
249			{
250	2		return $this->values[0];
251			}
252
253			/**
254			* {@inheritdoc}
255			*/
256	2		public function last()
257			{
258	2		return $this->values[$this->size() - 1];
259			}
260
261			/**
262			* {@inheritdoc}
263			*/
264	42		public function contains($element): bool
265			{
266	42		return in_array($element, $this->values, true);
267			}
268
269			/**
270			* {@inheritdoc}
271			*/
272	13		public function indexOf($element): int
273			{
274	13		$index = array_search($element, $this->values, true);
275
276	13		if ($index === false) {
277	1		throw new ElementNotFoundException;
278			}
279
280	12		return $index;
281			}
282
283			/**
284			* {@inheritdoc}
285			*/
286	1		public function indices(): SequenceInterface
287			{
288	1		return new self(...array_keys($this->values));
289			}
290
291			/**
292			* {@inheritdoc}
293			*/
294	2		public function map(\Closure $function): SequenceInterface
295			{
296	2		return new self(...array_map($function, $this->values));
297			}
298
299			/**
300			* {@inheritdoc}
301			*/
302	1		public function pad(int $size, $element): SequenceInterface
303			{
304	1		return new self(...array_pad($this->values, $size, $element));
305			}
306
307			/**
308			* {@inheritdoc}
309			*/
310	2		public function partition(\Closure $predicate): SequenceInterface
311			{
312	2		$truthy = [];
313	2		$falsy = [];
314
315	2		foreach ($this->values as $value) {
316	2		if ($predicate($value) === true) {
317	2		$truthy[] = $value;
318			} else {
319	2		$falsy[] = $value;
320			}
321			}
322
323	2		return new self(
324	2		new self(...$truthy),
325	2		new self(...$falsy)
326			);
327			}
328
329			/**
330			* {@inheritdoc}
331			*/
332	13		public function slice(int $from, int $until): SequenceInterface
333			{
334	13		return new self(...array_slice(
335	13		$this->values,
336			$from,
337	13		$until - $from
338			));
339			}
340
341			/**
342			* {@inheritdoc}
343			*/
344	1		public function splitAt(int $index): SequenceInterface
345			{
346	1		return new self(
347	1		$this->slice(0, $index),
348	1		$this->slice($index, $this->size())
349			);
350			}
351
352			/**
353			* {@inheritdoc}
354			*/
355	7		public function take(int $size): SequenceInterface
356			{
357	7		return $this->slice(0, $size);
358			}
359
360			/**
361			* {@inheritdoc}
362			*/
363	2		public function takeEnd(int $size): SequenceInterface
364			{
365	2		return $this->slice($this->size() - $size, $this->size());
366			}
367
368			/**
369			* {@inheritdoc}
370			*/
371	8		public function append(SequenceInterface $seq): SequenceInterface
372			{
373	8		return new self(...$this->values, ...$seq->toPrimitive());
374			}
375
376			/**
377			* {@inheritdoc}
378			*/
379	2		public function intersect(SequenceInterface $seq): SequenceInterface
380			{
381	2		return new self(...array_intersect($this->values, $seq->toPrimitive()));
382			}
383
384			/**
385			* {@inheritdoc}
386			*/
387	3		public function join(string $separator): StringPrimitive
388			{
389	3		return new StringPrimitive(implode($separator, $this->values));
390			}
391
392			/**
393			* {@inheritdoc}
394			*/
395	40		public function add($element): SequenceInterface
396			{
397	40		$values = $this->values;
398	40		$values[] = $element;
399
400	40		return new self(...$values);
401			}
402
403			/**
404			* {@inheritdoc}
405			*/
406	2		public function sort(\Closure $function): SequenceInterface
407			{
408	2		$values = $this->values;
409	2		usort($values, $function);
410
411	2		return new self(...$values);
412			}
413			}
414

Innmind / Immutable

GitHub Access Token became invalid