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

Primitive::build() A
last analyzed 2018-04-02 08:32 UTC

↳ Parent: Primitive

Complexity

Conditions	4
Paths	4

Size

Total Lines	19
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4.016

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	4
nop	2
dl	0
loc	19
ccs	9
cts	10
cp	0.9
crap	4.016
rs	9.2
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;

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

    private $function;
    private $optional = false;

    private function __construct(string $type)
    {
        $this->function = 'is_'.$type;
    }

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

        $type = (string) $schema->capture(self::PATTERN)->get('type');

        if (!function_exists('is_'.$type)) {
            throw new SchemaNotParseable((string) $schema);
        }

        $self = new self($type);

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

Innmind / Config

Primitive::build() A last analyzed 2018-04-02 08:32 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Primitive::build() A
last analyzed 2018-04-02 08:32 UTC