Container::loadComponent() - Code Metrics - Inspection of "fix DI" - linpax/microphp-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d16235...aff6da )

by Oleg

created 2016-04-22 17:46 UTC

Container::loadComponent() C

↳ Parent: Container

Complexity

Conditions	15
Paths	105

Size

Total Lines	51
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	2	Features	0

Metric	Value
c	3
b	2
f	0
dl	0
loc	51
rs	5.5168
cc	15
eloc	31
nc	105
nop	2

How to fix Long Method Complexity

<?php /** MicroContainer */

namespace Micro\Base;

/**
 * Container class file.
 *
 * @author Oleg Lunegov <[email protected]>
 * @link https://github.com/lugnsk/micro
 * @copyright Copyright &copy; 2013 Oleg Lunegov
 * @license /LICENSE
 * @package Micro
 * @subpackage Base
 * @version 1.0
 * @since 1.0
 */
class Container extends \stdClass implements IContainer
{
    /** @var array $data data */
    protected $data = [];
    /** @var array $config Configs */
    protected $config = [];
    /** @var array $components Components config */
    protected $components = [];


    /**
     * Load more configs from file
     *
     * @access public
     *
     * @param string $filename
     *
     * @return void
     */
    public function load($filename)
    {
        if (file_exists($filename)) {
            /** @noinspection PhpIncludeInspection */
            $this->config = array_merge_recursive($this->config, require $filename);
            $this->components = array_merge_recursive($this->components, $this->config['components']);
            unset($this->config['components']);
        }
    }

    /**
     * Is set component or option name into Container
     *
     * @access public
     *
     * @param string $name Name attribute
     *
     * @return bool
     */
    public function __isset($name)
    {
        if (array_key_exists($name, $this->config)) {
            return true;
        }
        if (array_key_exists($name, $this->data)) {
            return true;
        }
        if (array_key_exists($name, $this->components)) {
            return true;
        }

        return false;
    }

    /**
     * Get Container value
     *
     * @access public
     *
     * @param string $name element name
     *
     * @return mixed
     */
    public function __get($name = '')
    {
        if (!empty($this->config[$name])) {
            return $this->config[$name];
        }

        if (empty($this->data[$name]) && !$this->configure($name)) {
            return false;
        }

        return $this->data[$name];
    }

    /**
     * Set attribute
     *
     * @access public
     *
     * @param string $name Name attribute
     * @param mixed $component Component or option
     *
     * @return void
     */
    public function __set($name, $component)
    {
        $this->data[$name] = $component;
    }

    /**
     * Get component's
     *
     * @access public
     *
     * @param string|null $name name element to initialize
     *
     * @return bool
     */
    public function configure($name = null)
    {
        if (0 === count($this->components)) {
            return false;
        }

        if ($name === null) {
            foreach ($this->components AS $key => $options) {
                if (!$this->loadComponent($key, $options)) {
                    return false;
                }
            }

            return true;
        }

        if (empty($this->components[$name])) {
            return false;
        }

        if (!$this->loadComponent($name, $this->components[$name])) {
            return false;
        }

        return true;
    }

    /**
     * Load component
     *
     * @access public
     *
     * @param string $name component name
     * @param array $options component configs
     *
     * @return bool
     */
    public function loadComponent($name, $options)
    {
        if (empty($options['class']) || !class_exists($options['class'])) {
            return false;
        }

        $className = $options['class'];
        $this->data[$name] = null;

        $options['arguments'] = !empty($options['arguments']) ? $this->buildParams($options['arguments']) : null;
        $options['property'] = !empty($options['property']) ? $this->buildParams($options['property']) : null;
        $options['calls'] = !empty($options['calls']) ? $this->buildCalls($options['calls']) : null;

        try { // create object
            $reflection = new \ReflectionClass($className);
            $reflectionMethod = new \ReflectionMethod($className, '__construct');

            if ($reflectionMethod->getNumberOfParameters() === 0) {
                $this->data[$name] = new $className;
            } else {
                $this->data[$name] = $reflection->newInstanceArgs($options['arguments']);
            }

            unset($reflection, $reflectionMethod);
        } catch (Exception $e) {
            return false;
        }

        if (!empty($options['property'])) { // load properties
            foreach ($options['property'] as $property => $value) {
                if (property_exists($this->data[$name], $property)) {
                    $this->data[$name]->$property = $value;
                }
            }
        }

        if (!empty($options['calls'])) { // run methods
            foreach ($options['calls'] as $method => $arguments) {
                if (method_exists($this->data['name'], $method)) {
                    $reflectionMethod = new \ReflectionMethod($className, $method);
                    if ($reflectionMethod->getNumberOfParameters() === 0) {
                        $this->data['name']->$method();
                    } else {
                        call_user_func_array([$this->data['name'], $method], $arguments);
                    }
                }
            }
        }

        return true;
    }

    /**
     * Build calls arguments
     *
     * @access private
     * @param array $params
     * @return array
     */
    private function buildCalls(array $params)
    {
        $callers = [];

        if (!is_array($params[0])) {
            $params = [
                $params
            ];
        }

        foreach ($params as $arguments) {
            if (is_string($arguments[0])) {
                if (!empty($arguments[1]) && is_array($arguments[1])) {
                    $callers[$arguments[0]] = $this->buildParams($arguments[1]);
                } else {
                    $callers[$arguments[0]] = null;
                }
            }
        }

        return $callers;
    }

    /**
     * Build params from array
     *
     * @access private
     * @param array $params
     * @return array
     */
    private function buildParams(array $params)
    {
        /** @noinspection AlterInForeachInspection */
        foreach ($params AS $key => &$val) { // IoC Constructor
            if (is_string($params[$key]) && (0 === strpos($val, '@'))) {
                if ($val === '@this') {
                    $val = $this;
                } else {
                    if (null === $this->{substr($val, 1)}) {
                        return false;
                    }
                    $val = $this->{substr($val, 1)};
                }
            }
        }

        return $params;
    }
}


1			<?php /** MicroContainer */
2
3			namespace Micro\Base;
4
5			/**
6			* Container class file.
7			*
8			* @author Oleg Lunegov <[email protected]>
9			* @link https://github.com/lugnsk/micro
10			* @copyright Copyright © 2013 Oleg Lunegov
11			* @license /LICENSE
12			* @package Micro
13			* @subpackage Base
14			* @version 1.0
15			* @since 1.0
16			*/
17			class Container extends \stdClass implements IContainer
18			{
19			/** @var array $data data */
20			protected $data = [];
21			/** @var array $config Configs */
22			protected $config = [];
23			/** @var array $components Components config */
24			protected $components = [];
25
26
27			/**
28			* Load more configs from file
29			*
30			* @access public
31			*
32			* @param string $filename
33			*
34			* @return void
35			*/
36			public function load($filename)
37			{
38			if (file_exists($filename)) {
39			/** @noinspection PhpIncludeInspection */
40			$this->config = array_merge_recursive($this->config, require $filename);
41			$this->components = array_merge_recursive($this->components, $this->config['components']);
42			unset($this->config['components']);
43			}
44			}
45
46			/**
47			* Is set component or option name into Container
48			*
49			* @access public
50			*
51			* @param string $name Name attribute
52			*
53			* @return bool
54			*/
55			public function __isset($name)
56			{
57			if (array_key_exists($name, $this->config)) {
58			return true;
59			}
60			if (array_key_exists($name, $this->data)) {
61			return true;
62			}
63			if (array_key_exists($name, $this->components)) {
64			return true;
65			}
66
67			return false;
68			}
69
70			/**
71			* Get Container value
72			*
73			* @access public
74			*
75			* @param string $name element name
76			*
77			* @return mixed
78			*/
79			public function __get($name = '')
80			{
81			if (!empty($this->config[$name])) {
82			return $this->config[$name];
83			}
84
85			if (empty($this->data[$name]) && !$this->configure($name)) {
86			return false;
87			}
88
89			return $this->data[$name];
90			}
91
92			/**
93			* Set attribute
94			*
95			* @access public
96			*
97			* @param string $name Name attribute
98			* @param mixed $component Component or option
99			*
100			* @return void
101			*/
102			public function __set($name, $component)
103			{
104			$this->data[$name] = $component;
105			}
106
107			/**
108			* Get component's
109			*
110			* @access public
111			*
112			* @param string\|null $name name element to initialize
113			*
114			* @return bool
115			*/
116			public function configure($name = null)
117			{
118			if (0 === count($this->components)) {
119			return false;
120			}
121
122			if ($name === null) {
123			foreach ($this->components AS $key => $options) {
124			if (!$this->loadComponent($key, $options)) {
125			return false;
126			}
127			}
128
129			return true;
130			}
131
132			if (empty($this->components[$name])) {
133			return false;
134			}
135
136			if (!$this->loadComponent($name, $this->components[$name])) {
137			return false;
138			}
139
140			return true;
141			}
142
143			/**
144			* Load component
145			*
146			* @access public
147			*
148			* @param string $name component name
149			* @param array $options component configs
150			*
151			* @return bool
152			*/
153			public function loadComponent($name, $options)
154			{
155			if (empty($options['class']) \|\| !class_exists($options['class'])) {
156			return false;
157			}
158
159			$className = $options['class'];
160			$this->data[$name] = null;
161
162			$options['arguments'] = !empty($options['arguments']) ? $this->buildParams($options['arguments']) : null;
163			$options['property'] = !empty($options['property']) ? $this->buildParams($options['property']) : null;
164			$options['calls'] = !empty($options['calls']) ? $this->buildCalls($options['calls']) : null;
165
166			try { // create object
167			$reflection = new \ReflectionClass($className);
168			$reflectionMethod = new \ReflectionMethod($className, '__construct');
169
170			if ($reflectionMethod->getNumberOfParameters() === 0) {
171			$this->data[$name] = new $className;
172			} else {
173			$this->data[$name] = $reflection->newInstanceArgs($options['arguments']);
174			}
175
176			unset($reflection, $reflectionMethod);
177			} catch (Exception $e) {
178			return false;
179			}
180
181			if (!empty($options['property'])) { // load properties
182			foreach ($options['property'] as $property => $value) {
183			if (property_exists($this->data[$name], $property)) {
184			$this->data[$name]->$property = $value;
185			}
186			}
187			}
188
189			if (!empty($options['calls'])) { // run methods
190			foreach ($options['calls'] as $method => $arguments) {
191			if (method_exists($this->data['name'], $method)) {
192			$reflectionMethod = new \ReflectionMethod($className, $method);
193			if ($reflectionMethod->getNumberOfParameters() === 0) {
194			$this->data['name']->$method();
195			} else {
196			call_user_func_array([$this->data['name'], $method], $arguments);
197			}
198			}
199			}
200			}
201
202			return true;
203			}
204
205			/**
206			* Build calls arguments
207			*
208			* @access private
209			* @param array $params
210			* @return array
211			*/
212			private function buildCalls(array $params)
213			{
214			$callers = [];
215
216			if (!is_array($params[0])) {
217			$params = [
218			$params
219			];
220			}
221
222			foreach ($params as $arguments) {
223			if (is_string($arguments[0])) {
224			if (!empty($arguments[1]) && is_array($arguments[1])) {
225			$callers[$arguments[0]] = $this->buildParams($arguments[1]);
226			} else {
227			$callers[$arguments[0]] = null;
228			}
229			}
230			}
231
232			return $callers;
233			}
234
235			/**
236			* Build params from array
237			*
238			* @access private
239			* @param array $params
240			* @return array
241			*/
242			private function buildParams(array $params)
243			{
244			/** @noinspection AlterInForeachInspection */
245			foreach ($params AS $key => &$val) { // IoC Constructor
246			if (is_string($params[$key]) && (0 === strpos($val, '@'))) {
247			if ($val === '@this') {
248			$val = $this;
249			} else {
250			if (null === $this->{substr($val, 1)}) {
251			return false;
252			}
253			$val = $this->{substr($val, 1)};
254			}
255			}
256			}
257
258			return $params;
259			}
260			}
261

linpax / microphp-framework

Push — master ( d16235...aff6da )

Container::loadComponent() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like