Sequence::process() - Code Metrics - Innmind/Config - Measure and Improve Code Quality continuously with Scrutinizer

Sequence::process() D
last analyzed 2018-04-02 08:32 UTC

↳ Parent: Sequence

Complexity

Conditions	9
Paths	7

Size

Total Lines	29
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	9

Importance

Changes

Metric	Value
cc	9
eloc	14
nc	7
nop	1
dl	0
loc	29
ccs	15
cts	15
cp	1
crap	9
rs	4.909
c	0
b	0
f	0

<?php
declare(strict_types = 1);

namespace Innmind\Config\Property;

use Innmind\Config\{
    Property,
    Properties,
    Exception\SchemaNotParseable,
    Exception\InvalidArgumentException,
};
use Innmind\Immutable;

final class Sequence implements Property
{
    private const PATTERN = '~^sequence\+?$~';

    private $requiresValue = false;

    private function __construct(bool $requiresValue)
    {
        $this->requiresValue = $requiresValue;
    }

    public static function build(Immutable\Str $schema, Properties $properties): Property
    {
        if (!$schema->matches(self::PATTERN)) {
            throw new SchemaNotParseable((string) $schema);
        }

        return new self((string) $schema->substring(-1) === '+');
    }

    /**
     * {@inheritdoc}
     */
    public function process($value)
    {
        if (is_null($value)) {
            if ($this->requiresValue) {
                throw new InvalidArgumentException;
            }

            return new Immutable\Sequence;
        }

        if ($value instanceof Immutable\Sequence) {
            if ($this->requiresValue && $value->size() === 0) {
                throw new InvalidArgumentException;
            }

            return $value;
        }

        if (!is_array($value)) {
            throw new InvalidArgumentException;
        }

        $sequence = Immutable\Sequence::of(...$value);

        if ($this->requiresValue && $sequence->size() === 0) {
            throw new InvalidArgumentException;
        }

        return $sequence;
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Config\Property;
5
6		use Innmind\Config\{
7		Property,
8		Properties,
9		Exception\SchemaNotParseable,
10		Exception\InvalidArgumentException,
11		};
12		use Innmind\Immutable;
13
14		final class Sequence implements Property
15		{
16		private const PATTERN = '~^sequence\+?$~';
17
18		private $requiresValue = false;
19
20	14	private function __construct(bool $requiresValue)
21		{
22	14	$this->requiresValue = $requiresValue;
23	14	}
24
25	17	public static function build(Immutable\Str $schema, Properties $properties): Property
26		{
27	17	if (!$schema->matches(self::PATTERN)) {
28	3	throw new SchemaNotParseable((string) $schema);
29		}
30
31	14	return new self((string) $schema->substring(-1) === '+');
32		}
33
34		/**
35		* {@inheritdoc}
36		*/
37	11	public function process($value)
38		{
39	11	if (is_null($value)) {
40	2	if ($this->requiresValue) {
41	1	throw new InvalidArgumentException;
42		}
43
44	1	return new Immutable\Sequence;
45		}
46
47	9	if ($value instanceof Immutable\Sequence) {
48	4	if ($this->requiresValue && $value->size() === 0) {
49	1	throw new InvalidArgumentException;
50		}
51
52	3	return $value;
53		}
54
55	5	if (!is_array($value)) {
56	1	throw new InvalidArgumentException;
57		}
58
59	4	$sequence = Immutable\Sequence::of(...$value);
60
61	4	if ($this->requiresValue && $sequence->size() === 0) {
62	1	throw new InvalidArgumentException;
63		}
64
65	3	return $sequence;
66		}
67		}
68

Innmind / Config

Sequence::process() D last analyzed 2018-04-02 08:32 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Sequence::process() D
last analyzed 2018-04-02 08:32 UTC