Borobudur\DependencyInjection\InstanceManager

Complexity

Total Complexity

16

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	5

Importance

Changes	4
Bugs	1	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	4
A	getOriginalInstance()	0	4	1
A	getReflection()	0	4	1
A	getMethods()	0	4	1
A	getConstructorArguments()	0	6	1
A	getMethodArguments()	0	6	1
A	setProperties()	0	8	2
A	setProperty()	0	6	1
A	callMethods()	0	11	3
A	callMethod()	0	4	1

<?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 ReflectionClass;
use ReflectionMethod;
use ReflectionParameter;

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

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

    /**
     * @var object
     */
    private $service;

    /**
     * @var ReflectionClass
     */
    private $reflection;

    /**
     * Constructor.
     *
     * @param Di    $di
     * @param mixed $service
     */
    public function __construct(Di $di, $service)
    {
        if (is_callable($service) || !is_object($service)) {
            throw new InvalidArgumentException(sprintf(
                'Service should be object, "%s" given.',
                is_callable($service) ? 'callable' : gettype($service)
            ));
        }

        $this->di = $di;
        $this->resolver = $di->getContainer()->getParameterBag()->getResolver();
        $this->service = $service;
        $this->reflection = new ReflectionClass(get_class($service));
    }

    /**
     * Get original service.
     *
     * @return object
     */
    public function getOriginalInstance()
    {
        return $this->service;
    }

    /**
     * Get instance reflection.
     *
     * @return ReflectionClass
     */
    public function getReflection()
    {
        return $this->reflection;
    }

    /**
     * Get instance methods.
     *
     * @param int|null $filter
     *
     * @return ReflectionMethod[]
     */
    public function getMethods($filter = null)
    {
        return $this->reflection->getMethods($filter);
    }

    /**
     * Get constructor arguments.
     *
     * @return ReflectionParameter[]
     */
    public function getConstructorArguments()
    {
        $constructor = $this->reflection->getConstructor();

        return $constructor->getParameters();
    }

    /**
     * @param $method
     *
     * @return ReflectionParameter[]
     */
    public function getMethodArguments($method)
    {
        $method = $this->reflection->getMethod($method);

        return $method->getParameters();
    }

    /**
     * Set sets of properties.
     *
     * @param array $properties
     *
     * @return static
     */
    public function setProperties(array $properties)
    {
        foreach ($properties as $property => $value) {
            $this->setProperty($property, $value);
        }

        return $this;
    }

    /**
     * Set property to service.
     *
     * @param string $property
     * @param mixed  $value
     *
     * @return static
     */
    public function setProperty($property, $value)
    {
        $this->service->{$property} = $this->resolver->resolveValue($value);

        return $this;
    }

    /**
     * Call sets of method.
     *
     * @param array $methods
     *
     * @return array
     */
    public function callMethods(array $methods)
    {
        $results = array();
        foreach ($methods as $call) {
            if (2 === count($call)) {
                $results[] = $this->callMethod($call[0], (array) $call[1]);
            }
        }

        return $results;
    }

    /**
     * Call method with auto resolution.
     *
     * @param string $method
     * @param array  $arguments
     *
     * @return mixed
     */
    public function callMethod($method, array $arguments = array())
    {
        return $this->di->call(array($this->service, $method), $arguments);
    }
}