DependencyContainer::handleReflectionParameter() - Code Metrics - Inspection of "unclutter method" - ppetermann/king23-di - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — develop (ff897e)

by Peter

created 2018-08-25 14:39 UTC

DependencyContainer::handleReflectionParameter() A

↳ Parent: DependencyContainer

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	9
cts	9
cp	1
rs	9.7333
c	0
b	0
f	0
cc	4
nc	4
nop	2
crap	4

<?php

namespace King23\DI;

use King23\DI\Exception\AlreadyRegisteredException;
use King23\DI\Exception\NotFoundException;

/**
 * Class DependencyContainer
 * @package King23\DI
 */
class DependencyContainer implements ContainerInterface
{
    protected $injectors = [];

    /**
     * Constructor
     */
    public function __construct()
    {
        $that = $this;
        // we register ourselves, so this container can be injected too
        /** @noinspection PhpUnhandledExceptionInspection */
        $this->register(
            ContainerInterface::class,
            function () use ($that) {
                return $that;
            }
        );
    }

    /**
     * check if for $interface there is an existing service to inject
     *
     * @param $interface
     * @return bool
     */
    protected function hasServiceFor($interface)
    {
        return isset($this->injectors[$interface]);
    }

    /**
     * gets a service instance for $interface - singletoned!
     *
     * @param string $interface
     * @return mixed
     */
    protected function getServiceInstanceFor($interface)
    {
        return $this->injectors[$interface]();
    }

    /**
     * register an service implementation as a singleton (shared instance)
     *
     * @param $interface
     * @param callable $implementation
     * @throws AlreadyRegisteredException
     */
    public function register($interface, callable $implementation)
    {
        if (isset($this->injectors[$interface])) {
            throw new AlreadyRegisteredException("Error: for $interface there is already an implementation registered");
        }

        // wraps the implementation in a singleton
        $this->injectors[$interface] = function () use ($implementation) {
            static $instance;
            if (is_null($instance)) {
                $instance = $implementation();
            }

            return $instance;
        };
    }

    /**
     * register a service implementation as a factory
     *
     * @param $interface
     * @param callable $implementation
     * @throws AlreadyRegisteredException
     */
    public function registerFactory($interface, callable $implementation)
    {
        if (isset($this->injectors[$interface])) {
            throw new AlreadyRegisteredException("Error: for $interface there is already an implementation registered");
        }

        $this->injectors[$interface] = $implementation;
    }

    /**
     * @param string $classname fully qualified classname
     * @return object
     * @throws NotFoundException
     * @throws \ReflectionException
     */
    public function get($classname)
    {
        // first we check if this is maybe a known service
        if ($this->hasServiceFor($classname)) {
            return $this->getServiceInstanceFor($classname);
        }

        // alright, this was not one of our known services, so we assume
        // we are supposed to play factory for $classname

        // lets see if the class actually exists first
        if (!class_exists($classname, true) && !interface_exists($classname, true)) {
            throw new NotFoundException("Class/Interface not found: '$classname'");
        }

        $reflector = new \ReflectionClass($classname);

        $args = [];

        $constructor = $reflector->getConstructor();

        // if there is no constructor, we don't need to inject anything
        if (!is_null($constructor)) {
            /** @var \ReflectionParameter $parameter */
            foreach ($constructor->getParameters() as $parameter) {
                $args[] = $this->handleReflectionParameter($parameter, $classname);
            }
        }

        if ($reflector->isInterface()) {
            throw new NotFoundException("no Injector registered for interface: '$classname'");
        }

        return $reflector->newInstanceArgs($args);
    }

    /**
     * Returns true if the container can return an entry for the given identifier.
     * Returns false otherwise.
     *
     * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
     * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
     *
     * @param string $id Identifier of the entry to look for.
     *
     * @return bool
     */
    public function has($id)
    {
        // if we have a service registered, we can assume true
        if($this->hasServiceFor($id)) {
            return true;
        }

        // if we don't have as service registered, we might still pull one from the hat
        // so lets at least check if the class would be available
        return class_exists($id, true);
    }

    /**
     * @param \ReflectionParameter $parameter
     * @param string $classname
     * @return mixed|object
     * @throws NotFoundException
     * @throws \ReflectionException
     */
    private function handleReflectionParameter(\ReflectionParameter $parameter, $classname)
    {
        try {
            if (is_null($parameter->getClass())) {
                throw new NotFoundException("parameters for constructor contains field without typehint");
            }
        } catch (\ReflectionException $reflectionException) {
            throw new NotFoundException("can't reflect parameter '{$parameter->name}' of '$classname'", 0, $reflectionException);
        }
        $paramClass = $parameter->getClass()->getName();

        if ($this->hasServiceFor($paramClass)) {
            return $this->getServiceInstanceFor($paramClass);
        } else {
            return $this->get($paramClass);
        }
    }
}


1		<?php
2
3		namespace King23\DI;
4
5		use King23\DI\Exception\AlreadyRegisteredException;
6		use King23\DI\Exception\NotFoundException;
7
8		/**
9		* Class DependencyContainer
10		* @package King23\DI
11		*/
12		class DependencyContainer implements ContainerInterface
13		{
14		protected $injectors = [];
15
16		/**
17		* Constructor
18		*/
19	10	public function __construct()
20		{
21	10	$that = $this;
22		// we register ourselves, so this container can be injected too
23		/** @noinspection PhpUnhandledExceptionInspection */
24	10	$this->register(
25	10	ContainerInterface::class,
26		function () use ($that) {
27	1	return $that;
28		}
29	10	);
30	10	}
31
32		/**
33		* check if for $interface there is an existing service to inject
34		*
35		* @param $interface
36		* @return bool
37		*/
38	8	protected function hasServiceFor($interface)
39		{
40	8	return isset($this->injectors[$interface]);
41		}
42
43		/**
44		* gets a service instance for $interface - singletoned!
45		*
46		* @param string $interface
47		* @return mixed
48		*/
49	4	protected function getServiceInstanceFor($interface)
50		{
51	4	return $this->injectors[$interface]();
52		}
53
54		/**
55		* register an service implementation as a singleton (shared instance)
56		*
57		* @param $interface
58		* @param callable $implementation
59		* @throws AlreadyRegisteredException
60		*/
61	10	public function register($interface, callable $implementation)
62		{
63	10	if (isset($this->injectors[$interface])) {
64	1	throw new AlreadyRegisteredException("Error: for $interface there is already an implementation registered");
65		}
66
67		// wraps the implementation in a singleton
68	3	$this->injectors[$interface] = function () use ($implementation) {
69	3	static $instance;
70	3	if (is_null($instance)) {
71	3	$instance = $implementation();
72	3	}
73
74	3	return $instance;
75		};
76	10	}
77
78		/**
79		* register a service implementation as a factory
80		*
81		* @param $interface
82		* @param callable $implementation
83		* @throws AlreadyRegisteredException
84		*/
85	2	public function registerFactory($interface, callable $implementation)
86		{
87	2	if (isset($this->injectors[$interface])) {
88	1	throw new AlreadyRegisteredException("Error: for $interface there is already an implementation registered");
89		}
90
91	1	$this->injectors[$interface] = $implementation;
92	1	}
93
94		/**
95		* @param string $classname fully qualified classname
96		* @return object
97		* @throws NotFoundException
98		* @throws \ReflectionException
99		*/
100	8	public function get($classname)
101		{
102		// first we check if this is maybe a known service
103	8	if ($this->hasServiceFor($classname)) {
104	1	return $this->getServiceInstanceFor($classname);
105		}
106
107		// alright, this was not one of our known services, so we assume
108		// we are supposed to play factory for $classname
109
110		// lets see if the class actually exists first
111	8	if (!class_exists($classname, true) && !interface_exists($classname, true)) {
112	1	throw new NotFoundException("Class/Interface not found: '$classname'");
113		}
114
115	7	$reflector = new \ReflectionClass($classname);
116
117	7	$args = [];
118
119	7	$constructor = $reflector->getConstructor();
120
121		// if there is no constructor, we don't need to inject anything
122	7	if (!is_null($constructor)) {
123		/** @var \ReflectionParameter $parameter */
124	7	foreach ($constructor->getParameters() as $parameter) {
125	7	$args[] = $this->handleReflectionParameter($parameter, $classname);
126	4	}
127	4	}
128
129	5	if ($reflector->isInterface()) {
130	1	throw new NotFoundException("no Injector registered for interface: '$classname'");
131		}
132
133	4	return $reflector->newInstanceArgs($args);
134		}
135
136		/**
137		* Returns true if the container can return an entry for the given identifier.
138		* Returns false otherwise.
139		*
140		* `has($id)` returning true does not mean that `get($id)` will not throw an exception.
141		* It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
142		*
143		* @param string $id Identifier of the entry to look for.
144		*
145		* @return bool
146		*/
147	6	public function has($id)
148		{
149		// if we have a service registered, we can assume true
150	6	if($this->hasServiceFor($id)) {
151	3	return true;
152		}
153
154		// if we don't have as service registered, we might still pull one from the hat
155		// so lets at least check if the class would be available
156	5	return class_exists($id, true);
157		}
158
159		/**
160		* @param \ReflectionParameter $parameter
161		* @param string $classname
162		* @return mixed\|object
163		* @throws NotFoundException
164		* @throws \ReflectionException
165		*/
166	7	private function handleReflectionParameter(\ReflectionParameter $parameter, $classname)
167		{
168		try {
169	7	if (is_null($parameter->getClass())) {
170	1	throw new NotFoundException("parameters for constructor contains field without typehint");
171		}
172	7	} catch (\ReflectionException $reflectionException) {
173	1	throw new NotFoundException("can't reflect parameter '{$parameter->name}' of '$classname'", 0, $reflectionException);
174		}
175	5	$paramClass = $parameter->getClass()->getName();
		1 ignored issue – show Bug introduced 2018-08-25 14:40 UTC by Report Bug Copy Issue Report Consider using `$parameter->getClass()->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
176	5	if ($this->hasServiceFor($paramClass)) {
177	4	return $this->getServiceInstanceFor($paramClass);
178		} else {
179	1	return $this->get($paramClass);
180		}
181		}
182		}
183

ppetermann / king23-di

Branch — develop (ff897e)

DependencyContainer::handleReflectionParameter() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like