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

Arguments::load() A
last analyzed 2018-08-13 05:49 UTC

↳ Parent: Arguments

Complexity

Conditions	3
Paths	3

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

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

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Definition\Service;

use Innmind\Compose\Exception\ValueNotSupported;
use Innmind\Immutable\{
    StreamInterface,
    Stream
};

final class Arguments
{
    private static $defaults;
    private $arguments;

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

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

        $this->arguments = $arguments;
    }

    /**
     * @param mixed $value
     */
    public function load($value): Argument
    {
        foreach ($this->arguments as $argument) {
            try {
                $build = $argument.'::fromValue';

                return $build($value, $this);
            } catch (ValueNotSupported $e) {
                //pass
            }
        }

        throw new ValueNotSupported(var_export($value, true));
    }

    /**
     * @return StreamInterface<string>
     */
    public static function defaults(): StreamInterface
    {
        return self::$defaults ?? self::$defaults = Stream::of(
            'string',
            Argument\Decorate::class,
            Argument\Reference::class,
            Argument\Unwind::class,
            Argument\Pair::class,
            Argument\Primitive::class
        );
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Compose\Definition\Service;
5
6		use Innmind\Compose\Exception\ValueNotSupported;
7		use Innmind\Immutable\{
8		StreamInterface,
9		Stream
10		};
11
12		final class Arguments
13		{
14		private static $defaults;
15		private $arguments;
16
17	91	public function __construct(string ...$arguments)
18		{
19	91	$arguments = Stream::of('string', ...$arguments);
20
21	91	if ($arguments->size() === 0) {
22	90	$arguments = self::defaults();
23		}
24
25	91	$this->arguments = $arguments;
26	91	}
27
28		/**
29		* @param mixed $value
30		*/
31	34	public function load($value): Argument
32		{
33	34	foreach ($this->arguments as $argument) {
34		try {
35	34	$build = $argument.'::fromValue';
36
37	34	return $build($value, $this);
38	27	} catch (ValueNotSupported $e) {
39		//pass
40		}
41		}
42
43	1	throw new ValueNotSupported(var_export($value, true));
44		}
45
46		/**
47		* @return StreamInterface<string>
48		*/
49	91	public static function defaults(): StreamInterface
50		{
51	91	return self::$defaults ?? self::$defaults = Stream::of(
52	1	'string',
53	1	Argument\Decorate::class,
54	1	Argument\Reference::class,
55	1	Argument\Unwind::class,
56	1	Argument\Pair::class,
57	91	Argument\Primitive::class
58		);
59		}
60		}
61

Innmind / Compose

Arguments::load() A last analyzed 2018-08-13 05:49 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Arguments::load() A
last analyzed 2018-08-13 05:49 UTC