DependencyInjection::__construct() - Code Metrics - Inspection of "Added Dependency Injection" - byjg/config - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

by Joao

created 2020-04-11 16:13 UTC

DependencyInjection::__construct() A

↳ Parent: DependencyInjection

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php


namespace ByJG\Config;

use ByJG\Config\Exception\DependencyInjectionException;
use ByJG\Config\Exception\KeyNotFoundException;
use Psr\Container\ContainerInterface;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;

class DependencyInjection
{
    /**
     * @var ContainerInterface
     */
    protected $containerInterface;

    protected $class;

    protected $args = [];

    protected $instance;

    protected $singleton = false;

    protected $factory = null;

    protected $methodCall = [];

    /**
     * @param $containerInterface ContainerInterface
     * @return DependencyInjection
     */
    public function injectContainer($containerInterface)
    {
        $this->containerInterface = $containerInterface;
        return $this;
    }

    /**
     * @return mixed
     */
    protected function getClass()
    {
        return $this->class;
    }

    /**
     * @param mixed $class
     * @throws DependencyInjectionException
     */
    protected function setClass($class)
    {
        if (!class_exists($class)) {
            throw new DependencyInjectionException("Class $class does not exists");
        }
        $this->class = $class;
    }

    /**
     * @return mixed
     */
    protected function getArgs()
    {
            return array_map(function ($value) {
                if ($value instanceof Param) {
                    try {
                        return $this->containerInterface->get($value->getParam());
                    } catch (KeyNotFoundException $ex) {
                        throw new KeyNotFoundException($ex->getMessage() . " injected from '" . $this->getClass() . "'");
                    }
                }
                return $value;
            }, $this->args);
    }

    /**
     * @param mixed $args
     * @return DependencyInjection
     * @throws DependencyInjectionException
     */
    public function withConstructorArgs($args)

    {
        if (!is_null($args) && !is_array($args)) {
            throw new DependencyInjectionException("Arguments should be an array");
        }
        $this->args = $args;
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}

        return $this;
    }

    /**
     * @param mixed $args
     * @return DependencyInjection
     * @throws DependencyInjectionException
     */
    public function withFactoryMethod($method, $args = [])

    {
        if (!is_null($args) && !is_array($args)) {
            throw new DependencyInjectionException("Arguments should be an array");
        }
        $this->args = $args;
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}

        $this->factory = $method;

        return $this;
    }

    /**
     * DependencyInjection constructor.
     * @param $class
     * @throws DependencyInjectionException
     */
    protected function __construct($class)
    {
        $this->setClass($class);
    }

    /**
     * @param $class
     * @return DependencyInjection
     * @throws DependencyInjectionException
     */
    public static function bind($class)
    {
        return new DependencyInjection($class);
    }

    /**
     * @return DependencyInjection
     * @throws DependencyInjectionException
     * @throws ReflectionException
     */
    public function withInjectedConstructor()
    {
        $reflection = new ReflectionMethod($this->getClass(), "__construct");
        $params = $reflection->getParameters();

        if (count($params) > 0) {
            $args = [];
            foreach ($params as $param) {
                $type = $param->getType();
                if (empty($type)) {
                    throw new DependencyInjectionException("The parameter '$" . $param->getName() . "' has no type defined in class '" . $this->getClass() . "'");

                }
                $args[] = Param::get(ltrim($type, "\\"));
            }
            return $this->withConstructorArgs($args);
        }

        return $this->withNoConstructor();
    }

    /**
     * @return DependencyInjection
     * @throws DependencyInjectionException
     * @throws ReflectionException
     */
    public function withInjectedLegacyConstructor()
    {
        $reflection = new ReflectionMethod($this->getClass(), "__construct");

        $docComments = str_replace("\n", " ", $reflection->getDocComment());

        $methodParams = $reflection->getParameters();

        $params = [];
        $result = preg_match_all('/@param\s+([\d\w_\\\\]+)\s+\$[\w_\d]+/', $docComments, $params);

        if (count($methodParams) <> $result) {
            throw new DependencyInjectionException("The class " . $this->getClass() . " does not have annotations with the param type.");
        }

        if (count($methodParams) > 0) {
            $args = [];
            foreach ($params[1] as $param) {
                $args[] = Param::get(ltrim($param, "\\"));
            }
            return $this->withConstructorArgs($args);
        }

        return $this->withNoConstructor();
    }

    /**
     * @return DependencyInjection
     */
    public function withNoConstructor()
    {
        $this->args = null;

        return $this;
    }

    public function withMethodCall($method, $args = [])
    {
        $this->methodCall[] = [$method, $args];
        return $this;
    }

    /**
     * @return DependencyInjection
     */
    public function toSingleton()
    {
        $this->singleton = true;
        return $this;
    }

    /**
     * @return DependencyInjection
     */
    public function toInstance()
    {
        $this->singleton = false;
        return $this;
    }

    /**
     * @return object
     * @throws DependencyInjectionException
     * @throws ReflectionException
     */
    public function getInstance()
    {
        $instance = $this->getInternalInstance();

        if (is_null($instance)) {
            throw new DependencyInjectionException("Could not get a instance of " . $this->getClass());
        }

        return $instance;
    }

    /**
     * @return object
     * @throws ReflectionException
     */
    protected function getInternalInstance()
    {
        if ($this->singleton) {
            return $this->getSingletonInstace();
        }

        return $this->getNewInstance();
    }

    /**
     * @return object
     * @throws ReflectionException
     */
    protected function getNewInstance()
    {
        if (!empty($this->factory)) {
            return $this->callMethods(call_user_func_array([$this->getClass(), $this->factory], $this->getArgs()));
        }

        $reflectionClass = new ReflectionClass($this->getClass());

        if (is_null($this->args)) {
            return $this->callMethods($reflectionClass->newInstanceWithoutConstructor());
        }

        return $this->callMethods($reflectionClass->newInstanceArgs($this->getArgs()));
    }

    /**
     * @param $instance
     * @return mixed
     */
    protected function callMethods($instance)
    {
        foreach ($this->methodCall as $methodDefinition) {
            if (is_null($methodDefinition[1])) {
                call_user_func([$instance, $methodDefinition[0]]);
            } else {
                call_user_func_array([$instance, $methodDefinition[0]], $methodDefinition[1]);
            }
        }

        return $instance;
    }

    /**
     * @return object
     * @throws ReflectionException
     */
    protected function getSingletonInstace()
    {
        if (empty($this->instance)) {
            $this->instance = $this->getNewInstance();
        }
        return $this->instance;
    }
}


1		<?php
2
3
4		namespace ByJG\Config;
5
6		use ByJG\Config\Exception\DependencyInjectionException;
7		use ByJG\Config\Exception\KeyNotFoundException;
8		use Psr\Container\ContainerInterface;
9		use ReflectionClass;
10		use ReflectionException;
11		use ReflectionMethod;
12
13		class DependencyInjection
14		{
15		/**
16		* @var ContainerInterface
17		*/
18		protected $containerInterface;
19
20		protected $class;
21
22		protected $args = [];
23
24		protected $instance;
25
26		protected $singleton = false;
27
28		protected $factory = null;
29
30		protected $methodCall = [];
31
32		/**
33		* @param $containerInterface ContainerInterface
34		* @return DependencyInjection
35		*/
36		public function injectContainer($containerInterface)
37		{
38		$this->containerInterface = $containerInterface;
39		return $this;
40		}
41
42		/**
43		* @return mixed
44		*/
45		protected function getClass()
46		{
47		return $this->class;
48		}
49
50		/**
51		* @param mixed $class
52		* @throws DependencyInjectionException
53		*/
54		protected function setClass($class)
55		{
56		if (!class_exists($class)) {
57		throw new DependencyInjectionException("Class $class does not exists");
58		}
59		$this->class = $class;
60		}
61
62		/**
63		* @return mixed
64		*/
65		protected function getArgs()
66		{
67		return array_map(function ($value) {
68		if ($value instanceof Param) {
69		try {
70		return $this->containerInterface->get($value->getParam());
71		} catch (KeyNotFoundException $ex) {
72		throw new KeyNotFoundException($ex->getMessage() . " injected from '" . $this->getClass() . "'");
73		}
74		}
75		return $value;
76		}, $this->args);
77		}
78
79		/**
80		* @param mixed $args
81		* @return DependencyInjection
82		* @throws DependencyInjectionException
83		*/
84	View Code Duplication	public function withConstructorArgs($args)
		0 ignored issues – show Duplication introduced 2020-04-11 03:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
85		{
86		if (!is_null($args) && !is_array($args)) {
87		throw new DependencyInjectionException("Arguments should be an array");
88		}
89		$this->args = $args;
		0 ignored issues – show Documentation Bug introduced 2020-04-11 01:27 UTC by Report Bug Copy Issue Report It seems like `$args` can be `null`. However, the property `$args` is declared as `array`. Maybe change the type of the property to `array\|null` or add a type check? Our type inference engine has found an assignment of a scalar value (like a string, an integer or null) to a property which is an array. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property. To type hint that a parameter can be either an array or null, you can set a type hint of array and a default value of null. The PHP interpreter will then accept both an array or null for that parameter. function aContainsB(array $needle = null, array $haystack) { if (!$needle) { return false; } return array_intersect($haystack, $needle) == $haystack; } The function can be called with either null or an array for the parameter `$needle` but will only accept an array as `$haystack`. Loading history...
90
91		return $this;
92		}
93
94		/**
95		* @param mixed $args
96		* @return DependencyInjection
97		* @throws DependencyInjectionException
98		*/
99	View Code Duplication	public function withFactoryMethod($method, $args = [])
		0 ignored issues – show Duplication introduced 2020-04-11 03:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
100		{
101		if (!is_null($args) && !is_array($args)) {
102		throw new DependencyInjectionException("Arguments should be an array");
103		}
104		$this->args = $args;
		0 ignored issues – show Documentation Bug introduced 2020-04-11 03:55 UTC by Report Bug Copy Issue Report It seems like `$args` can be `null`. However, the property `$args` is declared as `array`. Maybe change the type of the property to `array\|null` or add a type check? Our type inference engine has found an assignment of a scalar value (like a string, an integer or null) to a property which is an array. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property. To type hint that a parameter can be either an array or null, you can set a type hint of array and a default value of null. The PHP interpreter will then accept both an array or null for that parameter. function aContainsB(array $needle = null, array $haystack) { if (!$needle) { return false; } return array_intersect($haystack, $needle) == $haystack; } The function can be called with either null or an array for the parameter `$needle` but will only accept an array as `$haystack`. Loading history...
105
106		$this->factory = $method;
107
108		return $this;
109		}
110
111		/**
112		* DependencyInjection constructor.
113		* @param $class
114		* @throws DependencyInjectionException
115		*/
116		protected function __construct($class)
117		{
118		$this->setClass($class);
119		}
120
121		/**
122		* @param $class
123		* @return DependencyInjection
124		* @throws DependencyInjectionException
125		*/
126		public static function bind($class)
127		{
128		return new DependencyInjection($class);
129		}
130
131		/**
132		* @return DependencyInjection
133		* @throws DependencyInjectionException
134		* @throws ReflectionException
135		*/
136		public function withInjectedConstructor()
137		{
138		$reflection = new ReflectionMethod($this->getClass(), "__construct");
139		$params = $reflection->getParameters();
140
141		if (count($params) > 0) {
142		$args = [];
143		foreach ($params as $param) {
144		$type = $param->getType();
145		if (empty($type)) {
146		throw new DependencyInjectionException("The parameter '$" . $param->getName() . "' has no type defined in class '" . $this->getClass() . "'");
		0 ignored issues – show Bug introduced 2020-04-11 16:15 UTC by Report Bug Copy Issue Report Consider using `$param->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
147		}
148		$args[] = Param::get(ltrim($type, "\\"));
149		}
150		return $this->withConstructorArgs($args);
151		}
152
153		return $this->withNoConstructor();
154		}
155
156		/**
157		* @return DependencyInjection
158		* @throws DependencyInjectionException
159		* @throws ReflectionException
160		*/
161		public function withInjectedLegacyConstructor()
162		{
163		$reflection = new ReflectionMethod($this->getClass(), "__construct");
164
165		$docComments = str_replace("\n", " ", $reflection->getDocComment());
166
167		$methodParams = $reflection->getParameters();
168
169		$params = [];
170		$result = preg_match_all('/@param\s+([\d\w_\\\\]+)\s+\$[\w_\d]+/', $docComments, $params);
171
172		if (count($methodParams) <> $result) {
173		throw new DependencyInjectionException("The class " . $this->getClass() . " does not have annotations with the param type.");
174		}
175
176		if (count($methodParams) > 0) {
177		$args = [];
178		foreach ($params[1] as $param) {
179		$args[] = Param::get(ltrim($param, "\\"));
180		}
181		return $this->withConstructorArgs($args);
182		}
183
184		return $this->withNoConstructor();
185		}
186
187		/**
188		* @return DependencyInjection
189		*/
190		public function withNoConstructor()
191		{
192		$this->args = null;
		0 ignored issues – show Documentation Bug introduced 2020-04-11 01:27 UTC by Report Bug Copy Issue Report It seems like `null` of type `null` is incompatible with the declared type `array` of property `$args`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
193		return $this;
194		}
195
196		public function withMethodCall($method, $args = [])
197		{
198		$this->methodCall[] = [$method, $args];
199		return $this;
200		}
201
202		/**
203		* @return DependencyInjection
204		*/
205		public function toSingleton()
206		{
207		$this->singleton = true;
208		return $this;
209		}
210
211		/**
212		* @return DependencyInjection
213		*/
214		public function toInstance()
215		{
216		$this->singleton = false;
217		return $this;
218		}
219
220		/**
221		* @return object
222		* @throws DependencyInjectionException
223		* @throws ReflectionException
224		*/
225		public function getInstance()
226		{
227		$instance = $this->getInternalInstance();
228
229		if (is_null($instance)) {
230		throw new DependencyInjectionException("Could not get a instance of " . $this->getClass());
231		}
232
233		return $instance;
234		}
235
236		/**
237		* @return object
238		* @throws ReflectionException
239		*/
240		protected function getInternalInstance()
241		{
242		if ($this->singleton) {
243		return $this->getSingletonInstace();
244		}
245
246		return $this->getNewInstance();
247		}
248
249		/**
250		* @return object
251		* @throws ReflectionException
252		*/
253		protected function getNewInstance()
254		{
255		if (!empty($this->factory)) {
256		return $this->callMethods(call_user_func_array([$this->getClass(), $this->factory], $this->getArgs()));
257		}
258
259		$reflectionClass = new ReflectionClass($this->getClass());
260
261		if (is_null($this->args)) {
262		return $this->callMethods($reflectionClass->newInstanceWithoutConstructor());
263		}
264
265		return $this->callMethods($reflectionClass->newInstanceArgs($this->getArgs()));
266		}
267
268		/**
269		* @param $instance
270		* @return mixed
271		*/
272		protected function callMethods($instance)
273		{
274		foreach ($this->methodCall as $methodDefinition) {
275		if (is_null($methodDefinition[1])) {
276		call_user_func([$instance, $methodDefinition[0]]);
277		} else {
278		call_user_func_array([$instance, $methodDefinition[0]], $methodDefinition[1]);
279		}
280		}
281
282		return $instance;
283		}
284
285		/**
286		* @return object
287		* @throws ReflectionException
288		*/
289		protected function getSingletonInstace()
290		{
291		if (empty($this->instance)) {
292		$this->instance = $this->getNewInstance();
293		}
294		return $this->instance;
295		}
296		}
297

byjg / config

Pull Request — master (#4)

DependencyInjection::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like