Borobudur\DependencyInjection\Di

Complexity

Total Complexity

13

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	5
Bugs	1	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getContainer()	0	4	1
A	getInjector()	0	4	1
B	createInstance()	0	27	4
A	create()	0	4	1
A	call()	0	14	2
A	getServiceParameter()	0	11	2

<?php
/*
 * This file is part of the Borobudur-DependencyInjection package.
 *
 * (c) Hexacodelabs <http://hexacodelabs.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Borobudur\DependencyInjection;

use Borobudur\DependencyInjection\Exception\InvalidArgumentException;
use Borobudur\DependencyInjection\ParameterBag\Resolver;
use Closure;
use ReflectionClass;
use ReflectionFunction;
use ReflectionMethod;
use ReflectionParameter;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/8/15
 */
class Di
{
    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var Resolver
     */
    private $resolver;

    /**
     * @var Injector
     */
    private $injector;

    /**
     * Constructor.
     *
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container = null)
    {
        $this->container = $container ?: new Container(null, $this);
        $this->resolver = $this->container->getParameterBag()->getResolver();
        $this->injector = new Injector($this->container);
    }

    /**
     * Get container.
     *
     * @return Container|ContainerInterface
     */
    public function getContainer()
    {
        return $this->container;
    }

    /**
     * Get dependency injector.
     *
     * @return Injector
     */
    public function getInjector()
    {
        return $this->injector;
    }

    /**
     * Create and automatic resolve class to object.
     *
     * @param string $class
     * @param array  $arguments
     *
     * @return InstanceManager
     */
    public function createInstance($class, array $arguments = array())
    {
        if (!is_string($class)) {
            throw new InvalidArgumentException(sprintf('Class should be string, "%s" given.', gettype($class)));
        }

        $resolver = $this->resolver;
        $reflection = new ReflectionClass($resolver->resolveString($class));

        if (null !== $constructor = $reflection->getConstructor()) {
            $arguments = $resolver->unescapeValue($resolver->resolveValue($arguments));
            $parameters = $constructor->getParameters();
            $service = $reflection->newInstanceArgs($this->injector->replaceArguments(
                $parameters,
                $this->injector->resolveParameters($parameters),
                array_map(array($this->injector, 'getParameterValue'), $arguments)
            ));
        } else {
            $service = $reflection->newInstance();
        }

        if ($service instanceof ContainerAwareInterface) {
            $service->setContainer($this->container);
        }

        return $this->create($service);
    }

    /**
     * Create instance manager.
     *
     * @param object $service
     *
     * @return InstanceManager
     */
    public function create($service)
    {
        return new InstanceManager($this, $service);
    }

    /**
     * Call service.
     *
     * @param mixed $service
     * @param array $args
     *
     * @return mixed
     */
    public function call($service, array $args = array())
    {
        if (!is_callable($service)) {
            throw new InvalidArgumentException(sprintf('Service should be callable, "%s" given.', gettype($service)));
        }

        $parameters = $this->getServiceParameter($service);

        return call_user_func_array($service, $this->injector->replaceArguments(
            $parameters,
            $this->injector->resolveParameters($parameters),
            array_map(array($this->injector, 'getParameterValue'), $args)
        ));
    }

    /**
     * Get service parameter.
     *
     * @param mixed $service
     *
     * @return ReflectionParameter[]
     */
    private function getServiceParameter($service)
    {
        if ($service instanceof Closure) {
            $reflection = new ReflectionFunction($service);
            return $reflection->getParameters();
        }

        $reflection = new ReflectionMethod($service[0], $service[1]);

        return $reflection->getParameters();
    }
}