DefinitionParser::parse() - Code Metrics - Inspection of "Merge branch 'master' into lazy-services" - yiisoft/di - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — lazy-services ( 2f8c8b...8212a3 )

by Dmitriy

created 2022-11-20 08:38 UTC

DefinitionParser::parse() B

↳ Parent: DefinitionParser

Complexity

Conditions	10
Paths	10

Size

Total Lines	64
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	33
c	0
b	0
f	0
nc	10
nop	1
dl	0
loc	64
rs	7.6666

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Di\Helpers;

use Yiisoft\Definitions\ArrayDefinition;

use function count;
use function is_array;
use function is_callable;
use function is_string;

/**
 * @internal Splits metadata and definition.
 *
 * Supports the following configuration:
 *
 * 1) With a dedicated definition:
 *
 * ```php
 * Engine::class => [
 *     'definition' => [
 *         '__class' => BigEngine::class,
 *         'setNumber()' => [42],
 *     ],
 *     'tags' => ['a', 'b'],
 *     'reset' => function () {
 *         $this->number = 42;
 *      },
 * ]
 * ```
 *
 * 2) Mixed in array definition:
 *
 * ```php
 * Engine::class => [
 *     '__class' => BigEngine::class,
 *     'setNumber()' => [42],
 *     'tags' => ['a', 'b'],
 *     'reset' => function () {
 *         $this->number = 42;
 *      },
 * ]
 * ```
 */
final class DefinitionParser
{
    private const DEFINITION_META = 'definition';

    public const IS_PREPARED_ARRAY_DEFINITION_DATA = 'isPreparedArrayDefinitionData';

    /**
     * @param mixed $definition Definition to parse.
     *
     * @return array Definition parsed into array of a special structure.
     *
     * @psalm-return array{mixed,array}
     */
    public static function parse(mixed $definition): array
    {
        if (!is_array($definition)) {
            return [$definition, []];
        }

        // Dedicated definition
        if (isset($definition[self::DEFINITION_META])) {
            /** @var mixed $newDefinition */
            $newDefinition = $definition[self::DEFINITION_META];
            unset($definition[self::DEFINITION_META]);

            return [$newDefinition, $definition];
        }

        // Callable definition
        if (is_callable($definition, true)) {
            return [$definition, []];
        }

        // Array definition
        $meta = [];
        $class = null;
        $constructorArguments = [];
        $methodsAndProperties = [];
        /** @var mixed $value */
        foreach ($definition as $key => $value) {
            if (is_string($key)) {
                // Class
                if ($key === ArrayDefinition::CLASS_NAME) {
                    /** @var mixed $class */
                    $class = $value;
                    continue;
                }

                // Constructor arguments
                if ($key === ArrayDefinition::CONSTRUCTOR) {
                    /** @var mixed $constructorArguments */
                    $constructorArguments = $value;
                    continue;
                }

                // Methods and properties
                if (count($methodArray = explode('()', $key, 2)) === 2) {
                    $methodsAndProperties[$key] = [ArrayDefinition::TYPE_METHOD, $methodArray[0], $value];
                    continue;
                }
                if (count($propertyArray = explode('$', $key, 2)) === 2) {
                    $methodsAndProperties[$key] = [ArrayDefinition::TYPE_PROPERTY, $propertyArray[1], $value];
                    continue;
                }
            }

            /** @var mixed */
            $meta[$key] = $value;
        }
        return [
            [
                'class' => $class,
                '__construct()' => $constructorArguments,
                'methodsAndProperties' => $methodsAndProperties,
                self::IS_PREPARED_ARRAY_DEFINITION_DATA => true,
            ],
            $meta,
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Di\Helpers;
6
7			use Yiisoft\Definitions\ArrayDefinition;
8
9			use function count;
10			use function is_array;
11			use function is_callable;
12			use function is_string;
13
14			/**
15			* @internal Splits metadata and definition.
16			*
17			* Supports the following configuration:
18			*
19			* 1) With a dedicated definition:
20			*
21			* ```php
22			* Engine::class => [
23			* 'definition' => [
24			* '__class' => BigEngine::class,
25			* 'setNumber()' => [42],
26			* ],
27			* 'tags' => ['a', 'b'],
28			* 'reset' => function () {
29			* $this->number = 42;
30			* },
31			* ]
32			* ```
33			*
34			* 2) Mixed in array definition:
35			*
36			* ```php
37			* Engine::class => [
38			* '__class' => BigEngine::class,
39			* 'setNumber()' => [42],
40			* 'tags' => ['a', 'b'],
41			* 'reset' => function () {
42			* $this->number = 42;
43			* },
44			* ]
45			* ```
46			*/
47			final class DefinitionParser
48			{
49			private const DEFINITION_META = 'definition';
50
51			public const IS_PREPARED_ARRAY_DEFINITION_DATA = 'isPreparedArrayDefinitionData';
52
53			/**
54			* @param mixed $definition Definition to parse.
55			*
56			* @return array Definition parsed into array of a special structure.
57			*
58			* @psalm-return array{mixed,array}
59			*/
60			public static function parse(mixed $definition): array
61			{
62			if (!is_array($definition)) {
63			return [$definition, []];
64			}
65
66			// Dedicated definition
67			if (isset($definition[self::DEFINITION_META])) {
68			/** @var mixed $newDefinition */
69			$newDefinition = $definition[self::DEFINITION_META];
70			unset($definition[self::DEFINITION_META]);
71
72			return [$newDefinition, $definition];
73			}
74
75			// Callable definition
76			if (is_callable($definition, true)) {
77			return [$definition, []];
78			}
79
80			// Array definition
81			$meta = [];
82			$class = null;
83			$constructorArguments = [];
84			$methodsAndProperties = [];
85			/** @var mixed $value */
86			foreach ($definition as $key => $value) {
87			if (is_string($key)) {
88			// Class
89			if ($key === ArrayDefinition::CLASS_NAME) {
90			/** @var mixed $class */
91			$class = $value;
92			continue;
93			}
94
95			// Constructor arguments
96			if ($key === ArrayDefinition::CONSTRUCTOR) {
97			/** @var mixed $constructorArguments */
98			$constructorArguments = $value;
99			continue;
100			}
101
102			// Methods and properties
103			if (count($methodArray = explode('()', $key, 2)) === 2) {
104			$methodsAndProperties[$key] = [ArrayDefinition::TYPE_METHOD, $methodArray[0], $value];
105			continue;
106			}
107			if (count($propertyArray = explode('$', $key, 2)) === 2) {
108			$methodsAndProperties[$key] = [ArrayDefinition::TYPE_PROPERTY, $propertyArray[1], $value];
109			continue;
110			}
111			}
112
113			/** @var mixed */
114			$meta[$key] = $value;
115			}
116			return [
117			[
118			'class' => $class,
119			'__construct()' => $constructorArguments,
120			'methodsAndProperties' => $methodsAndProperties,
121			self::IS_PREPARED_ARRAY_DEFINITION_DATA => true,
122			],
123			$meta,
124			];
125			}
126			}
127

yiisoft / di

Push — lazy-services ( 2f8c8b...8212a3 )

DefinitionParser::parse() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like