Borobudur\DependencyInjection\ContainerBuilder

Complexity

Total Complexity

33

Size/Duplication

Total Lines	319
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Importance

Changes	14
Bugs	5	Features	7

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	replaceDefinition()	0	6	1
A	addDefinition()	0	8	2
A	setDefinition()	0	13	2
A	set()	0	11	2
A	has()	0	8	2
A	hasDefinition()	0	4	1
A	getDefinition()	0	10	2
A	get()	0	20	4
A	register()	0	12	3
A	createService()	0	12	1
A	load()	0	4	1
A	addTag()	0	4	1
A	registerDefinition()	0	15	2
A	assertImplementAbstract()	0	12	3
A	removeAlias()	0	11	3
A	setAlias()	0	13	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\ImmutableParameterException;
use Borobudur\DependencyInjection\Exception\InvalidArgumentException;
use Borobudur\DependencyInjection\ParameterBag\ParameterBagInterface;
use Borobudur\DependencyInjection\Tag\TagInterface;
use Borobudur\DependencyInjection\Tag\TagProcessor;

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/8/15
 */
class ContainerBuilder extends Container
{
    /**
     * @var Definition[]
     */
    private $definitions = array();

    /**
     * @var array
     */
    private $lockAlias = array();

    /**
     * @var ArrayServiceLoader
     */
    private $arrayLoader;

    /**
     * @var TagProcessor
     */
    private $tagProcessor;

    /**
     * Constructor.
     *
     * @param ParameterBagInterface|null $parameterBag
     * @param Di|null                    $di
     */
    public function __construct(ParameterBagInterface $parameterBag = null, Di $di = null)
    {
        parent::__construct($parameterBag, $di);
        $this->arrayLoader = new ArrayServiceLoader($this);
        $this->tagProcessor = new TagProcessor($this);
    }

    /**
     * Clear and replace with sets of definitions.
     *
     * @param array $definitions
     *
     * @return static
     */
    public function replaceDefinition(array $definitions)
    {
        $this->definitions = array();

        return $this->addDefinition($definitions);
    }

    /**
     * Add sets of definition.
     *
     * @param array $definitions
     *
     * @return static
     */
    public function addDefinition(array $definitions)
    {
        foreach ($definitions as $id => $definition) {
            $this->setDefinition($id, $definition);
        }

        return $this;
    }

    /**
     * Set a service definition.
     *
     * @param string     $id
     * @param Definition $definition
     *
     * @return Definition
     */
    public function setDefinition($id, Definition $definition)
    {
        if ($this->isImmutable()) {
            throw new ImmutableParameterException('setDefinition');
        }

        $id = strtolower($id);

        $this->setAlias($id, $definition);
        $this->tagProcessor->process($id, $definition->getTags());

        return $this->definitions[$id] = $definition;
    }

    /**
     * Set service.
     *
     * @param string $id
     * @param mixed  $service
     */
    public function set($id, $service)
    {
        $id = strtolower($id);

        if (isset($this->definitions[$id])) {
            unset($this->definitions[$id]);
        }

        $this->removeAlias($id);
        parent::set($id, $service);
    }

    /**
     * {@inheritdoc}
     */
    public function has($id)
    {
        if (false === parent::has($id)) {
            return $this->hasDefinition($id);
        }

        return true;
    }

    /**
     * Check if definition exists.
     *
     * @param string $id
     *
     * @return bool
     */
    public function hasDefinition($id)
    {
        return array_key_exists(strtolower($id), $this->definitions);
    }

    /**
     * Get definition.
     *
     * @param string $id
     *
     * @return Definition
     */
    public function getDefinition($id)
    {
        $id = strtolower($id);

        if (!array_key_exists($id, $this->definitions)) {
            throw new InvalidArgumentException(sprintf('Service definition "%s" is not defined.', $id));
        }

        return $this->definitions[$id];
    }

    /**
     * Get service.
     *
     * @param string $id
     * @param array  $args
     * @param int    $invalidBehavior
     *
     * @return mixed|object|null
     */
    public function get($id, array $args = array(), $invalidBehavior = self::EXCEPTION_ON_INVALID_REFERENCE)
    {
        if (null !== $service = parent::get($id, $args, self::NULL_ON_INVALID_REFERENCE)) {
            return $service;
        }

        $id = $this->getServiceId($id);

        try {
            $definition = $this->getDefinition($id);
        } catch (InvalidArgumentException $e) {
            if (self::NULL_ON_INVALID_REFERENCE === $invalidBehavior) {
                return null;
            }

            throw $e;
        }

        return $this->registerDefinition($id, $definition, $args);
    }

    /**
     * Register service and map class alias if service is object.
     *
     * @param string $id
     * @param mixed  $service
     * @param bool   $shared
     */
    public function register($id, $service, $shared = false)
    {
        if (true === $shared) {
            $this->share($id, $service);
        } else {
            $this->set($id, $service);
        }

        if (is_object($service)) {
            $this->setDefinition($id, new Definition(get_class($service)));
        }
    }

    /**
     * Create service.
     *
     * @param Definition $definition
     * @param array      $args
     *
     * @return InstanceManager
     */
    public function createService(Definition $definition, array $args = array())
    {
        $instance = $this->getDi()->createInstance(
            $definition->getClass(),
            array_merge($definition->getArgument()->all(), $args)
        );

        $instance->callMethods($definition->getMethodCall()->all());
        $instance->setProperties($definition->getProperty()->all());

        return $instance;
    }

    /**
     * Load services from array.
     *
     * @param array $services
     */
    public function load(array $services)
    {
        $this->arrayLoader->load($services);
    }

    /**
     * Add a tag.
     *
     * @param TagInterface $tag
     */
    public function addTag(TagInterface $tag)
    {
        $this->tagProcessor->add($tag);
    }

    /**
     * Register service definition.
     *
     * @param string     $id
     * @param Definition $definition
     * @param array      $args
     *
     * @return object
     */
    private function registerDefinition($id, Definition $definition, array $args = array())
    {
        $instance = $this->createService($definition, $args);
        $service = $instance->getOriginalInstance();

        if ($definition->isShared()) {
            $this->share($id, $service);
        } else {
            unset($this->lockAlias[$id]);
        }

        $this->assertImplementAbstract($definition, $service);

        return $service;
    }

    /**
     * Assert that service implement abstract.
     *
     * @param Definition $definition
     * @param mixed      $service
     */
    private function assertImplementAbstract(Definition $definition, $service)
    {
        if ($definition->isAbstract()
            && !in_array(ltrim($definition->getAbstract(), '\\'), class_implements($service))
        ) {
            throw new InvalidArgumentException(sprintf(
                'Class "%s" not implement "%s".',
                get_class($service),
                $definition->getAbstract()
            ));
        }
    }

    /**
     * Fix alias.
     *
     * @param string $id
     */
    private function removeAlias($id)
    {
        if (null !== ($alias = $this->getAliasFromId($id)) && !isset($this->lockAlias[$id])) {
            $index = array_search($id, $this->aliases[$alias]);
            unset($this->aliases[$alias][$index]);
            // re-index
            $this->aliases[$alias] = array_values($this->aliases[$alias]);
        }

        unset($this->lockAlias[$id]);
    }

    /**
     * Register abstract definition if possible.
     *
     * @param string     $id
     * @param Definition $definition
     */
    private function setAlias($id, Definition $definition)
    {
        if ($definition->isAbstract()) {
            $class = $definition->getAbstract();
        } else {
            $class = $definition->getClass();
        }

        $class = '\\' . ltrim($class, '\\');

        $this->aliases[$class][] = $id;
        $this->lockAlias[$id] = true;
    }
}