DependencyInjection - Code Metrics - Inspection of "Merge pull request #4 from byjg/4.0.0" - byjg/config - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d7bbfe...68af3a )

by Joao

created 2020-07-13 03:22 UTC

DependencyInjection A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	296
Duplicated Lines	6.76 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
wmc	40
lcom	1
cbo	4
dl	20
loc	296
rs	9.2
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	injectContainer()	0	5	1
A	getClass()	0	4	1
A	setClass()	0	7	2
A	getArgs()	0	13	3
A	withConstructorArgs()	9	9	3
A	withFactoryMethod()	11	11	3
A	__construct()	0	4	1
A	bind()	0	4	1
A	withInjectedConstructor()	0	19	4
A	withInjectedLegacyConstructor()	0	25	4
A	withNoConstructor()	0	5	1
A	withMethodCall()	0	5	1
A	toSingleton()	0	5	1
A	toEagerSingleton()	0	6	1
A	toInstance()	0	5	1
A	getInstance()	0	10	2
A	getInternalInstance()	0	8	2
A	getNewInstance()	0	14	3
A	callMethods()	0	12	3
A	getSingletonInstace()	0	7	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DependencyInjection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DependencyInjection, and based on these observations, apply Extract Interface, too.

<?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 (is_null($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
     * @throws DependencyInjectionException
     * @throws ReflectionException
     */
    public function toEagerSingleton()
    {
        $this->singleton = true;
        $this->getInstance();
        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 (is_null($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		* @throws DependencyInjectionException
214		* @throws ReflectionException
215		*/
216		public function toEagerSingleton()
217		{
218		$this->singleton = true;
219		$this->getInstance();
220		return $this;
221		}
222
223		/**
224		* @return DependencyInjection
225		*/
226		public function toInstance()
227		{
228		$this->singleton = false;
229		return $this;
230		}
231
232		/**
233		* @return object
234		* @throws DependencyInjectionException
235		* @throws ReflectionException
236		*/
237		public function getInstance()
238		{
239		$instance = $this->getInternalInstance();
240
241		if (is_null($instance)) {
242		throw new DependencyInjectionException("Could not get a instance of " . $this->getClass());
243		}
244
245		return $instance;
246		}
247
248		/**
249		* @return object
250		* @throws ReflectionException
251		*/
252		protected function getInternalInstance()
253		{
254		if ($this->singleton) {
255		return $this->getSingletonInstace();
256		}
257
258		return $this->getNewInstance();
259		}
260
261		/**
262		* @return object
263		* @throws ReflectionException
264		*/
265		protected function getNewInstance()
266		{
267		if (!empty($this->factory)) {
268		return $this->callMethods(call_user_func_array([$this->getClass(), $this->factory], $this->getArgs()));
269		}
270
271		$reflectionClass = new ReflectionClass($this->getClass());
272
273		if (is_null($this->args)) {
274		return $this->callMethods($reflectionClass->newInstanceWithoutConstructor());
275		}
276
277		return $this->callMethods($reflectionClass->newInstanceArgs($this->getArgs()));
278		}
279
280		/**
281		* @param $instance
282		* @return mixed
283		*/
284		protected function callMethods($instance)
285		{
286		foreach ($this->methodCall as $methodDefinition) {
287		if (is_null($methodDefinition[1])) {
288		call_user_func([$instance, $methodDefinition[0]]);
289		} else {
290		call_user_func_array([$instance, $methodDefinition[0]], $methodDefinition[1]);
291		}
292		}
293
294		return $instance;
295		}
296
297		/**
298		* @return object
299		* @throws ReflectionException
300		*/
301		protected function getSingletonInstace()
302		{
303		if (empty($this->instance)) {
304		$this->instance = $this->getNewInstance();
305		}
306		return $this->instance;
307		}
308		}
309

byjg / config