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

Enum::build() B
last analyzed 2018-04-02 08:32 UTC

↳ Parent: Enum

Complexity

Conditions	3
Paths	3

Size

Total Lines	24
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	14
nc	3
nop	2
dl	0
loc	24
ccs	15
cts	15
cp	1
crap	3
rs	8.9713
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\{
    Str,
    SetInterface,
    Set,
};

final class Enum implements Property
{
    private const PATTERN = '~^\??enum\((?<values>.+)\)$~';

    private $values;
    private $optional = false;

    private function __construct(Set $values)
    {
        $this->values = $values;
    }

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

        $self = new self(
            $schema
                ->capture(self::PATTERN)
                ->get('values')
                ->split('|')
                ->reduce(
                    Set::of('string'),
                    static function(SetInterface $values, Str $value): SetInterface {
                        return $values->add((string) $value);
                    }
                )
        );

        if ((string) $schema->substring(0, 1) === '?') {
            $self->optional = true;
        }

        return $self;
    }

    /**
     * {@inheritdoc}
     */
    public function process($value)
    {
        if (is_null($value) && $this->optional) {
            return null;
        }

        if (!$this->values->contains($value)) {
            throw new InvalidArgumentException;
        }

        return $value;
    }
}


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		Str,
14		SetInterface,
15		Set,
16		};
17
18		final class Enum implements Property
19		{
20		private const PATTERN = '~^\??enum\((?<values>.+)\)$~';
21
22		private $values;
23		private $optional = false;
24
25	13	private function __construct(Set $values)
26		{
27	13	$this->values = $values;
28	13	}
29
30	16	public static function build(Str $schema, Properties $properties): Property
31		{
32	16	if (!$schema->matches(self::PATTERN)) {
33	3	throw new SchemaNotParseable((string) $schema);
34		}
35
36	13	$self = new self(
37		$schema
38	13	->capture(self::PATTERN)
39	13	->get('values')
40	13	->split('\|')
41	13	->reduce(
42	13	Set::of('string'),
43	13	static function(SetInterface $values, Str $value): SetInterface {
44	13	return $values->add((string) $value);
45	13	}
46		)
47		);
48
49	13	if ((string) $schema->substring(0, 1) === '?') {
50	6	$self->optional = true;
51		}
52
53	13	return $self;
54		}
55
56		/**
57		* {@inheritdoc}
58		*/
59	7	public function process($value)
60		{
61	7	if (is_null($value) && $this->optional) {
62	3	return null;
63		}
64
65	4	if (!$this->values->contains($value)) {
66	1	throw new InvalidArgumentException;
67		}
68
69	3	return $value;
70		}
71		}
72

Innmind / Config

Enum::build() B last analyzed 2018-04-02 08:32 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Enum::build() B
last analyzed 2018-04-02 08:32 UTC