Map::__construct() - Code Metrics - Innmind/Compose - Measure and Improve Code Quality continuously with Scrutinizer

Map::__construct() A
last analyzed 2018-08-13 05:49 UTC

↳ Parent: Map

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Definition\Argument\Type;

use Innmind\Compose\{
    Definition\Argument\Type,
    Exception\ValueNotSupported
};
use Innmind\Immutable\{
    MapInterface,
    Str
};

final class Map implements Type
{
    private const PATTERN = '~^map<(?<key>.+), ?(?<value>.+)>$~';
    private $key;
    private $value;

    public function __construct(string $key, string $value)
    {
        $this->key = $key;
        $this->value = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function accepts($value): bool
    {
        if (!$value instanceof MapInterface) {
            return false;
        }

        return (string) $value->keyType() === $this->key &&
            (string) $value->valueType() === $this->value;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromString(Str $value): Type
    {
        if (!$value->matches(self::PATTERN)) {
            throw new ValueNotSupported((string) $value);
        }

        $components = $value->capture(self::PATTERN);

        return new self(
            (string) $components->get('key'),
            (string) $components->get('value')
        );
    }

    /**
     * {@inheritdoc}
     */
    public function __toString(): string
    {
        return sprintf('map<%s, %s>', $this->key, $this->value);
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Compose\Definition\Argument\Type;
5
6		use Innmind\Compose\{
7		Definition\Argument\Type,
8		Exception\ValueNotSupported
9		};
10		use Innmind\Immutable\{
11		MapInterface,
12		Str
13		};
14
15		final class Map implements Type
16		{
17		private const PATTERN = '~^map<(?<key>.+), ?(?<value>.+)>$~';
18		private $key;
19		private $value;
20
21	4	public function __construct(string $key, string $value)
22		{
23	4	$this->key = $key;
24	4	$this->value = $value;
25	4	}
26
27		/**
28		* {@inheritdoc}
29		*/
30	2	public function accepts($value): bool
31		{
32	2	if (!$value instanceof MapInterface) {
33	1	return false;
34		}
35
36	2	return (string) $value->keyType() === $this->key &&
37	2	(string) $value->valueType() === $this->value;
38		}
39
40		/**
41		* {@inheritdoc}
42		*/
43	15	public static function fromString(Str $value): Type
44		{
45	15	if (!$value->matches(self::PATTERN)) {
46	13	throw new ValueNotSupported((string) $value);
47		}
48
49	2	$components = $value->capture(self::PATTERN);
50
51	2	return new self(
52	2	(string) $components->get('key'),
53	2	(string) $components->get('value')
54		);
55		}
56
57		/**
58		* {@inheritdoc}
59		*/
60	1	public function __toString(): string
61		{
62	1	return sprintf('map<%s, %s>', $this->key, $this->value);
63		}
64		}
65

Innmind / Compose

Map::__construct() A last analyzed 2018-08-13 05:49 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Map::__construct() A
last analyzed 2018-08-13 05:49 UTC