Factory::afterCreation() - Code Metrics - Inspection of "adjustment" - phossa2/di - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 84f915...15625b )

by Hong

created 2016-07-17 22:15 UTC

Factory::afterCreation() A

↳ Parent: Factory

Complexity

Conditions	4
Paths	4

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	13
rs	9.2
cc	4
eloc	6
nc	4
nop	2

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Di
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Di\Factory;

use Phossa2\Di\Message\Message;
use Phossa2\Di\Resolver\ObjectResolver;
use Phossa2\Shared\Base\ObjectAbstract;
use Phossa2\Di\Exception\LogicException;
use Phossa2\Di\Traits\ResolverAwareTrait;
use Phossa2\Di\Interfaces\FactoryInterface;
use Phossa2\Di\Interfaces\ResolverInterface;

/**
 * Factory
 *
 * Wrapper of factorying methods for container
 *
 * @package Phossa2\Di
 * @author  Hong Zhang <[email protected]>
 * @see     FactoryInterface
 * @version 2.0.0
 * @since   2.0.0 added
 */
class Factory extends ObjectAbstract implements FactoryInterface
{
    use ResolverAwareTrait, FactoryHelperTrait;

    /**
     * @param  ResolverInterface
     * @access public
     */
    public function __construct(ResolverInterface $resolver)
    {
        $this->setResolver($resolver);
    }

    /**
     * {@inheritDoc}
     */
    public function createInstance(/*# string */ $rawId, array $arguments)
    {
        // get service definition
        $def = $this->getDefinition($rawId, $arguments);

        // arguments
        $args = isset($def['args']) ? $def['args'] : [];

        if (is_string($def['class'])) {
            $obj = $this->constructObject($def['class'], $args);

        } else {
            $obj = $this->executeCallable($def['class'], $args);
        }

        // execute after-creation methods
        $this->afterCreation($obj, $def);

        return $obj;
    }

    /**
     * {@inheritDoc}
     */
    public function executeCallable($callable, array $arguments = [])
    {
        // not callable
        if (!is_callable($callable)) {
            return $callable;
        }

        if (!empty($arguments)) {
            $params = $this->getCallableParameters($callable);
            $args = $this->matchArguments($params, $arguments);
            return call_user_func_array($callable, $args);
        } else {
            return call_user_func($callable);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function executeMethodBatch(array $methods, $object = null)
    {
        foreach ($this->mergeMethods($methods) as $method) {
            $this->executeMethod($method, $object);
        }
    }

    /**
     * if $object provided, build callable like [$object, $method] and execute it.
     *
     * method:
     *
     * - callable
     *
     * - array ['function', [ arguments...]]
     *
     * - array [callable, [ arguments ...]]
     *
     * - array ['method', [ arguments ...]]
     *   will be converted to [[$object, 'method'], [ ... ]]
     *
     * @param  array|callable method
     * @param  object|null $object to construct callable
     * @throws LogicException if something goes wrong
     * @access protected
     */
    protected function executeMethod($method, $object = null)
    {
        // is callable
        if (is_callable($method)) {
            return $this->executeCallable($method);

        // is [ method, arguments ]
        } elseif (isset($method[0])) {
            return $this->executeCallable(
                $this->getObjectMethod($object, $method[0]), // callable
                isset($method[1]) ? $method[1] : [] // arguments
            );
        }
    }

    /**
     * Things to do after an object created.
     *
     * @param  object $object
     * @param  array $definition service definition for $object
     * @access protected
     */
    protected function afterCreation($object, array $definition)
    {
        // execute methods of THIS object
        if (isset($definition['methods'])) {
            $this->executeMethodBatch($definition['methods'], $object);
        }

        // execute common methods for all objects
        if (!isset($definition['skip']) || !$definition['skip']) {
            $methods = $this->getCommonMethods();
            $this->executeMethodBatch($methods, $object);
        }
    }

    /**
     * Get common methods
     *
     * @return array
     * @access protected
     */
    protected function getCommonMethods()/*# : array */
    {
        // di.common node
        $commNode = $this->getResolver()->getSectionId('', 'common');

        return $this->mergeMethods(
            $this->getResolver()->get($commNode)
        );
    }

    /**
     * Merge different sections of a node
     *
     * convert
     *   `['section1' => [[1], [2]], 'section2' => [[3], [4]]]`
     *
     * to
     *   `[[1], [2], [3], [4]]`
     *
     * @param  array|null $nodeData
     * @return array
     * @access protected
     */
    protected function mergeMethods($nodeData)/*# : array */
    {
        // no merge
        if (empty($nodeData) || isset($nodeData[0])) {
            return (array) $nodeData;
        }

        // in sections
        $result = [];
        foreach ($nodeData as $data) {
            $result = array_merge($result, $data);
        }
        return $result;
    }

    /**
     * Returns [$object, $method] if it is a callable, otherwise returns $method
     *
     * @param  mixed $object
     * @param  mixed $method
     * @return bool
     * @access protected
     */
    protected function getObjectMethod($object, $method)/*# : bool */
    {
        if (is_string($method) && method_exists($object, $method)) {
            return [$object, $method];
        } elseif (is_callable($method)) {
            return $method;
        } else {
            throw new LogicException(
                Message::get(Message::DI_CALLABLE_BAD, $method),
                Message::DI_CALLABLE_BAD
            );
        }
    }

    /**
     * Get service definition
     *
     * @param  string $rawId
     * @param  array $args
     * @return array
     * @access protected
     */
    protected function getDefinition(
        /*# string */ $rawId,
        array $args
    )/*# : array */ {
        // get the definition
        $def = $this->getResolver()->getService($rawId);

        // fix class
        if (!is_array($def) || !isset($def['class'])) {
            $def = ['class' => $def];
        }

        // add arguments
        if (!empty($args)) {
            $def['args'] = $args;
        }

        return (array) $def;
    }

    /**
     * Get an object base on provided classname or interface name
     *
     * @param  string $classname class or interface name
     * @return object
     * @throws \Exception if something goes wrong
     * @access protected
     */
    protected function getObjectByClass(/*# string */ $classname)
    {
        if ($this->getResolver()->hasService($classname)) {
            $serviceId = ObjectResolver::getServiceId($classname);
            return $this->getResolver()->get($serviceId);
        }
        throw new LogicException(
            Message::get(Message::DI_CLASS_UNKNOWN, $classname),
            Message::DI_CLASS_UNKNOWN
            );
    }
}


1			<?php
2			/**
3			* Phossa Project
4			*
5			* PHP version 5.4
6			*
7			* @category Library
8			* @package Phossa2\Di
9			* @copyright Copyright (c) 2016 phossa.com
10			* @license http://mit-license.org/ MIT License
11			* @link http://www.phossa.com/
12			*/
13			/# declare(strict_types=1); /
14
15			namespace Phossa2\Di\Factory;
16
17			use Phossa2\Di\Message\Message;
18			use Phossa2\Di\Resolver\ObjectResolver;
19			use Phossa2\Shared\Base\ObjectAbstract;
20			use Phossa2\Di\Exception\LogicException;
21			use Phossa2\Di\Traits\ResolverAwareTrait;
22			use Phossa2\Di\Interfaces\FactoryInterface;
23			use Phossa2\Di\Interfaces\ResolverInterface;
24
25			/**
26			* Factory
27			*
28			* Wrapper of factorying methods for container
29			*
30			* @package Phossa2\Di
31			* @author Hong Zhang <[email protected]>
32			* @see FactoryInterface
33			* @version 2.0.0
34			* @since 2.0.0 added
35			*/
36			class Factory extends ObjectAbstract implements FactoryInterface
37			{
38			use ResolverAwareTrait, FactoryHelperTrait;
39
40			/**
41			* @param ResolverInterface
42			* @access public
43			*/
44			public function __construct(ResolverInterface $resolver)
45			{
46			$this->setResolver($resolver);
47			}
48
49			/**
50			* {@inheritDoc}
51			*/
52			public function createInstance(/# string / $rawId, array $arguments)
53			{
54			// get service definition
55			$def = $this->getDefinition($rawId, $arguments);
56
57			// arguments
58			$args = isset($def['args']) ? $def['args'] : [];
59
60			if (is_string($def['class'])) {
61			$obj = $this->constructObject($def['class'], $args);
62
63			} else {
64			$obj = $this->executeCallable($def['class'], $args);
65			}
66
67			// execute after-creation methods
68			$this->afterCreation($obj, $def);
69
70			return $obj;
71			}
72
73			/**
74			* {@inheritDoc}
75			*/
76			public function executeCallable($callable, array $arguments = [])
77			{
78			// not callable
79			if (!is_callable($callable)) {
80			return $callable;
81			}
82
83			if (!empty($arguments)) {
84			$params = $this->getCallableParameters($callable);
85			$args = $this->matchArguments($params, $arguments);
86			return call_user_func_array($callable, $args);
87			} else {
88			return call_user_func($callable);
89			}
90			}
91
92			/**
93			* {@inheritDoc}
94			*/
95			public function executeMethodBatch(array $methods, $object = null)
96			{
97			foreach ($this->mergeMethods($methods) as $method) {
98			$this->executeMethod($method, $object);
99			}
100			}
101
102			/**
103			* if $object provided, build callable like [$object, $method] and execute it.
104			*
105			* method:
106			*
107			* - callable
108			*
109			* - array ['function', [ arguments...]]
110			*
111			* - array [callable, [ arguments ...]]
112			*
113			* - array ['method', [ arguments ...]]
114			* will be converted to [[$object, 'method'], [ ... ]]
115			*
116			* @param array\|callable method
117			* @param object\|null $object to construct callable
118			* @throws LogicException if something goes wrong
119			* @access protected
120			*/
121			protected function executeMethod($method, $object = null)
122			{
123			// is callable
124			if (is_callable($method)) {
125			return $this->executeCallable($method);
126
127			// is [ method, arguments ]
128			} elseif (isset($method[0])) {
129			return $this->executeCallable(
130			$this->getObjectMethod($object, $method[0]), // callable
131			isset($method[1]) ? $method[1] : [] // arguments
132			);
133			}
134			}
135
136			/**
137			* Things to do after an object created.
138			*
139			* @param object $object
140			* @param array $definition service definition for $object
141			* @access protected
142			*/
143			protected function afterCreation($object, array $definition)
144			{
145			// execute methods of THIS object
146			if (isset($definition['methods'])) {
147			$this->executeMethodBatch($definition['methods'], $object);
148			}
149
150			// execute common methods for all objects
151			if (!isset($definition['skip']) \|\| !$definition['skip']) {
152			$methods = $this->getCommonMethods();
153			$this->executeMethodBatch($methods, $object);
154			}
155			}
156
157			/**
158			* Get common methods
159			*
160			* @return array
161			* @access protected
162			*/
163			protected function getCommonMethods()/# : array /
164			{
165			// di.common node
166			$commNode = $this->getResolver()->getSectionId('', 'common');
167
168			return $this->mergeMethods(
169			$this->getResolver()->get($commNode)
170			);
171			}
172
173			/**
174			* Merge different sections of a node
175			*
176			* convert
177			* `['section1' => [[1], [2]], 'section2' => [[3], [4]]]`
178			*
179			* to
180			* `[[1], [2], [3], [4]]`
181			*
182			* @param array\|null $nodeData
183			* @return array
184			* @access protected
185			*/
186			protected function mergeMethods($nodeData)/# : array /
187			{
188			// no merge
189			if (empty($nodeData) \|\| isset($nodeData[0])) {
190			return (array) $nodeData;
191			}
192
193			// in sections
194			$result = [];
195			foreach ($nodeData as $data) {
196			$result = array_merge($result, $data);
197			}
198			return $result;
199			}
200
201			/**
202			* Returns [$object, $method] if it is a callable, otherwise returns $method
203			*
204			* @param mixed $object
205			* @param mixed $method
206			* @return bool
207			* @access protected
208			*/
209			protected function getObjectMethod($object, $method)/# : bool /
210			{
211			if (is_string($method) && method_exists($object, $method)) {
212			return [$object, $method];
213			} elseif (is_callable($method)) {
214			return $method;
215			} else {
216			throw new LogicException(
217			Message::get(Message::DI_CALLABLE_BAD, $method),
218			Message::DI_CALLABLE_BAD
219			);
220			}
221			}
222
223			/**
224			* Get service definition
225			*
226			* @param string $rawId
227			* @param array $args
228			* @return array
229			* @access protected
230			*/
231			protected function getDefinition(
232			/# string / $rawId,
233			array $args
234			)/# : array / {
235			// get the definition
236			$def = $this->getResolver()->getService($rawId);
237
238			// fix class
239			if (!is_array($def) \|\| !isset($def['class'])) {
240			$def = ['class' => $def];
241			}
242
243			// add arguments
244			if (!empty($args)) {
245			$def['args'] = $args;
246			}
247
248			return (array) $def;
249			}
250
251			/**
252			* Get an object base on provided classname or interface name
253			*
254			* @param string $classname class or interface name
255			* @return object
256			* @throws \Exception if something goes wrong
257			* @access protected
258			*/
259			protected function getObjectByClass(/# string / $classname)
260			{
261			if ($this->getResolver()->hasService($classname)) {
262			$serviceId = ObjectResolver::getServiceId($classname);
263			return $this->getResolver()->get($serviceId);
264			}
265			throw new LogicException(
266			Message::get(Message::DI_CLASS_UNKNOWN, $classname),
267			Message::DI_CLASS_UNKNOWN
268			);
269			}
270			}
271

phossa2 / di

GitHub Access Token became invalid

Push — master ( 84f915...15625b )

Factory::afterCreation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like