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

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

↳ Parent: Structures

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3

Importance

Changes

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

<?php
declare(strict_types = 1);

namespace Innmind\Config;

use Innmind\Config\Exception\{
    DomainException,
    SchemaNotParseable,
};
use Innmind\Immutable\{
    StreamInterface,
    Stream,
};

final class Structures
{
    private static $defaults;
    private $structures;

    public function __construct(string ...$structures)
    {
        $structures = Stream::of('string', ...$structures);

        if ($structures->size() === 0) {
            $structures = self::defaults();
        }

        $structures->foreach(static function(string $structure): void {
            $refl = new \ReflectionClass($structure);

            if (!$refl->implementsInterface(Structure::class)) {
                throw new DomainException($structure);
            }
        });

        $this->structures = $structures;
    }

    public function build(array $schema, Properties $properties): Structure
    {
        foreach ($this->structures as $structure) {
            try {
                return [$structure, 'build']($schema, $this, $properties);
            } catch (SchemaNotParseable $e) {
                //pass
            }
        }

        throw new SchemaNotParseable('', 0, $e ?? null);
    }

    /**
     * @return StreamInterface<Structure>
     */
    public static function defaults(): StreamInterface
    {
        return self::$defaults ?? self::$defaults = Stream::of(
            'string',
            Structure\Prototype::class,
            Structure\Map::class
        );
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Config;
5
6		use Innmind\Config\Exception\{
7		DomainException,
8		SchemaNotParseable,
9		};
10		use Innmind\Immutable\{
11		StreamInterface,
12		Stream,
13		};
14
15		final class Structures
16		{
17		private static $defaults;
18		private $structures;
19
20	26	public function __construct(string ...$structures)
21		{
22	26	$structures = Stream::of('string', ...$structures);
23
24	26	if ($structures->size() === 0) {
25	23	$structures = self::defaults();
26		}
27
28	26	$structures->foreach(static function(string $structure): void {
29	26	$refl = new \ReflectionClass($structure);
30
31	26	if (!$refl->implementsInterface(Structure::class)) {
32	1	throw new DomainException($structure);
33		}
34	26	});
35
36	25	$this->structures = $structures;
37	25	}
38
39	19	public function build(array $schema, Properties $properties): Structure
40		{
41	19	foreach ($this->structures as $structure) {
42		try {
43	19	return [$structure, 'build']($schema, $this, $properties);
44	19	} catch (SchemaNotParseable $e) {
45		//pass
46		}
47		}
48
49	4	throw new SchemaNotParseable('', 0, $e ?? null);
50		}
51
52		/**
53		* @return StreamInterface<Structure>
54		*/
55	24	public static function defaults(): StreamInterface
56		{
57	24	return self::$defaults ?? self::$defaults = Stream::of(
58	1	'string',
59	1	Structure\Prototype::class,
60	24	Structure\Map::class
61		);
62		}
63		}
64

Innmind / Config

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

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

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