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

Construct::__invoke() A
last analyzed 2018-08-13 05:49 UTC

↳ Parent: Construct

Complexity

Conditions	2
Paths	1

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

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

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Definition\Service\Constructor;

use Innmind\Compose\{
    Definition\Service\Constructor,
    Lazy,
    Compilation\Service\Constructor as CompiledConstructor,
    Compilation\Service\Constructor\Construct as CompiledConstruct,
    Compilation\Service\Argument as CompiledArgument
};
use Innmind\Immutable\{
    Str,
    Sequence
};

final class Construct implements Constructor
{
    private $value;

    private function __construct(string $value)
    {
        $this->value = $value;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromString(Str $value): Constructor
    {
        return new self((string) $value);
    }

    /**
     * {@inheritdoc}
     */
    public function __invoke(...$arguments): object
    {
        $class = (string) $this->value;

        $arguments = Sequence::of(...$arguments)->map(static function($argument) {
            if ($argument instanceof Lazy) {
                return $argument->load();
            }

            return $argument;
        });

        return new $class(...$arguments);
    }

    public function compile(CompiledArgument ...$arguments): CompiledConstructor
    {
        return new CompiledConstruct($this->value, ...$arguments);
    }

    public function __toString(): string
    {
        return $this->value;
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Compose\Definition\Service\Constructor;
5
6		use Innmind\Compose\{
7		Definition\Service\Constructor,
8		Lazy,
9		Compilation\Service\Constructor as CompiledConstructor,
10		Compilation\Service\Constructor\Construct as CompiledConstruct,
11		Compilation\Service\Argument as CompiledArgument
12		};
13		use Innmind\Immutable\{
14		Str,
15		Sequence
16		};
17
18		final class Construct implements Constructor
19		{
20		private $value;
21
22	224	private function __construct(string $value)
23		{
24	224	$this->value = $value;
25	224	}
26
27		/**
28		* {@inheritdoc}
29		*/
30	224	public static function fromString(Str $value): Constructor
31		{
32	224	return new self((string) $value);
33		}
34
35		/**
36		* {@inheritdoc}
37		*/
38	115	public function __invoke(...$arguments): object
39		{
40	115	$class = (string) $this->value;
41
42	115	$arguments = Sequence::of(...$arguments)->map(static function($argument) {
43	19	if ($argument instanceof Lazy) {
44	15	return $argument->load();
45		}
46
47	16	return $argument;
48	115	});
49
50	114	return new $class(...$arguments);
51		}
52
53	7	public function compile(CompiledArgument ...$arguments): CompiledConstructor
54		{
55	7	return new CompiledConstruct($this->value, ...$arguments);
56		}
57
58	24	public function __toString(): string
59		{
60	24	return $this->value;
61		}
62		}
63

Innmind / Compose

Construct::__invoke() A last analyzed 2018-08-13 05:49 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Construct::__invoke() A
last analyzed 2018-08-13 05:49 UTC