Slick\Di\Container

Complexity

Total Complexity

29

Size/Duplication

Total Lines	279
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	get()	0	9	3
A	has()	0	8	2
A	register()	0	15	2
A	parentHas()	0	7	2
A	resolve()	0	13	3
A	registerEntry()	0	8	2
A	add()	0	10	2
A	createDefinition()	0	9	2
A	createValueDefinition()	0	8	3
A	make()	0	14	2
A	setHydrator()	0	5	1
A	getHydrator()	0	7	2
A	parent()	0	4	1

<?php

/**
 * This file is part of slick/di package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Di;

use Interop\Container\Exception\ContainerException;
use Slick\Di\Definition\Alias;
use Slick\Di\Definition\Factory;
use Slick\Di\Definition\ObjectDefinition;
use Slick\Di\Definition\Scope;
use Slick\Di\Definition\Value;
use Slick\Di\Exception\NotFoundException;

/**
 * Container
 *
 * @package Slick\Di
 * @author  Filipe Silva <silvam.filipe@gmail.com>
 */
class Container implements ContainerInterface, ObjectHydratorAwareInterface
{
    /**
     * @var array
     */
    protected $definitions = [];

    /**
     * @var array
     */
    protected static $instances = [];

    /**
     * @var ObjectHydratorInterface
     */
    protected $hydrator;

    /**
     * @var null|ContainerInterface
     */
    protected $parent;

    /**
     * Creates a dependency container
     */
    public function __construct()
    {
        $this->parent = array_key_exists('container', self::$instances)
            ? self::$instances['container']
            : null;

        self::$instances['container'] = $this;
    }

    /**
     * Finds an entry of the container by its identifier and returns it.
     *
     * @param string $id Identifier of the entry to look for.
     *
     * @throws NotFoundException  No entry was found for this identifier.
     * @throws ContainerException Error while retrieving the entry.
     *
     * @return mixed Entry.
     */
    public function get($id)
    {
        if (!$this->has($id) && $id !== 'container') {
            throw new NotFoundException(
                "Dependency container has not found any definition for '{$id}'"
            );
        }
        return $this->resolve($id);
    }

    /**
     * Returns true if the container can return an entry for the given
     * identifier. Returns false otherwise.
     *
     * @param string $id Identifier of the entry to look for.
     *
     * @return boolean
     */
    public function has($id)
    {
        if (!array_key_exists($id, $this->definitions)) {
            return $this->parentHas($id);
        }

        return true;
    }

    /**
     * Adds a definition or a value to the container
     *
     * @param string       $name
     * @param mixed        $definition
     * @param Scope|string $scope      Resolving scope
     * @param array        $parameters Used if $value is a callable
     *
     * @return Container
     */
    public function register(
        $name,
        $definition = null,
        $scope = Scope::SINGLETON,
        array $parameters = []
    ) {
        if (!$definition instanceof DefinitionInterface) {
            $definition = $this->createDefinition(
                $definition,
                $parameters
            );
            $definition->setScope($scope);
        }
        return $this->add($name, $definition);
    }

    /**
     * Checks if parent has a provided key
     *
     * @param string $key
     *
     * @return bool
     */
    protected function parentHas($key)
    {
        if (!$this->parent) {
            return false;
        }
        return $this->parent->has($key);
    }

    /**
     * Resolves the definition that was saved under the provided name
     *
     * @param string $name
     *
     * @return mixed
     */
    protected function resolve($name)
    {
        if (array_key_exists($name, self::$instances)) {
            return self::$instances[$name];
        }

        if (array_key_exists($name, $this->definitions)) {
            $entry = $this->definitions[$name];
            return $this->registerEntry($name, $entry);
        }

        return $this->parent->get($name);
    }

    /**
     * Checks the definition scope to register resolution result
     *
     * If scope is set to prototype the the resolution result is not
     * stores in the container instances.
     *
     * @param string              $name
     * @param DefinitionInterface $definition
     * @return mixed
     */
    protected function registerEntry($name, DefinitionInterface $definition)
    {
        $value = $definition->resolve();
        if ((string) $definition->getScope() !== Scope::PROTOTYPE) {
            self::$instances[$name] = $value;
        }
        return $value;
    }

    /**
     * Adds a definition to the definitions list
     *
     * This method does not override an existing entry if the same name exists
     * in the definitions or in any definitions of its parents.
     * This way it is possible to change entries defined by other packages
     * as those are build after the main application container is build.
     * The main application container should be the first to be created and
     * therefore set any entry that will override the latest containers build.
     *
     * @param string              $name
     * @param DefinitionInterface $definition
     *
     * @return Container
     */
    protected function add($name, DefinitionInterface $definition)
    {
        if ($this->has($name)) {
            return $this;
        }

        $this->definitions[$name] = $definition;
        $definition->setContainer($this);
        return $this;
    }

    /**
     * Creates the definition for registered data
     *
     * If value is a callable then the definition is Factory, otherwise
     * it will create a Value definition.
     *
     * @see Factory, Value
     *
     * @param callable|mixed $value
     * @param array          $parameters
     *
     * @return Factory|Value
     */
    protected function createDefinition(
        $value,
        array $parameters = []
    ) {
        if (is_callable($value)) {
            return new Factory($value, $parameters);
        }
        return $this->createValueDefinition($value);
    }

    /**
     * Creates a definition for provided name and value pair
     *
     * If $value is a string prefixed with '@' it will create an Alias
     * definition. Otherwise a Value definition will be created.
     *
     * @param mixed  $value
     *
     * @return Value|Alias
     */
    protected function createValueDefinition($value)
    {
        if (is_string($value) && strpos($value, '@') !== false) {
            return new Alias($value);
        }

        return new Value($value);
    }

    /**
     * Creates an instance of provided class injecting its dependencies
     *
     * @param string $className
     * @param array ...$arguments
     *
     * @return mixed
     */
    public function make($className, ...$arguments)
    {
        if (is_a($className, ContainerInjectionInterface::class, true)) {
            return call_user_func_array([$className, 'create'], [$this]);
        }

        $definition = (new ObjectDefinition($className))
            ->setContainer($this)
        ;
        call_user_func_array([$definition, 'with'], $arguments);
        $object = $definition->resolve();

It seems like resolve() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->getHydrator()->hydrate($object);
        return $object;
    }

    /**
     * Set the object hydrator
     *
     * @param ObjectHydratorInterface $hydrator
     *
     * @return Container|ObjectHydratorAwareInterface
     */
    public function setHydrator(ObjectHydratorInterface $hydrator)
    {
        $this->hydrator = $hydrator;
        return $this;
    }

    /**
     * Get the object hydrator
     *
     * @return ObjectHydratorInterface
     */
    public function getHydrator()
    {
        if (!$this->hydrator) {
            $this->setHydrator(new ObjectHydrator($this));
        }
        return $this->hydrator;
    }

    /**
     * Gets the parent container if it exists
     *
     * @return null|ContainerInterface
     */
    public function parent()
    {
        return $this->parent;
    }
}