Factory::__construct() - Code Metrics - Inspection of "Refactor factory" - yiisoft/factory - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#146)

by Dmitriy

created 2021-09-20 10:52 UTC

Factory::__construct() A

↳ Parent: Factory

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Factory;

use Psr\Container\ContainerInterface;
use Yiisoft\Definitions\ArrayDefinition;
use Yiisoft\Definitions\Contract\DefinitionInterface;
use Yiisoft\Definitions\Contract\ReferenceInterface;
use Yiisoft\Definitions\Infrastructure\DefinitionValidator;
use Yiisoft\Definitions\Exception\CircularReferenceException;
use Yiisoft\Definitions\Exception\InvalidConfigException;
use Yiisoft\Definitions\Exception\NotFoundException;
use Yiisoft\Definitions\Exception\NotInstantiableException;
use Yiisoft\Definitions\Infrastructure\Normalizer;

/**
 * Factory allows creating objects passing arguments runtime.
 * A factory will try to use a PSR-11 compliant container to get dependencies,
 * but will fall back to manual instantiation
 * if the container cannot provide a required dependency.
 */
final class Factory
{
    private ?ContainerInterface $container;
    private FactoryContainer $factoryContainer;

    /**
     * @var bool $validate Validate definitions when set
     */
    private bool $validate;

    /**
     * Factory constructor.
     *
     * @psalm-param array<string, mixed> $definitions
     *
     * @throws InvalidConfigException
     */
    public function __construct(
        ContainerInterface $container = null,
        array $definitions = [],
        bool $validate = true
    ) {
        $this->container = $container;
        $this->factoryContainer = new FactoryContainer($container);
        $this->validate = $validate;
        $this->setMultiple($definitions);
    }

    /**
     * Creates a new object using the given configuration.
     *
     * You may view this method as an enhanced version of the `new` operator.
     * The method supports creating an object based on a class name, a configuration array or
     * an anonymous function.
     *
     * Below are some usage examples:
     *
     * ```php
     * // create an object using a class name
     * $object = $factory->create(\Yiisoft\Db\Connection::class);
     *
     * // create an object using a configuration array
     * $object = $factory->create([
     *     'class' => \Yiisoft\Db\Connection\Connection::class,
     *     '__construct()' => [
     *         'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
     *     ],
     *     'setUsername()' => ['root'],
     *     'setPassword()' => [''],
     *     'setCharset()' => ['utf8'],
     * ]);
     * ```
     *
     * Using [[Container|dependency injection container]], this method can also identify
     * dependent objects, instantiate them and inject them into the newly created object.
     *
     * @param mixed $config The object configuration. This can be specified in one of the following forms:
     *
     * - A string: representing the class name of the object to be created.
     *
     * - A configuration array: the array must contain a `class` element which is treated as the object class,
     *   and the rest of the name-value pairs will be used to initialize the corresponding object properties.
     *
     * - A PHP callable: either an anonymous function or an array representing a class method
     *   (`[$class or $object, $method]`). The callable should return a new instance of the object being created.
     *
     * @throws InvalidConfigException If the configuration is invalid.
     * @throws CircularReferenceException
     * @throws NotFoundException
     * @throws NotInstantiableException
     *
     * @return mixed|object The created object.
     *
     * @psalm-template T
     * @psalm-param mixed|class-string<T> $config
     * @psalm-return ($config is class-string ? T : mixed)
     * @psalm-suppress MixedReturnStatement
     */
    public function create($config)
    {
        if ($this->validate) {
            DefinitionValidator::validate($config);
        }

        if (is_string($config)) {
            if ($this->factoryContainer->hasDefinition($config)) {
                return $this->factoryContainer->get($config);
            }
            throw new NotFoundException($config);
        }

        $definition = $this->createDefinition($config);

        if ($definition instanceof ArrayDefinition) {
            $definition->setReferenceContainer($this->factoryContainer);
        }
        try {
            $container = ($this->container === null || $definition instanceof ReferenceInterface) ? $this->factoryContainer : $this->container;
            return $definition->resolve($container);
        } finally {
            if ($definition instanceof ArrayDefinition) {
                $definition->setReferenceContainer(null);
            }
        }
    }

    /**
     * Sets a definition to the factory.
     *
     * @param mixed $definition
     *
     * @throws InvalidConfigException
     */
    public function set(string $id, $definition): void
    {
        if ($this->validate) {
            DefinitionValidator::validate($definition, $id);
        }

        $this->factoryContainer->setDefinition($id, $definition);
    }

    /**
     * Sets multiple definitions at once.
     *
     * @param array $definitions definitions indexed by their ids
     *
     * @psalm-param array<string, mixed> $definitions
     *
     * @throws InvalidConfigException
     */
    public function setMultiple(array $definitions): void
    {
        /** @var mixed $definition */
        foreach ($definitions as $id => $definition) {
            $this->set($id, $definition);
        }
    }

    /**
     * @param mixed $config
     *
     * @throws InvalidConfigException
     */
    private function createDefinition($config): DefinitionInterface
    {
        $definition = Normalizer::normalize($config);

        if (
            ($definition instanceof ArrayDefinition) &&
            $this->factoryContainer->hasDefinition($definition->getClass())
        ) {
            $definition = $this->mergeDefinitions(
                $this->factoryContainer->getDefinition($definition->getClass()),
                $definition
            );
        }

        return $definition;
    }

    private function mergeDefinitions(DefinitionInterface $one, ArrayDefinition $two): DefinitionInterface
    {
        return $one instanceof ArrayDefinition ? $one->merge($two) : $two;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Factory;
6
7		use Psr\Container\ContainerInterface;
8		use Yiisoft\Definitions\ArrayDefinition;
9		use Yiisoft\Definitions\Contract\DefinitionInterface;
10		use Yiisoft\Definitions\Contract\ReferenceInterface;
11		use Yiisoft\Definitions\Infrastructure\DefinitionValidator;
12		use Yiisoft\Definitions\Exception\CircularReferenceException;
13		use Yiisoft\Definitions\Exception\InvalidConfigException;
14		use Yiisoft\Definitions\Exception\NotFoundException;
15		use Yiisoft\Definitions\Exception\NotInstantiableException;
16		use Yiisoft\Definitions\Infrastructure\Normalizer;
17
18		/**
19		* Factory allows creating objects passing arguments runtime.
20		* A factory will try to use a PSR-11 compliant container to get dependencies,
21		* but will fall back to manual instantiation
22		* if the container cannot provide a required dependency.
23		*/
24		final class Factory
25		{
26		private ?ContainerInterface $container;
27		private FactoryContainer $factoryContainer;
28
29		/**
30		* @var bool $validate Validate definitions when set
31		*/
32		private bool $validate;
33
34		/**
35		* Factory constructor.
36		*
37		* @psalm-param array<string, mixed> $definitions
38		*
39		* @throws InvalidConfigException
40		*/
41	86	public function __construct(
42		ContainerInterface $container = null,
43		array $definitions = [],
44		bool $validate = true
45		) {
46	86	$this->container = $container;
47	86	$this->factoryContainer = new FactoryContainer($container);
48	86	$this->validate = $validate;
49	86	$this->setMultiple($definitions);
50	84	}
51
52		/**
53		* Creates a new object using the given configuration.
54		*
55		* You may view this method as an enhanced version of the `new` operator.
56		* The method supports creating an object based on a class name, a configuration array or
57		* an anonymous function.
58		*
59		* Below are some usage examples:
60		*
61		* ```php
62		* // create an object using a class name
63		* $object = $factory->create(\Yiisoft\Db\Connection::class);
64		*
65		* // create an object using a configuration array
66		* $object = $factory->create([
67		* 'class' => \Yiisoft\Db\Connection\Connection::class,
68		* '__construct()' => [
69		* 'dsn' => 'mysql:host=127.0.0.1;dbname=demo',
70		* ],
71		* 'setUsername()' => ['root'],
72		* 'setPassword()' => [''],
73		* 'setCharset()' => ['utf8'],
74		* ]);
75		* ```
76		*
77		* Using [[Container\|dependency injection container]], this method can also identify
78		* dependent objects, instantiate them and inject them into the newly created object.
79		*
80		* @param mixed $config The object configuration. This can be specified in one of the following forms:
81		*
82		* - A string: representing the class name of the object to be created.
83		*
84		* - A configuration array: the array must contain a `class` element which is treated as the object class,
85		* and the rest of the name-value pairs will be used to initialize the corresponding object properties.
86		*
87		* - A PHP callable: either an anonymous function or an array representing a class method
88		* (`[$class or $object, $method]`). The callable should return a new instance of the object being created.
89		*
90		* @throws InvalidConfigException If the configuration is invalid.
91		* @throws CircularReferenceException
92		* @throws NotFoundException
93		* @throws NotInstantiableException
94		*
95		* @return mixed\|object The created object.
96		*
97		* @psalm-template T
98		* @psalm-param mixed\|class-string<T> $config
99		* @psalm-return ($config is class-string ? T : mixed)
100		* @psalm-suppress MixedReturnStatement
101		*/
102	83	public function create($config)
103		{
104	83	if ($this->validate) {
105	79	DefinitionValidator::validate($config);
106		}
107
108	79	if (is_string($config)) {
109	62	if ($this->factoryContainer->hasDefinition($config)) {
110	59	return $this->factoryContainer->get($config);
111		}
112	3	throw new NotFoundException($config);
113		}
114
115	19	$definition = $this->createDefinition($config);
116
117	18	if ($definition instanceof ArrayDefinition) {
118	16	$definition->setReferenceContainer($this->factoryContainer);
119		}
120		try {
121	18	$container = ($this->container === null \|\| $definition instanceof ReferenceInterface) ? $this->factoryContainer : $this->container;
122	18	return $definition->resolve($container);
123		} finally {
124	18	if ($definition instanceof ArrayDefinition) {
125	18	$definition->setReferenceContainer(null);
126		}
127		}
128		}
129
130		/**
131		* Sets a definition to the factory.
132		*
133		* @param mixed $definition
134		*
135		* @throws InvalidConfigException
136		*/
137	54	public function set(string $id, $definition): void
138		{
139	54	if ($this->validate) {
140	51	DefinitionValidator::validate($definition, $id);
141		}
142
143	51	$this->factoryContainer->setDefinition($id, $definition);
144	51	}
145
146		/**
147		* Sets multiple definitions at once.
148		*
149		* @param array $definitions definitions indexed by their ids
150		*
151		* @psalm-param array<string, mixed> $definitions
152		*
153		* @throws InvalidConfigException
154		*/
155	86	public function setMultiple(array $definitions): void
156		{
157		/** @var mixed $definition */
158	86	foreach ($definitions as $id => $definition) {
159	52	$this->set($id, $definition);
160		}
161	84	}
162
163		/**
164		* @param mixed $config
165		*
166		* @throws InvalidConfigException
167		*/
168	19	private function createDefinition($config): DefinitionInterface
169		{
170	19	$definition = Normalizer::normalize($config);
171
172		if (
173	18	($definition instanceof ArrayDefinition) &&
174	18	$this->factoryContainer->hasDefinition($definition->getClass())
175		) {
176	16	$definition = $this->mergeDefinitions(
177	16	$this->factoryContainer->getDefinition($definition->getClass()),
178		$definition
179		);
180		}
181
182	18	return $definition;
183		}
184
185	16	private function mergeDefinitions(DefinitionInterface $one, ArrayDefinition $two): DefinitionInterface
186		{
187	16	return $one instanceof ArrayDefinition ? $one->merge($two) : $two;
188		}
189		}
190

yiisoft / factory

Pull Request — master (#146)

Factory::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like