StrictIterableTrait - Code Metrics - Inspection of "Added `reduce` method to ArrayList" - italolelis/collections - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

unknown

created 2016-05-10 15:37 UTC

StrictIterableTrait B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	257
Duplicated Lines	30.74 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

37.3%

Importance

Changes	7
Bugs	1	Features	3

Metric	Value
wmc	45
c	7
b	1
f	3
lcom	0
cbo	3
dl	79
loc	257
ccs	47
cts	126
cp	0.373
rs	8.3673

17 Methods

Rating	Name	Duplication	Size	Complexity
A	map()	0	9	2
A	last()	0	6	1
A	mapWithKey()	0	9	2
A	take()	0	17	4
A	skip()	0	13	3
A	skipWhile()	0	16	4
A	concat()	0	15	3
A	first()	0	8	2
A	each()	0	8	2
A	exists()	0	10	3
A	filter()	11	11	3
A	filterWithKey()	11	11	3
A	zip()	14	14	3
A	takeWhile()	12	12	3
B	slice()	19	19	5
A	concatAll()	12	12	1
A	reduce()	0	4	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 StrictIterableTrait 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 StrictIterableTrait, and based on these observations, apply Extract Interface, too.

<?php

namespace Collections\Traits;

use Collections\Iterable;
use Collections\VectorInterface;

trait StrictIterableTrait
{
    use CommonMutableContainerTrait;

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function map(callable $callable)
    {
        $res = new static();
        foreach ($this as $v) {

            $res[] = $callable($v);
        }

        return $res;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function mapWithKey($callback)
    {
        $res = new static();
        foreach ($this as $k => $v) {

            $res[$k] = $callback($k, $v);
        }

        return $res;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function filter(callable $callable)

    {
        $res = new static();
        foreach ($this as $v) {

            if ($callable($v)) {
                $res[] = $v;
            }
        }

        return $res;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function filterWithKey($callback)

    {
        $res = new static();
        foreach ($this as $k => $v) {

            if ($callback($k, $v)) {
                $res[$k] = $v;
            }
        }

        return $res;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function zip(Iterable $iterable)

    {
        $res = new static();
        $it = $iterable->getIterator();
        foreach ($this as $v) {

            if (!$it->valid()) {
                break;
            }
            $res[] = new Pair($v, $it->current());
            $it->next();
        }

        return $res;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function take($size = 1)
    {
        $res = new static();

        if ($size <= 0) {
            return $res;
        }

        foreach ($this as $v) {

            $res[] = $v;
            if (--$size === 0) {
                break;
            }
        }

        return $res;
    }

    public function takeWhile(callable $callable)

    {
        $res = new static();
        foreach ($this as $v) {

            if (!$callable($v)) {
                break;
            }
            $res[] = $v;
        }

        return $res;
    }

    public function skip($n)
    {
        $res = new static();
        foreach ($this as $v) {

            if ($n <= 0) {
                $res[] = $v;
            } else {
                --$n;
            }
        }

        return $res;
    }

    public function skipWhile(callable $callable)
    {
        $res = new static();
        $skip = true;
        foreach ($this as $v) {

            if ($skip) {
                if ($callable($v)) {
                    continue;
                }
                $skip = false;
            }
            $res[] = $v;
        }

        return $res;
    }

    public function slice($start, $length)

    {
        $res = new static();
        if ($length <= 0) {
            return $res;
        }
        foreach ($this as $v) {

            if ($start !== 0) {
                --$start;
                continue;
            }
            $res[] = $v;
            if (--$length === 0) {
                break;
            }
        }

        return $res;
    }

    public function concat(\Traversable $iterable)
    {
        $res = [];

        foreach ($this as $v) {

            $res[] = $v;
        }

        foreach ($iterable as $v) {
            $res[] = $v;
        }
        $this->container = $res;
class MyClass { }

$x = new MyClass();
$x->foo = true;

        return $this;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function first()
    {
        foreach ($this as $v) {

            return $v;
        }

        return null;
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function last()
    {
        $result = $this->toArray();

        return array_pop($result);
    }

    /**
     * {@inheritDoc}
     * @return $this
     */
    public function each(callable $callable)
    {
        foreach ($this as $v) {

            $callable($v);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function exists(callable $fn)
    {
        foreach ($this as $element) {

            if ($fn($element)) {
                return true;
            }
        }

        return false;
    }

    public function concatAll()

    {
        /** @var VectorInterface $results */
        $results = new static();
        $this->each(function (Iterable $subArray) use ($results) {
            $subArray->each(function ($item) use ($results) {
                $results->add($item);
            });
        });

        return $results;
    }

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


1			<?php
2
3			namespace Collections\Traits;
4
5			use Collections\Iterable;
6			use Collections\VectorInterface;
7
8			trait StrictIterableTrait
9			{
10			use CommonMutableContainerTrait;
11
12			/**
13			* {@inheritDoc}
14			* @return $this
15			*/
16	1		public function map(callable $callable)
17			{
18	1		$res = new static();
19	1		foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
20	1		$res[] = $callable($v);
21	1		}
22
23	1		return $res;
24			}
25
26			/**
27			* {@inheritDoc}
28			* @return $this
29			*/
30			public function mapWithKey($callback)
31			{
32			$res = new static();
33			foreach ($this as $k => $v) {
			0 ignored issues – show Bug introduced 2016-02-26 13:40 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
34			$res[$k] = $callback($k, $v);
35			}
36
37			return $res;
38			}
39
40			/**
41			* {@inheritDoc}
42			* @return $this
43			*/
44	4	View Code Duplication	public function filter(callable $callable)
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
45			{
46	2		$res = new static();
47	2		foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
48	2		if ($callable($v)) {
49	2		$res[] = $v;
50	2		}
51	2		}
52
53	4		return $res;
54			}
55
56			/**
57			* {@inheritDoc}
58			* @return $this
59			*/
60		View Code Duplication	public function filterWithKey($callback)
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
61			{
62			$res = new static();
63			foreach ($this as $k => $v) {
			0 ignored issues – show Bug introduced 2016-02-26 13:40 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
64			if ($callback($k, $v)) {
65			$res[$k] = $v;
66			}
67			}
68
69			return $res;
70			}
71
72			/**
73			* {@inheritDoc}
74			* @return $this
75			*/
76		View Code Duplication	public function zip(Iterable $iterable)
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
77			{
78			$res = new static();
79			$it = $iterable->getIterator();
80			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-11-22 18:48 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
81			if (!$it->valid()) {
82			break;
83			}
84			$res[] = new Pair($v, $it->current());
85			$it->next();
86			}
87
88			return $res;
89			}
90
91			/**
92			* {@inheritDoc}
93			* @return $this
94			*/
95	1		public function take($size = 1)
96			{
97	1		$res = new static();
98
99	1		if ($size <= 0) {
100			return $res;
101			}
102
103	1		foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
104	1		$res[] = $v;
105	1		if (--$size === 0) {
106	1		break;
107			}
108	1		}
109
110	1		return $res;
111			}
112
113		View Code Duplication	public function takeWhile(callable $callable)
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
114			{
115			$res = new static();
116			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
117			if (!$callable($v)) {
118			break;
119			}
120			$res[] = $v;
121			}
122
123			return $res;
124			}
125
126			public function skip($n)
127			{
128			$res = new static();
129			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
130			if ($n <= 0) {
131			$res[] = $v;
132			} else {
133			--$n;
134			}
135			}
136
137			return $res;
138			}
139
140			public function skipWhile(callable $callable)
141			{
142			$res = new static();
143			$skip = true;
144			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-11-22 16:24 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
145			if ($skip) {
146			if ($callable($v)) {
147			continue;
148			}
149			$skip = false;
150			}
151			$res[] = $v;
152			}
153
154			return $res;
155			}
156
157		View Code Duplication	public function slice($start, $length)
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
158			{
159			$res = new static();
160			if ($length <= 0) {
161			return $res;
162			}
163			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2016-02-26 13:40 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
164			if ($start !== 0) {
165			--$start;
166			continue;
167			}
168			$res[] = $v;
169			if (--$length === 0) {
170			break;
171			}
172			}
173
174			return $res;
175			}
176
177	1		public function concat(\Traversable $iterable)
178			{
179	1		$res = [];
180
181	1		foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
182	1		$res[] = $v;
183	1		}
184
185	1		foreach ($iterable as $v) {
186	1		$res[] = $v;
187	1		}
188	1		$this->container = $res;
			0 ignored issues – show Bug introduced 2015-11-22 16:24 UTC by Report Bug Copy Issue Report The property `container` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
189
190	1		return $this;
191			}
192
193			/**
194			* {@inheritDoc}
195			* @return $this
196			*/
197	2		public function first()
198			{
199	2		foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
200	1		return $v;
201	1		}
202
203	1		return null;
204			}
205
206			/**
207			* {@inheritDoc}
208			* @return $this
209			*/
210	2		public function last()
211			{
212	2		$result = $this->toArray();
213
214	2		return array_pop($result);
215			}
216
217			/**
218			* {@inheritDoc}
219			* @return $this
220			*/
221			public function each(callable $callable)
222			{
223			foreach ($this as $v) {
			0 ignored issues – show Bug introduced 2015-12-01 17:34 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
224			$callable($v);
225			}
226
227			return $this;
228			}
229
230			/**
231			* {@inheritdoc}
232			*/
233	1		public function exists(callable $fn)
234			{
235	1		foreach ($this as $element) {
			0 ignored issues – show Bug introduced 2015-11-22 16:24 UTC by Report Bug Copy Issue Report The expression `$this` of type `this<Collections\Traits\StrictIterableTrait>` is not traversable. Loading history...
236	1		if ($fn($element)) {
237	1		return true;
238			}
239	1		}
240
241	1		return false;
242			}
243
244		View Code Duplication	public function concatAll()
			0 ignored issues – show Duplication introduced 2016-05-08 11:10 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...
245			{
246			/** @var VectorInterface $results */
247			$results = new static();
248			$this->each(function (Iterable $subArray) use ($results) {
249			$subArray->each(function ($item) use ($results) {
250			$results->add($item);
251			});
252			});
253
254			return $results;
255			}
256
257			/**
258			* {@inheritdoc}
259			*/
260			public function reduce(callable $callback, $initial = null)
261			{
262			return array_reduce($this->toArray(), $callback, $initial);
263			}
264			}
265

italolelis / collections