Phossa2\Di\Factory\Factory

Complexity

Total Complexity

31

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	5
Bugs	1	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createInstance()	0	20	3
A	executeCallable()	0	15	3
A	executeMethodBatch()	0	6	2
A	executeMethod()	0	14	4
A	afterCreation()	0	12	4
A	executeCommonBatch()	0	11	3
A	getCommonMethods()	0	19	3
A	mergeMethods()	0	14	4
A	getObjectMethod()	0	13	4

<?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\Container;
use Phossa2\Di\Message\Message;
use Phossa2\Di\Traits\FactoryTrait;
use Phossa2\Shared\Base\ObjectAbstract;
use Phossa2\Di\Exception\LogicException;
use Phossa2\Di\Interfaces\FactoryInterface;

/**
 * Factory
 *
 * Wrapper of factorying methods for container
 *
 * @package Phossa2\Di
 * @author  Hong Zhang <phossa@126.com>
 * @see     FactoryInterface
 * @version 2.0.0
 * @since   2.0.0 added
 */
class Factory extends ObjectAbstract implements FactoryInterface
{
    use FactoryTrait;

    /**
     * @param  Container $container
     * @access public
     */
    public function __construct(Container $container)
    {
        $this->master = $container;
    }

    /**
     * {@inheritDoc}
     */
    public function createInstance(/*# string */ $rawId, array $arguments)
    {
        // get resolved 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']) {
            $this->executeCommonBatch($object);
        }
    }

    /**
     * Execute common methods defined in 'di.common' for all objects
     *
     * Methods are in the form of
     *
     *   [ interfaceOrClassname, [methodOrCallable, ArgumentsArray]],
     *   [ testCallable($obj, $container), [methodOrCallable, ArgumentsArray],
     *   ...
     *
     * @param  object $object
     * @return $this
     * @access protected
     */
    protected function executeCommonBatch($object)
    {
        foreach ($this->getCommonMethods() as $method) {
            $tester = $method[0];
            $runner = $method[1];
            if (call_user_func_array($tester, [$object, $this->master])) {
                $this->executeMethod($runner, $object);
            }
        }
        return $this;
    }

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

        // fix tester
        foreach ($methods as $i => $pair) {
            if (is_string($pair[0])) {
                $tester = $pair[0];
                $methods[$i][0] = function($obj) use ($tester) {
                    return is_a($obj, $tester);
                };
            }
        }

        return $methods;
    }

    /**
     * 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
            );
        }
    }
}