Primitive::next() - Code Metrics - Inspection of "work around php casting a string key to int when v..." - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — develop (f633c7)

by Baptiste

created 2019-01-17 20:42 UTC

Primitive::next() A

↳ Parent: Primitive

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php
declare(strict_types = 1);

namespace Innmind\Immutable\Map;

use Innmind\Immutable\{
    MapInterface,
    Map,
    Type,
    Str,
    Stream,
    StreamInterface,
    SetInterface,
    Set,
    Pair,
    Exception\InvalidArgumentException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptyMapException
};

final class Primitive implements MapInterface
{
    private $keyType;
    private $valueType;
    private $keySpecification;
    private $valueSpecification;
    private $values;
    private $size;

    /**
     * {@inheritdoc}
     */
    public function __construct(string $keyType, string $valueType)
    {
        $this->keySpecification = Type::of($keyType);

        if (!in_array($keyType, ['int', 'integer', 'string'], true)) {
            throw new LogicException;
        }

        $this->valueSpecification = Type::of($valueType);
        $this->keyType = new Str($keyType);
        $this->valueType = new Str($valueType);
        $this->values = [];
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function put($key, $value): MapInterface
    {
        $this->keySpecification->validate($key);
        $this->valueSpecification->validate($value);

        $map = clone $this;
        $map->size = null;
        $map->values[$key] = $value;
        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        if (!$this->offsetExists($key)) {
            throw new ElementNotFoundException;
        }

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

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

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        $map = clone $this;
        $map->size = null;
        $map->values = [];

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function equals(MapInterface $map): bool
    {
        if ($map->size() !== $this->size()) {
            return false;
        }

        foreach ($this->values as $k => $v) {
            if (!$map->contains($k)) {
                return false;
            }

            if ($map->get($k) !== $v) {
                return false;
            }
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): MapInterface
    {
        $map = $this->clear();

        foreach ($this->values as $k => $v) {
            if ($predicate($this->normalizeKey($k), $v) === true) {
                $map->values[$k] = $v;
            }
        }

        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function foreach(callable $function): MapInterface
    {
        foreach ($this->values as $k => $v) {
            $function($this->normalizeKey($k), $v);
        }

        return $this;
    }

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

        $map = null;

        foreach ($this->values as $k => $v) {
            $key = $discriminator($this->normalizeKey($k), $v);

            if ($map === null) {
                $map = new Map(
                    Type::determine($key),
                    MapInterface::class
                );
            }

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->put($k, $v)
                );
            } else {
                $map = $map->put(
                    $key,
                    $this->clear()->put($k, $v)
                );
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function keys(): SetInterface
    {
        return Set::of(
            (string) $this->keyType,
            ...\array_map(function($key) {
                return $this->normalizeKey($key);
            }, \array_keys($this->values))
        );
    }

    /**
     * {@inheritdoc}
     */
    public function values(): StreamInterface
    {
        return Stream::of((string) $this->valueType, ...\array_values($this->values));
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): MapInterface
    {
        $map = $this->clear();

        foreach ($this->values as $k => $v) {
            $return = $function($this->normalizeKey($k), $v);

            if ($return instanceof Pair) {
                $this->keySpecification->validate($return->key());

                $key = $return->key();
                $value = $return->value();
            } else {
                $key = $k;
                $value = $return;
            }

            $this->valueSpecification->validate($value);

            $map->values[$key] = $value;
        }

        $map->rewind();

        return $map;
    }

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

    /**
     * {@inheritdoc}
     */
    public function remove($key): MapInterface
    {
        if (!$this->contains($key)) {
            return $this;
        }

        $map = clone $this;
        $map->size = null;
        unset($map->values[$key]);
        $map->rewind();

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MapInterface $map): MapInterface
    {
        if (
            !$this->keyType()->equals($map->keyType()) ||
            !$this->valueType()->equals($map->valueType())
        ) {
            throw new InvalidArgumentException(
                'The 2 maps does not reference the same types'
            );
        }

        return $map->reduce(
            $this,
            function(self $carry, $key, $value): self {
                return $carry->put($key, $value);
            }
        );
    }

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

        foreach ($this->values as $k => $v) {
            $return = $predicate($this->normalizeKey($k), $v);

            if ($return === true) {
                $truthy->values[$k] = $v;
            } else {
                $falsy->values[$k] = $v;
            }
        }

        $truthy->rewind();
        $falsy->rewind();

        return Map::of('bool', MapInterface::class)
            (true, $truthy)
            (false, $falsy);
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        foreach ($this->values as $k => $v) {
            $carry = $reducer($carry, $this->normalizeKey($k), $v);
        }

        return $carry;
    }

    public function empty(): bool
    {
        $this->rewind();

        return !$this->valid();
    }

    private function normalizeKey($value)
    {
        if ((string) $this->keyType === 'string') {
            return (string) $value;
        }

        return $value;
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Immutable\Map;
5
6		use Innmind\Immutable\{
7		MapInterface,
8		Map,
9		Type,
10		Str,
11		Stream,
12		StreamInterface,
13		SetInterface,
14		Set,
15		Pair,
16		Exception\InvalidArgumentException,
17		Exception\LogicException,
18		Exception\ElementNotFoundException,
19		Exception\GroupEmptyMapException
20		};
21
22		final class Primitive implements MapInterface
23		{
24		private $keyType;
25		private $valueType;
26		private $keySpecification;
27		private $valueSpecification;
28		private $values;
29		private $size;
30
31		/**
32		* {@inheritdoc}
33		*/
34	144	public function __construct(string $keyType, string $valueType)
35		{
36	144	$this->keySpecification = Type::of($keyType);
37
38	144	if (!in_array($keyType, ['int', 'integer', 'string'], true)) {
39	2	throw new LogicException;
40		}
41
42	142	$this->valueSpecification = Type::of($valueType);
43	142	$this->keyType = new Str($keyType);
44	142	$this->valueType = new Str($valueType);
45	142	$this->values = [];
46	142	}
47
48		/**
49		* {@inheritdoc}
50		*/
51	46	public function keyType(): Str
52		{
53	46	return $this->keyType;
54		}
55
56		/**
57		* {@inheritdoc}
58		*/
59	40	public function valueType(): Str
60		{
61	40	return $this->valueType;
62		}
63
64		/**
65		* {@inheritdoc}
66		*/
67	38	public function size(): int
68		{
69	38	return $this->size ?? $this->size = \count($this->values);
70		}
71
72		/**
73		* {@inheritdoc}
74		*/
75	2	public function count(): int
76		{
77	2	return $this->size();
78		}
79
80		/**
81		* {@inheritdoc}
82		*/
83	4	public function current()
84		{
85	4	return \current($this->values);
86		}
87
88		/**
89		* {@inheritdoc}
90		*/
91	8	public function key()
92		{
93	8	return $this->normalizeKey(\key($this->values));
94		}
95
96		/**
97		* {@inheritdoc}
98		*/
99	4	public function next()
100		{
101	4	\next($this->values);
102	4	}
103
104		/**
105		* {@inheritdoc}
106		*/
107	100	public function rewind()
108		{
109	100	\reset($this->values);
110	100	}
111
112		/**
113		* {@inheritdoc}
114		*/
115	6	public function valid()
116		{
117	6	return $this->key() !== null;
118		}
119
120		/**
121		* {@inheritdoc}
122		*/
123	58	public function offsetExists($offset): bool
124		{
125	58	return \array_key_exists($offset, $this->values);
126		}
127
128		/**
129		* {@inheritdoc}
130		*/
131	8	public function offsetGet($offset)
132		{
133	8	return $this->get($offset);
134		}
135
136		/**
137		* {@inheritdoc}
138		*/
139	2	public function offsetSet($offset, $value)
140		{
141	2	throw new LogicException('You can\'t modify a map');
142		}
143
144		/**
145		* {@inheritdoc}
146		*/
147	2	public function offsetUnset($offset)
148		{
149	2	throw new LogicException('You can\'t modify a map');
150		}
151
152		/**
153		* {@inheritdoc}
154		*/
155	112	public function put($key, $value): MapInterface
156		{
157	112	$this->keySpecification->validate($key);
158	108	$this->valueSpecification->validate($value);
159
160	100	$map = clone $this;
161	100	$map->size = null;
162	100	$map->values[$key] = $value;
163	100	$map->rewind();
164
165	100	return $map;
166		}
167
168		/**
169		* {@inheritdoc}
170		*/
171	48	public function get($key)
172		{
173	48	if (!$this->offsetExists($key)) {
174	8	throw new ElementNotFoundException;
175		}
176
177	40	return $this->values[$key];
178		}
179
180		/**
181		* {@inheritdoc}
182		*/
183	38	public function contains($key): bool
184		{
185	38	return $this->offsetExists($key);
186		}
187
188		/**
189		* {@inheritdoc}
190		*/
191	28	public function clear(): MapInterface
192		{
193	28	$map = clone $this;
194	28	$map->size = null;
195	28	$map->values = [];
196
197	28	return $map;
198		}
199
200		/**
201		* {@inheritdoc}
202		*/
203	14	public function equals(MapInterface $map): bool
204		{
205	14	if ($map->size() !== $this->size()) {
206	4	return false;
207		}
208
209	14	foreach ($this->values as $k => $v) {
210	12	if (!$map->contains($k)) {
211	4	return false;
212		}
213
214	12	if ($map->get($k) !== $v) {
215	9	return false;
216		}
217		}
218
219	12	return true;
220		}
221
222		/**
223		* {@inheritdoc}
224		*/
225	4	public function filter(callable $predicate): MapInterface
226		{
227	4	$map = $this->clear();
228
229	4	foreach ($this->values as $k => $v) {
230	4	if ($predicate($this->normalizeKey($k), $v) === true) {
231	4	$map->values[$k] = $v;
232		}
233		}
234
235	4	$map->rewind();
236
237	4	return $map;
238		}
239
240		/**
241		* {@inheritdoc}
242		*/
243	4	public function foreach(callable $function): MapInterface
244		{
245	4	foreach ($this->values as $k => $v) {
246	4	$function($this->normalizeKey($k), $v);
247		}
248
249	4	return $this;
250		}
251
252		/**
253		* {@inheritdoc}
254		*/
255	8	public function groupBy(callable $discriminator): MapInterface
256		{
257	8	if ($this->size() === 0) {
258	4	throw new GroupEmptyMapException;
259		}
260
261	4	$map = null;
262
263	4	foreach ($this->values as $k => $v) {
264	4	$key = $discriminator($this->normalizeKey($k), $v);
265
266	4	if ($map === null) {
267	4	$map = new Map(
268	4	Type::determine($key),
269	4	MapInterface::class
270		);
271		}
272
273	4	if ($map->contains($key)) {
274	4	$map = $map->put(
275	4	$key,
276	4	$map->get($key)->put($k, $v)
277		);
278		} else {
279	4	$map = $map->put(
280	4	$key,
281	4	$this->clear()->put($k, $v)
282		);
283		}
284		}
285
286	4	return $map;
287		}
288
289		/**
290		* {@inheritdoc}
291		*/
292	28	public function keys(): SetInterface
293		{
294	28	return Set::of(
295	28	(string) $this->keyType,
296	28	...\array_map(function($key) {
297	28	return $this->normalizeKey($key);
298	28	}, \array_keys($this->values))
299		);
300		}
301
302		/**
303		* {@inheritdoc}
304		*/
305	26	public function values(): StreamInterface
306		{
307	26	return Stream::of((string) $this->valueType, ...\array_values($this->values));
308		}
309
310		/**
311		* {@inheritdoc}
312		*/
313	12	public function map(callable $function): MapInterface
314		{
315	12	$map = $this->clear();
316
317	12	foreach ($this->values as $k => $v) {
318	12	$return = $function($this->normalizeKey($k), $v);
319
320	12	if ($return instanceof Pair) {
321	8	$this->keySpecification->validate($return->key());
322
323	4	$key = $return->key();
324	4	$value = $return->value();
325		} else {
326	8	$key = $k;
327	8	$value = $return;
328		}
329
330	8	$this->valueSpecification->validate($value);
331
332	4	$map->values[$key] = $value;
333		}
334
335	4	$map->rewind();
336
337	4	return $map;
338		}
339
340		/**
341		* {@inheritdoc}
342		*/
343	4	public function join(string $separator): Str
344		{
345	4	return $this->values()->join($separator);
346		}
347
348		/**
349		* {@inheritdoc}
350		*/
351	4	public function remove($key): MapInterface
352		{
353	4	if (!$this->contains($key)) {
354	4	return $this;
355		}
356
357	4	$map = clone $this;
358	4	$map->size = null;
359	4	unset($map->values[$key]);
360	4	$map->rewind();
361
362	4	return $map;
363		}
364
365		/**
366		* {@inheritdoc}
367		*/
368	6	public function merge(MapInterface $map): MapInterface
369		{
370		if (
371	6	!$this->keyType()->equals($map->keyType()) \|\|
372	6	!$this->valueType()->equals($map->valueType())
373		) {
374	4	throw new InvalidArgumentException(
375	4	'The 2 maps does not reference the same types'
376		);
377		}
378
379	2	return $map->reduce(
380	2	$this,
381	2	function(self $carry, $key, $value): self {
382	2	return $carry->put($key, $value);
383	2	}
384		);
385		}
386
387		/**
388		* {@inheritdoc}
389		*/
390	4	public function partition(callable $predicate): MapInterface
391		{
392	4	$truthy = $this->clear();
393	4	$falsy = $this->clear();
394
395	4	foreach ($this->values as $k => $v) {
396	4	$return = $predicate($this->normalizeKey($k), $v);
397
398	4	if ($return === true) {
399	4	$truthy->values[$k] = $v;
400		} else {
401	4	$falsy->values[$k] = $v;
402		}
403		}
404
405	4	$truthy->rewind();
406	4	$falsy->rewind();
407
408	4	return Map::of('bool', MapInterface::class)
409	4	(true, $truthy)
410	4	(false, $falsy);
411		}
412
413		/**
414		* {@inheritdoc}
415		*/
416	8	public function reduce($carry, callable $reducer)
417		{
418	8	foreach ($this->values as $k => $v) {
419	8	$carry = $reducer($carry, $this->normalizeKey($k), $v);
420		}
421
422	8	return $carry;
423		}
424
425	2	public function empty(): bool
426		{
427	2	$this->rewind();
428
429	2	return !$this->valid();
430		}
431
432	54	private function normalizeKey($value)
433		{
434	54	if ((string) $this->keyType === 'string') {
435	2	return (string) $value;
436		}
437
438	52	return $value;
439		}
440		}
441

Innmind / Immutable

GitHub Access Token became invalid

Branch — develop (f633c7)

Primitive::next() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like