Stream - Code Metrics - Inspection of "add named constructors to ease chaining" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 5fe34b...11f42d )

by Baptiste

created 2017-11-23 17:25 UTC

Stream B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	506
Duplicated Lines	14.43 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	52
lcom	1
cbo	9
dl	73
loc	506
ccs	181
cts	181
cp	1
rs	7.9487
c	0
b	0
f	0

45 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	of()	0	10	1
A	type()	0	4	1
A	size()	0	4	1
A	count()	0	4	1
A	toPrimitive()	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	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	get()	0	4	1
A	diff()	0	11	1
A	distinct()	0	7	1
A	drop()	0	7	1
A	dropEnd()	0	7	1
A	equals()	0	8	1
A	filter()	0	7	1
A	foreach()	0	6	1
B	groupBy()	33	33	5
A	first()	0	4	1
A	last()	0	4	1
A	contains()	0	4	1
A	indexOf()	0	4	1
A	indices()	0	7	1
A	map()	0	11	1
A	pad()	9	9	1
A	partition()	0	17	3
A	slice()	0	7	1
A	splitAt()	0	11	1
A	take()	0	7	1
A	takeEnd()	0	7	1
A	append()	11	11	1
A	intersect()	11	11	1
A	join()	0	4	1
A	add()	9	9	1
A	sort()	0	7	1
A	reduce()	0	4	1
A	clear()	0	7	1
A	reverse()	0	7	1
A	validate()	0	8	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 Stream 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 Stream, and based on these observations, apply Extract Interface, too.

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\{
    LogicException,
    GroupEmptySequenceException,
    InvalidArgumentException
};

/**
 * {@inheritdoc}
 */
class Stream implements StreamInterface
{
    use Type;

    private $type;
    private $spec;
    private $values;

    public function __construct(string $type)
    {
        $this->type = new Str($type);
        $this->spec = $this->getSpecificationFor($type);
        $this->values = new Sequence;
    }

    public static function of(string $type, ...$values): self
    {
        return array_reduce(
            $values,
            static function(self $self, $value): self {
                return $self->add($value);
            },
            new self($type)
        );
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function diff(StreamInterface $stream): StreamInterface
    {
        $this->validate($stream);

        $newStream = clone $this;
        $newStream->values = $this->values->diff(
            new Sequence(...$stream)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        return $newStream;
    }

    /**
     * {@inheritdoc}
     */
    public function distinct(): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->distinct();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function drop(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->drop($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function dropEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->dropEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(StreamInterface $stream): bool
    {
        $this->validate($stream);

        return $this->values->equals(
            new Sequence(...$stream)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->filter($predicate);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): StreamInterface
    {
        $this->values->foreach($function);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function groupBy(callable $discriminator): MapInterface

    {
        if ($this->size() === 0) {
            throw new GroupEmptySequenceException;
        }

        $map = null;

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

            if ($map === null) {
                $map = new Map(
                    $this->determineType($key),
                    StreamInterface::class
                );
            }

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

        return $map;
    }

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function indices(): StreamInterface
    {
        $stream = new self('int');
        $stream->values = $this->values->indices();

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): StreamInterface
    {
        return $this
            ->values
            ->reduce(
                new self((string) $this->type),
                function(self $carry, $element) use($function): StreamInterface {
                    return $carry->add($function($element));
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function pad(int $size, $element): StreamInterface

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->pad($size, $element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = new self((string) $this->type);
        $falsy = new self((string) $this->type);

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

        return (new Map('bool', StreamInterface::class))
            ->put(true, $truthy)
            ->put(false, $falsy);
    }

    /**
     * {@inheritdoc}
     */
    public function slice(int $from, int $until): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->slice($from, $until);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function splitAt(int $position): StreamInterface
    {
        $stream = new self(StreamInterface::class);
        $splitted = $this->values->splitAt($position);
        $first = new self((string) $this->type);
        $second = new self((string) $this->type);
        $first->values = $splitted->first();
        $second->values = $splitted->last();

        return $stream->add($first)->add($second);
    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->take($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function takeEnd(int $size): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->takeEnd($size);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function append(StreamInterface $stream): StreamInterface

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->append(
            new Sequence(...$stream)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function intersect(StreamInterface $stream): StreamInterface

    {
        $this->validate($stream);

        $self = clone $this;
        $self->values = $this->values->intersect(
            new Sequence(...$stream)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        );

        return $self;
    }

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

    /**
     * {@inheritdoc}
     */
    public function add($element): StreamInterface

    {
        $this->spec->validate($element);

        $stream = clone $this;
        $stream->values = $this->values->add($element);

        return $stream;
    }

    /**
     * {@inheritdoc}
     */
    public function sort(callable $function): StreamInterface
    {
        $stream = clone $this;
        $stream->values = $this->values->sort($function);

        return $stream;
    }

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

    /**
     * {@inheritdoc}
     */
    public function clear(): StreamInterface
    {
        $self = clone $this;
        $self->values = new Sequence;

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function reverse(): StreamInterface
    {
        $self = clone $this;
        $self->values = $this->values->reverse();

        return $self;
    }

    /**
     * Make sure the stream is compatible with the current one
     *
     * @param StreamInterface $stream
     *
     * @throws InvalidArgumentException
     *
     * @return void
     */
    private function validate(StreamInterface $stream)
    {
        if (!$stream->type()->equals($this->type)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            throw new InvalidArgumentException(
                'The 2 streams does not reference the same type'
            );
        }
    }
}


1			<?php
2			declare(strict_types = 1);
3
4			namespace Innmind\Immutable;
5
6			use Innmind\Immutable\Exception\{
7			LogicException,
8			GroupEmptySequenceException,
9			InvalidArgumentException
10			};
11
12			/**
13			* {@inheritdoc}
14			*/
15			class Stream implements StreamInterface
16			{
17			use Type;
18
19			private $type;
20			private $spec;
21			private $values;
22
23	375		public function __construct(string $type)
24			{
25	375		$this->type = new Str($type);
26	375		$this->spec = $this->getSpecificationFor($type);
27	375		$this->values = new Sequence;
28	375		}
29
30	3		public static function of(string $type, ...$values): self
31			{
32	3		return array_reduce(
33	3		$values,
34	3		static function(self $self, $value): self {
35	3		return $self->add($value);
36	3		},
37	3		new self($type)
38			);
39			}
40
41			/**
42			* {@inheritdoc}
43			*/
44	141		public function type(): Str
45			{
46	141		return $this->type;
47			}
48
49			/**
50			* {@inheritdoc}
51			*/
52	48		public function size(): int
53			{
54	48		return $this->values->size();
55			}
56
57			/**
58			* {@inheritdoc}
59			*/
60	18		public function count(): int
61			{
62	18		return $this->values->size();
63			}
64
65			/**
66			* {@inheritdoc}
67			*/
68	135		public function toPrimitive()
69			{
70	135		return $this->values->toPrimitive();
71			}
72
73			/**
74			* {@inheritdoc}
75			*/
76	102		public function current()
77			{
78	102		return $this->values->current();
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84	72		public function key()
85			{
86	72		return $this->values->key();
87			}
88
89			/**
90			* {@inheritdoc}
91			*/
92	96		public function next()
93			{
94	96		$this->values->next();
95	96		}
96
97			/**
98			* {@inheritdoc}
99			*/
100	102		public function rewind()
101			{
102	102		$this->values->rewind();
103	102		}
104
105			/**
106			* {@inheritdoc}
107			*/
108	102		public function valid()
109			{
110	102		return $this->values->valid();
111			}
112
113			/**
114			* {@inheritdoc}
115			*/
116	3		public function offsetExists($offset): bool
117			{
118	3		return $this->values->offsetExists($offset);
119			}
120
121			/**
122			* {@inheritdoc}
123			*/
124	27		public function offsetGet($offset)
125			{
126	27		return $this->get($offset);
127			}
128
129			/**
130			* {@inheritdoc}
131			*/
132	3		public function offsetSet($offset, $value)
133			{
134	3		throw new LogicException('You can\'t modify a stream');
135			}
136
137			/**
138			* {@inheritdoc}
139			*/
140	3		public function offsetUnset($offset)
141			{
142	3		throw new LogicException('You can\'t modify a stream');
143			}
144
145			/**
146			* {@inheritdoc}
147			*/
148	78		public function get(int $index)
149			{
150	78		return $this->values->get($index);
151			}
152
153			/**
154			* {@inheritdoc}
155			*/
156	6		public function diff(StreamInterface $stream): StreamInterface
157			{
158	6		$this->validate($stream);
159
160	6		$newStream = clone $this;
161	6		$newStream->values = $this->values->diff(
162	6		new Sequence(...$stream)
			0 ignored issues – show Documentation introduced 2017-02-12 11:09 UTC by Report Bug Copy Issue Report `new \Innmind\Immutable\Sequence(...$stream)` is of type `object<Innmind\Immutable\Sequence>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
163			);
164
165	6		return $newStream;
166			}
167
168			/**
169			* {@inheritdoc}
170			*/
171	3		public function distinct(): StreamInterface
172			{
173	3		$stream = clone $this;
174	3		$stream->values = $this->values->distinct();
175
176	3		return $stream;
177			}
178
179			/**
180			* {@inheritdoc}
181			*/
182	24		public function drop(int $size): StreamInterface
183			{
184	24		$stream = clone $this;
185	24		$stream->values = $this->values->drop($size);
186
187	24		return $stream;
188			}
189
190			/**
191			* {@inheritdoc}
192			*/
193	3		public function dropEnd(int $size): StreamInterface
194			{
195	3		$stream = clone $this;
196	3		$stream->values = $this->values->dropEnd($size);
197
198	3		return $stream;
199			}
200
201			/**
202			* {@inheritdoc}
203			*/
204	33		public function equals(StreamInterface $stream): bool
205			{
206	33		$this->validate($stream);
207
208	30		return $this->values->equals(
209	30		new Sequence(...$stream)
			0 ignored issues – show Documentation introduced 2017-02-12 11:09 UTC by Report Bug Copy Issue Report `new \Innmind\Immutable\Sequence(...$stream)` is of type `object<Innmind\Immutable\Sequence>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
210			);
211			}
212
213			/**
214			* {@inheritdoc}
215			*/
216	6		public function filter(callable $predicate): StreamInterface
217			{
218	6		$stream = clone $this;
219	6		$stream->values = $this->values->filter($predicate);
220
221	6		return $stream;
222			}
223
224			/**
225			* {@inheritdoc}
226			*/
227	6		public function foreach(callable $function): StreamInterface
228			{
229	6		$this->values->foreach($function);
230
231	6		return $this;
232			}
233
234			/**
235			* {@inheritdoc}
236			*/
237	9	View Code Duplication	public function groupBy(callable $discriminator): MapInterface
			0 ignored issues – show Duplication introduced 2017-08-06 15:25 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...
238			{
239	9		if ($this->size() === 0) {
240	3		throw new GroupEmptySequenceException;
241			}
242
243	6		$map = null;
244
245	6		foreach ($this->values as $value) {
246	6		$key = $discriminator($value);
247
248	6		if ($map === null) {
249	6		$map = new Map(
250	6		$this->determineType($key),
251	6		StreamInterface::class
252			);
253			}
254
255	6		if ($map->contains($key)) {
256	6		$map = $map->put(
257	6		$key,
258	6		$map->get($key)->add($value)
259			);
260			} else {
261	6		$map = $map->put(
262	6		$key,
263	6		(new self((string) $this->type))->add($value)
264			);
265			}
266			}
267
268	6		return $map;
269			}
270
271			/**
272			* {@inheritdoc}
273			*/
274	6		public function first()
275			{
276	6		return $this->values->first();
277			}
278
279			/**
280			* {@inheritdoc}
281			*/
282	6		public function last()
283			{
284	6		return $this->values->last();
285			}
286
287			/**
288			* {@inheritdoc}
289			*/
290	153		public function contains($element): bool
291			{
292	153		return $this->values->contains($element);
293			}
294
295			/**
296			* {@inheritdoc}
297			*/
298	57		public function indexOf($element): int
299			{
300	57		return $this->values->indexOf($element);
301			}
302
303			/**
304			* {@inheritdoc}
305			*/
306	3		public function indices(): StreamInterface
307			{
308	3		$stream = new self('int');
309	3		$stream->values = $this->values->indices();
310
311	3		return $stream;
312			}
313
314			/**
315			* {@inheritdoc}
316			*/
317	9		public function map(callable $function): StreamInterface
318			{
319			return $this
320	9		->values
321	9		->reduce(
322	9		new self((string) $this->type),
323	9		function(self $carry, $element) use($function): StreamInterface {
324	9		return $carry->add($function($element));
325	9		}
326			);
327			}
328
329			/**
330			* {@inheritdoc}
331			*/
332	6	View Code Duplication	public function pad(int $size, $element): StreamInterface
			0 ignored issues – show Duplication introduced 2017-08-06 15:25 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...
333			{
334	6		$this->spec->validate($element);
335
336	3		$stream = clone $this;
337	3		$stream->values = $this->values->pad($size, $element);
338
339	3		return $stream;
340			}
341
342			/**
343			* {@inheritdoc}
344			*/
345	6		public function partition(callable $predicate): MapInterface
346			{
347	6		$truthy = new self((string) $this->type);
348	6		$falsy = new self((string) $this->type);
349
350	6		foreach ($this->values as $value) {
351	6		if ($predicate($value) === true) {
352	6		$truthy = $truthy->add($value);
353			} else {
354	6		$falsy = $falsy->add($value);
355			}
356			}
357
358	6		return (new Map('bool', StreamInterface::class))
359	6		->put(true, $truthy)
360	6		->put(false, $falsy);
361			}
362
363			/**
364			* {@inheritdoc}
365			*/
366	9		public function slice(int $from, int $until): StreamInterface
367			{
368	9		$stream = clone $this;
369	9		$stream->values = $this->values->slice($from, $until);
370
371	9		return $stream;
372			}
373
374			/**
375			* {@inheritdoc}
376			*/
377	3		public function splitAt(int $position): StreamInterface
378			{
379	3		$stream = new self(StreamInterface::class);
380	3		$splitted = $this->values->splitAt($position);
381	3		$first = new self((string) $this->type);
382	3		$second = new self((string) $this->type);
383	3		$first->values = $splitted->first();
384	3		$second->values = $splitted->last();
385
386	3		return $stream->add($first)->add($second);
387			}
388
389			/**
390			* {@inheritdoc}
391			*/
392	24		public function take(int $size): StreamInterface
393			{
394	24		$stream = clone $this;
395	24		$stream->values = $this->values->take($size);
396
397	24		return $stream;
398			}
399
400			/**
401			* {@inheritdoc}
402			*/
403	3		public function takeEnd(int $size): StreamInterface
404			{
405	3		$stream = clone $this;
406	3		$stream->values = $this->values->takeEnd($size);
407
408	3		return $stream;
409			}
410
411			/**
412			* {@inheritdoc}
413			*/
414	33	View Code Duplication	public function append(StreamInterface $stream): StreamInterface
			0 ignored issues – show Duplication introduced 2017-08-06 15:25 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...
415			{
416	33		$this->validate($stream);
417
418	30		$self = clone $this;
419	30		$self->values = $this->values->append(
420	30		new Sequence(...$stream)
			0 ignored issues – show Documentation introduced 2017-02-12 11:09 UTC by Report Bug Copy Issue Report `new \Innmind\Immutable\Sequence(...$stream)` is of type `object<Innmind\Immutable\Sequence>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
421			);
422
423	30		return $self;
424			}
425
426			/**
427			* {@inheritdoc}
428			*/
429	9	View Code Duplication	public function intersect(StreamInterface $stream): StreamInterface
			0 ignored issues – show Duplication introduced 2017-08-06 15:25 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...
430			{
431	9		$this->validate($stream);
432
433	6		$self = clone $this;
434	6		$self->values = $this->values->intersect(
435	6		new Sequence(...$stream)
			0 ignored issues – show Documentation introduced 2017-02-12 11:09 UTC by Report Bug Copy Issue Report `new \Innmind\Immutable\Sequence(...$stream)` is of type `object<Innmind\Immutable\Sequence>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
436			);
437
438	6		return $self;
439			}
440
441			/**
442			* {@inheritdoc}
443			*/
444	21		public function join(string $separator): Str
445			{
446	21		return new Str((string) $this->values->join($separator));
447			}
448
449			/**
450			* {@inheritdoc}
451			*/
452	297	View Code Duplication	public function add($element): StreamInterface
			0 ignored issues – show Duplication introduced 2017-08-06 15:25 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...
453			{
454	297		$this->spec->validate($element);
455
456	294		$stream = clone $this;
457	294		$stream->values = $this->values->add($element);
458
459	294		return $stream;
460			}
461
462			/**
463			* {@inheritdoc}
464			*/
465	6		public function sort(callable $function): StreamInterface
466			{
467	6		$stream = clone $this;
468	6		$stream->values = $this->values->sort($function);
469
470	6		return $stream;
471			}
472
473			/**
474			* {@inheritdoc}
475			*/
476	60		public function reduce($carry, callable $reducer)
477			{
478	60		return $this->values->reduce($carry, $reducer);
479			}
480
481			/**
482			* {@inheritdoc}
483			*/
484	45		public function clear(): StreamInterface
485			{
486	45		$self = clone $this;
487	45		$self->values = new Sequence;
488
489	45		return $self;
490			}
491
492			/**
493			* {@inheritdoc}
494			*/
495	6		public function reverse(): StreamInterface
496			{
497	6		$self = clone $this;
498	6		$self->values = $this->values->reverse();
499
500	6		return $self;
501			}
502
503			/**
504			* Make sure the stream is compatible with the current one
505			*
506			* @param StreamInterface $stream
507			*
508			* @throws InvalidArgumentException
509			*
510			* @return void
511			*/
512	75		private function validate(StreamInterface $stream)
513			{
514	75		if (!$stream->type()->equals($this->type)) {
			0 ignored issues – show Documentation introduced 2017-02-04 17:24 UTC by Report Bug Copy Issue Report `$this->type` is of type `object<Innmind\Immutable\Str>`, but the function expects a `object<self>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
515	9		throw new InvalidArgumentException(
516	9		'The 2 streams does not reference the same type'
517			);
518			}
519	66		}
520			}
521

Innmind / Immutable

GitHub Access Token became invalid