Normalizer::parse() - Code Metrics - Inspection of "New array definition syntax" - yiisoft/factory - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#78)

by Dmitriy

created 2021-04-13 10:16 UTC

Normalizer::parse() B

↳ Parent: Normalizer

Complexity

Conditions	10
Paths	15

Size

Total Lines	38
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	23
dl	0
loc	38
rs	7.6666
c	1
b	0
f	0
cc	10
nc	15
nop	2

How to fix Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Factory\Definition;

use Yiisoft\Factory\Exception\InvalidConfigException;

use function array_key_exists;
use function is_array;
use function is_callable;
use function is_object;
use function is_string;

/**
 * Class Definition represents a definition in a container
 */
class Normalizer
{
    /**
     * Definition may be defined multiple ways.
     * Interface name as string:
     *
     * ```php
     * $container->set('interface_name', EngineInterface::class);
     * ```
     *
     * A closure:
     *
     * ```php
     * $container->set('closure', function($container) {
     *     return new MyClass($container->get('db'));
     * });
     * ```
     *
     * A callable array:
     *
     * ```php
     * $container->set('static_call', [MyClass::class, 'create']);
     * ```
     *
     * A definition array:
     *
     * ```php
     * $container->set('full_definition', [
     *     'class' => EngineMarkOne::class,
     *     '__construct()' => [42],
     *     '@argName' => 'value',
     *     'setX()' => [42],
     * ]);
     * ```
     *
     * @param mixed $definition
     *
     * @throws InvalidConfigException
     */
    public static function normalize($definition, string $id = null, array $constructorArguments = [], array $allowedMeta = []): DefinitionInterface
    {
        if ($definition instanceof DefinitionInterface) {
            return $definition;
        }

        if (is_string($definition)) {
            if (empty($definition)) {
                throw new InvalidConfigException('Invalid definition: empty string.');
            }
            if ($id === $definition || (!empty($constructorArguments) && class_exists($definition))) {
                /** @psalm-var class-string $definition */
                return new ArrayDefinition([
                    ArrayDefinition::CLASS_NAME => $definition,
                    ArrayDefinition::CONSTRUCTOR => $constructorArguments,
                ]);
            }
            return Reference::to($definition);
        }

        if (is_callable($definition, true)) {
            return new CallableDefinition($definition);
        }

        if (is_array($definition)) {
            $config = $definition;
            if (!array_key_exists(ArrayDefinition::CLASS_NAME, $config)) {
                $config[ArrayDefinition::CLASS_NAME] = $id;
            }
            /** @psalm-suppress ArgumentTypeCoercion */
            return new ArrayDefinition($config, $allowedMeta);
        }

        if (is_object($definition)) {
            return new ValueDefinition($definition);
        }

        throw new InvalidConfigException('Invalid definition:' . var_export($definition, true));
    }

    /**
     * Validates definition for correctness.
     *
     * @param mixed $definition {@see normalize()}
     *
     * @throws InvalidConfigException
     */
    public static function validate($definition, bool $throw = true): bool
    {
        if ($definition instanceof DefinitionInterface) {
            return true;
        }

        if (is_string($definition) && !empty($definition)) {
            return true;
        }

        if (is_callable($definition)) {
            return true;
        }

        if (is_array($definition)) {
            return true;
        }

        if (is_object($definition)) {
            return true;
        }

        if ($throw) {
            throw new InvalidConfigException('Invalid definition:' . var_export($definition, true));
        }

        return false;
    }

    /**
     * Validates definition for correctness.
     *
     * @param mixed $definition
     * @param array $allowedMeta
     *
     * @throws InvalidConfigException
     */
    public static function parse($definition, array $allowedMeta): array
    {
        if (!is_array($definition)) {
            return [$definition, []];
        }

        $meta = [];
        if (isset($definition[self::DEFINITION_META])) {

            $newDefinition = $definition[self::DEFINITION_META];
            unset($definition[self::DEFINITION_META]);
            $meta = array_filter($definition, function ($key) use ($allowedMeta) {
                return in_array($key, $allowedMeta);
            }, ARRAY_FILTER_USE_KEY);
            $definition = $newDefinition;
        }

        foreach ($definition as $key => $value) {
            // Method.
            if ($key === ArrayDefinition::CLASS_NAME || $key === ArrayDefinition::CONSTRUCTOR) {
                continue;
            } elseif (substr($key, -2) === '()') {
                if (!is_array($value)) {
                    throw new InvalidConfigException(
                        sprintf('Invalid definition: incorrect method arguments. Expected array, got %s.', self::getType($value))
                    );
                }
                // Not property = meta.
            } elseif (substr($key, 0, 1) !== '@') {

                if (!in_array($key, $allowedMeta, true)) {
                    throw new InvalidConfigException(sprintf('Invalid definition: metadata "%s" is not allowed. Did you mean "%s()" or "@%s"?', $key, $key, $key));
                }
                $meta[$key] = $value;
                unset($definition[$key]);
            }
        }

        return [$definition, $meta];
    }

    /**
     * @param mixed $value
     */
    private static function getType($value): string
    {
        return is_object($value) ? get_class($value) : gettype($value);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Factory\Definition;
6
7			use Yiisoft\Factory\Exception\InvalidConfigException;
8
9			use function array_key_exists;
10			use function is_array;
11			use function is_callable;
12			use function is_object;
13			use function is_string;
14
15			/**
16			* Class Definition represents a definition in a container
17			*/
18			class Normalizer
19			{
20			/**
21			* Definition may be defined multiple ways.
22			* Interface name as string:
23			*
24			* ```php
25			* $container->set('interface_name', EngineInterface::class);
26			* ```
27			*
28			* A closure:
29			*
30			* ```php
31			* $container->set('closure', function($container) {
32			* return new MyClass($container->get('db'));
33			* });
34			* ```
35			*
36			* A callable array:
37			*
38			* ```php
39			* $container->set('static_call', [MyClass::class, 'create']);
40			* ```
41			*
42			* A definition array:
43			*
44			* ```php
45			* $container->set('full_definition', [
46			* 'class' => EngineMarkOne::class,
47			* '__construct()' => [42],
48			* '@argName' => 'value',
49			* 'setX()' => [42],
50			* ]);
51			* ```
52			*
53			* @param mixed $definition
54			*
55			* @throws InvalidConfigException
56			*/
57			public static function normalize($definition, string $id = null, array $constructorArguments = [], array $allowedMeta = []): DefinitionInterface
58			{
59			if ($definition instanceof DefinitionInterface) {
60			return $definition;
61			}
62
63			if (is_string($definition)) {
64			if (empty($definition)) {
65			throw new InvalidConfigException('Invalid definition: empty string.');
66			}
67			if ($id === $definition \|\| (!empty($constructorArguments) && class_exists($definition))) {
68			/** @psalm-var class-string $definition */
69			return new ArrayDefinition([
70			ArrayDefinition::CLASS_NAME => $definition,
71			ArrayDefinition::CONSTRUCTOR => $constructorArguments,
72			]);
73			}
74			return Reference::to($definition);
75			}
76
77			if (is_callable($definition, true)) {
78			return new CallableDefinition($definition);
79			}
80
81			if (is_array($definition)) {
82			$config = $definition;
83			if (!array_key_exists(ArrayDefinition::CLASS_NAME, $config)) {
84			$config[ArrayDefinition::CLASS_NAME] = $id;
85			}
86			/** @psalm-suppress ArgumentTypeCoercion */
87			return new ArrayDefinition($config, $allowedMeta);
88			}
89
90			if (is_object($definition)) {
91			return new ValueDefinition($definition);
92			}
93
94			throw new InvalidConfigException('Invalid definition:' . var_export($definition, true));
95			}
96
97			/**
98			* Validates definition for correctness.
99			*
100			* @param mixed $definition {@see normalize()}
101			*
102			* @throws InvalidConfigException
103			*/
104			public static function validate($definition, bool $throw = true): bool
105			{
106			if ($definition instanceof DefinitionInterface) {
107			return true;
108			}
109
110			if (is_string($definition) && !empty($definition)) {
111			return true;
112			}
113
114			if (is_callable($definition)) {
115			return true;
116			}
117
118			if (is_array($definition)) {
119			return true;
120			}
121
122			if (is_object($definition)) {
123			return true;
124			}
125
126			if ($throw) {
127			throw new InvalidConfigException('Invalid definition:' . var_export($definition, true));
128			}
129
130			return false;
131			}
132
133			/**
134			* Validates definition for correctness.
135			*
136			* @param mixed $definition
137			* @param array $allowedMeta
138			*
139			* @throws InvalidConfigException
140			*/
141			public static function parse($definition, array $allowedMeta): array
142			{
143			if (!is_array($definition)) {
144			return [$definition, []];
145			}
146
147			$meta = [];
148			if (isset($definition[self::DEFINITION_META])) {
			0 ignored issues – show Bug introduced 2021-04-13 10:19 UTC by Report Bug Copy Issue Report The constant `Yiisoft\Factory\Definiti...alizer::DEFINITION_META` was not found. Maybe you did not declare it correctly or list all dependencies? Loading history...
149			$newDefinition = $definition[self::DEFINITION_META];
150			unset($definition[self::DEFINITION_META]);
151			$meta = array_filter($definition, function ($key) use ($allowedMeta) {
152			return in_array($key, $allowedMeta);
153			}, ARRAY_FILTER_USE_KEY);
154			$definition = $newDefinition;
155			}
156
157			foreach ($definition as $key => $value) {
158			// Method.
159			if ($key === ArrayDefinition::CLASS_NAME \|\| $key === ArrayDefinition::CONSTRUCTOR) {
160			continue;
161			} elseif (substr($key, -2) === '()') {
162			if (!is_array($value)) {
163			throw new InvalidConfigException(
164			sprintf('Invalid definition: incorrect method arguments. Expected array, got %s.', self::getType($value))
165			);
166			}
167			// Not property = meta.
168			} elseif (substr($key, 0, 1) !== '@') {
169
170			if (!in_array($key, $allowedMeta, true)) {
171			throw new InvalidConfigException(sprintf('Invalid definition: metadata "%s" is not allowed. Did you mean "%s()" or "@%s"?', $key, $key, $key));
172			}
173			$meta[$key] = $value;
174			unset($definition[$key]);
175			}
176			}
177
178			return [$definition, $meta];
179			}
180
181			/**
182			* @param mixed $value
183			*/
184			private static function getType($value): string
185			{
186			return is_object($value) ? get_class($value) : gettype($value);
187			}
188			}
189

yiisoft / factory

Pull Request — master (#78)

Normalizer::parse() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like