Container::get() - Code Metrics - php-kitchen/yii2-di - Measure and Improve Code Quality continuously with Scrutinizer

Container::get() A
last analyzed 2018-01-15 16:03 UTC

↳ Parent: Container

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	3
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0

<?php

namespace PHPKitchen\DI;

use PHPKitchen\DI\Contracts\ServiceProvider;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use yii\base\InvalidConfigException;

/**
 * Represents advanced Dependency Injection container.
 *
 * Provides such features as:
 * - decorators: allows to decorate objects without affecting their container definitions.
 * - service providers: allows to group complex dependencies definitions in a single class that bootstraps
 * service or services.
 * - factories: generate factories for classes dynamically.
 *
 * @package core\di
 * @author Dmitry Kolodko <[email protected]>
 */
class Container extends \yii\di\Container implements Contracts\Container {
    /**
     * @var Contracts\ObjectDecorator[]|array
     */
    protected $_decorators;
    /**
     * @var Contracts\DelayedServiceProvider[]|\SplObjectStorage
     */
    protected $delayedServiceProviders;
    /**
     * @var string default class for factory.
     */
    public $factoryClass = ClassFactory::class;

    public function init() {
        parent::init();
        $this->delayedServiceProviders = new \SplObjectStorage();
    }

    public function addProvider($provider) {
        $this->registerServiceProvider($provider);
    }

    public function addDecorator($objectName, $decorator) {
        $this->_decorators[$objectName][] = $decorator;
    }

    public function createFactoryFor($class) {
        return $this->create([
            'class' => $this->factoryClass,
            'className' => $class,
        ]);
    }

    /**
     * Creates a new object using the given configuration.
     *
     * @param string|array|callable $type the object type. 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.
     *
     * @param array $params the constructor parameters
     *
     * @return object the created object
     * @throws InvalidConfigException if the configuration is invalid.
     * @see \yii\di\Container
     */
    public function create($type, array $params = []) {
        if (is_string($type)) {
            $object = $this->get($type, $params);
        } elseif (is_array($type) && isset($type['class'])) {
            $class = $type['class'];
            unset($type['class']);
            $object = $this->get($class, $params, $type);
        } elseif (is_callable($type, true)) {
            $object = $this->invoke($type, $params);
        } elseif (is_array($type)) {
            throw new InvalidConfigException('Object configuration must be an array containing a "class" element.');
        } else {
            throw new InvalidConfigException('Unsupported configuration type: ' . gettype($type));
        }

        return $object;
    }

    /**
     * @inheritdoc
     * @override
     */
    public function get($class, $params = [], $config = []) {
        $this->registerDelayedServiceProviderFor($class);

        $object = parent::get($class, $params, $config);

        $this->runDecoratorsOnObject($class, $object);

        return $object;
    }

    protected function registerDelayedServiceProviderFor($classOrInterface) {
        $delayedServiceProviders = $this->delayedServiceProviders;
        if ($delayedServiceProviders->count() === 0) {
            return;
        }

        foreach ($delayedServiceProviders as $delayedServiceProvider) {
            if ($delayedServiceProvider->provides($classOrInterface)) {
                $delayedServiceProvider->register();
                $delayedServiceProviders->detach($delayedServiceProvider);
            }
        }
    }

    /**
     * Configures an object with the initial property values.
     *
     * @param object $object the object to be configured
     * @param array $properties the property initial values given in terms of name-value pairs.
     *
     * @return object the object itself
     */
    public function configureObject($object, $properties) {
        foreach ($properties as $name => $value) {
            $object->$name = $value;
        }

        return $object;
    }

    /**
     * @param string $definitionName class or name of definition in container
     *
     * @return array definition or empty array if definition not set.
     */
    public function getDefinitionOf($definitionName) {
        $definitions = $this->getDefinitions();

        return isset($definitions[$definitionName]) ? $definitions[$definitionName] : [];
    }

    protected function runDecoratorsOnObject($decoratorsGroupName, $object) {
        if (!$this->isDecoratorsGroupRegistered($decoratorsGroupName)) {
            return;
        }
        foreach ($this->_decorators[$decoratorsGroupName] as &$decorator) {
            if (is_callable($decorator)) {
                call_user_func($decorator, $object);
                continue;
            }
            if (!is_object($decorator)) {
                $decorator = $this->create($decorator);
            }
            $decorator->decorate($object);
        }
    }

    protected function isDecoratorsGroupRegistered($decoratorsGroup) {
        $objectName = is_object($decoratorsGroup) ? get_class($decoratorsGroup) : $decoratorsGroup;

        return isset($this->_decorators[$objectName]) && !empty($this->_decorators[$objectName]);
    }

    /**
     * @param ServiceProvider $serviceProvider
     *
     * @throws InvalidConfigException
     */
    protected function registerServiceProvider($serviceProvider) {
        $serviceProvider = $this->ensureProviderIsObject($serviceProvider);

        if (!($serviceProvider instanceof Contracts\ServiceProvider)) {
            throw new InvalidConfigException('Service provider should be an instance of ' . ServiceProvider::class);
        } elseif ($serviceProvider instanceof Contracts\DelayedServiceProvider) {
            $this->addDelayedServiceProvider($serviceProvider);
        } else {
            $serviceProvider->register();
        }
    }

    protected function addDelayedServiceProvider($provider) {
        $this->delayedServiceProviders->attach($provider);
    }

    protected function ensureProviderIsObject($provider) {
        if (!is_object($provider)) {
            $provider = $this->create($provider);
        }

        return $provider;
    }

    //region ---------------------- SETTERS -------------------------------

    public function setDecorators($name, array $decorators) {
        foreach ($decorators as $decorator) {
            $this->addDecorator($name, $decorator);
        }
    }

    public function setServiceProviders(array $serviceProviders) {
        foreach ($serviceProviders as $serviceProvider) {
            $this->registerServiceProvider($serviceProvider);
        }
    }
    //endregion
}

1			<?php
2
3			namespace PHPKitchen\DI;
4
5			use PHPKitchen\DI\Contracts\ServiceProvider;
			0 ignored issues – show Bug introduced 2017-10-09 12:07 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `PHPKitchen\DI\ServiceProvider`. Consider defining an alias. Let?s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let?s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
6			use yii\base\InvalidConfigException;
7
8			/**
9			* Represents advanced Dependency Injection container.
10			*
11			* Provides such features as:
12			* - decorators: allows to decorate objects without affecting their container definitions.
13			* - service providers: allows to group complex dependencies definitions in a single class that bootstraps
14			* service or services.
15			* - factories: generate factories for classes dynamically.
16			*
17			* @package core\di
18			* @author Dmitry Kolodko <[email protected]>
19			*/
20			class Container extends \yii\di\Container implements Contracts\Container {
21			/**
22			* @var Contracts\ObjectDecorator[]\|array
23			*/
24			protected $_decorators;
25			/**
26			* @var Contracts\DelayedServiceProvider[]\|\SplObjectStorage
27			*/
28			protected $delayedServiceProviders;
29			/**
30			* @var string default class for factory.
31			*/
32			public $factoryClass = ClassFactory::class;
33
34			public function init() {
35			parent::init();
36			$this->delayedServiceProviders = new \SplObjectStorage();
37			}
38
39			public function addProvider($provider) {
40			$this->registerServiceProvider($provider);
41			}
42
43			public function addDecorator($objectName, $decorator) {
44			$this->_decorators[$objectName][] = $decorator;
45			}
46
47			public function createFactoryFor($class) {
48			return $this->create([
49			'class' => $this->factoryClass,
50			'className' => $class,
51			]);
52			}
53
54			/**
55			* Creates a new object using the given configuration.
56			*
57			* @param string\|array\|callable $type the object type. This can be specified in one of the following forms:
58			*
59			* - a string: representing the class name of the object to be created
60			* - a configuration array: the array must contain a `class` element which is treated as the object class,
61			* and the rest of the name-value pairs will be used to initialize the corresponding object properties
62			* - a PHP callable: either an anonymous function or an array representing a class method (`[$class or $object, $method]`).
63			* The callable should return a new instance of the object being created.
64			*
65			* @param array $params the constructor parameters
66			*
67			* @return object the created object
68			* @throws InvalidConfigException if the configuration is invalid.
69			* @see \yii\di\Container
70			*/
71			public function create($type, array $params = []) {
72			if (is_string($type)) {
73			$object = $this->get($type, $params);
74			} elseif (is_array($type) && isset($type['class'])) {
75			$class = $type['class'];
76			unset($type['class']);
77			$object = $this->get($class, $params, $type);
78			} elseif (is_callable($type, true)) {
79			$object = $this->invoke($type, $params);
80			} elseif (is_array($type)) {
81			throw new InvalidConfigException('Object configuration must be an array containing a "class" element.');
82			} else {
83			throw new InvalidConfigException('Unsupported configuration type: ' . gettype($type));
84			}
85
86			return $object;
87			}
88
89			/**
90			* @inheritdoc
91			* @override
92			*/
93			public function get($class, $params = [], $config = []) {
94			$this->registerDelayedServiceProviderFor($class);
95
96			$object = parent::get($class, $params, $config);
97
98			$this->runDecoratorsOnObject($class, $object);
99
100			return $object;
101			}
102
103			protected function registerDelayedServiceProviderFor($classOrInterface) {
104			$delayedServiceProviders = $this->delayedServiceProviders;
105			if ($delayedServiceProviders->count() === 0) {
106			return;
107			}
108
109			foreach ($delayedServiceProviders as $delayedServiceProvider) {
110			if ($delayedServiceProvider->provides($classOrInterface)) {
111			$delayedServiceProvider->register();
112			$delayedServiceProviders->detach($delayedServiceProvider);
113			}
114			}
115			}
116
117			/**
118			* Configures an object with the initial property values.
119			*
120			* @param object $object the object to be configured
121			* @param array $properties the property initial values given in terms of name-value pairs.
122			*
123			* @return object the object itself
124			*/
125			public function configureObject($object, $properties) {
126			foreach ($properties as $name => $value) {
127			$object->$name = $value;
128			}
129
130			return $object;
131			}
132
133			/**
134			* @param string $definitionName class or name of definition in container
135			*
136			* @return array definition or empty array if definition not set.
137			*/
138			public function getDefinitionOf($definitionName) {
139			$definitions = $this->getDefinitions();
140
141			return isset($definitions[$definitionName]) ? $definitions[$definitionName] : [];
142			}
143
144			protected function runDecoratorsOnObject($decoratorsGroupName, $object) {
145			if (!$this->isDecoratorsGroupRegistered($decoratorsGroupName)) {
146			return;
147			}
148			foreach ($this->_decorators[$decoratorsGroupName] as &$decorator) {
149			if (is_callable($decorator)) {
150			call_user_func($decorator, $object);
151			continue;
152			}
153			if (!is_object($decorator)) {
154			$decorator = $this->create($decorator);
155			}
156			$decorator->decorate($object);
157			}
158			}
159
160			protected function isDecoratorsGroupRegistered($decoratorsGroup) {
161			$objectName = is_object($decoratorsGroup) ? get_class($decoratorsGroup) : $decoratorsGroup;
162
163			return isset($this->_decorators[$objectName]) && !empty($this->_decorators[$objectName]);
164			}
165
166			/**
167			* @param ServiceProvider $serviceProvider
168			*
169			* @throws InvalidConfigException
170			*/
171			protected function registerServiceProvider($serviceProvider) {
172			$serviceProvider = $this->ensureProviderIsObject($serviceProvider);
173
174			if (!($serviceProvider instanceof Contracts\ServiceProvider)) {
175			throw new InvalidConfigException('Service provider should be an instance of ' . ServiceProvider::class);
176			} elseif ($serviceProvider instanceof Contracts\DelayedServiceProvider) {
177			$this->addDelayedServiceProvider($serviceProvider);
178			} else {
179			$serviceProvider->register();
180			}
181			}
182
183			protected function addDelayedServiceProvider($provider) {
184			$this->delayedServiceProviders->attach($provider);
185			}
186
187			protected function ensureProviderIsObject($provider) {
188			if (!is_object($provider)) {
189			$provider = $this->create($provider);
190			}
191
192			return $provider;
193			}
194
195			//region ---------------------- SETTERS -------------------------------
196
197			public function setDecorators($name, array $decorators) {
198			foreach ($decorators as $decorator) {
199			$this->addDecorator($name, $decorator);
200			}
201			}
202
203			public function setServiceProviders(array $serviceProviders) {
204			foreach ($serviceProviders as $serviceProvider) {
205			$this->registerServiceProvider($serviceProvider);
206			}
207			}
208			//endregion
209			}

php-kitchen / yii2-di

Container::get() A last analyzed 2018-01-15 16:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Container::get() A
last analyzed 2018-01-15 16:03 UTC