Laganica\Di\Container

Complexity

Total Complexity

23

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

77.78%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	get()	0	29	6
A	has()	0	12	3
A	setAutowire()	0	4	1
A	isAutowire()	0	4	1
A	addDefinitions()	0	6	2
A	addDefinition()	0	8	2
A	getDefinition()	0	4	1
A	transformDefinition()	0	12	3
A	hasDefinition()	0	4	1
A	addEntry()	0	4	1
A	getEntry()	0	4	1

<?php

namespace Laganica\Di;

use Closure;
use InvalidArgumentException;
use Laganica\Di\Definition\ClassDefinition;
use Laganica\Di\Definition\ClosureDefinition;
use Laganica\Di\Exception\ContainerException;
use Laganica\Di\Exception\NotFoundException;
use Laganica\Di\Resolver\ResolverFactoryInterface;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;

/**
 * Class Container
 *
 * @package Laganica\Di
 */
class Container implements ContainerInterface
{
    /**
     * @var array
     */
    private $definitions = [];

    /**
     * @var array
     */
    private $entries = [];

    /**
     * @var bool
     */
    private $autowire = true;

    /**
     * @var ResolverFactoryInterface
     */
    private $resolverFactory;

    /**
     * @param ResolverFactoryInterface $resolverFactory
     */
    public function __construct(ResolverFactoryInterface $resolverFactory)
    {
        $this->resolverFactory = $resolverFactory;
        $this->resolverFactory->setContainer($this);
    }

    /**
     * @inheritDoc
     */
    public function get($id)
    {
        if (!is_string($id)) {
            $type = get_class($id);
            throw new InvalidArgumentException("Argument \$id must be string, $type given");
        }

        if ($entry = $this->getEntry($id)) {
            return $entry;
        }

        $definition = $this->getDefinition($id);

        if ($definition) {
            $definition = $this->transformDefinition($definition);

            if ($resolver = $this->resolverFactory->create($definition)) {
                return $this->addEntry($id, $resolver->resolve($definition));
            }
        }

        if ($this->isAutowire()) {
            $resolver = $this->resolverFactory->createClassResolver();

            return $this->addEntry($id, $resolver->resolve(new ClassDefinition($id)));
        }

        throw NotFoundException::create($id);
    }

    /**
     * @inheritDoc
     */
    public function has($id): bool
    {
        try {
            $this->get($id);

            return true;
        } catch (NotFoundExceptionInterface $ex) {
            return false;
        } catch (ContainerExceptionInterface $ex) {
            return true;
        }
    }

    /**
     * @param bool $autowire
     */
    public function setAutowire(bool $autowire): void
    {
        $this->autowire = $autowire;
    }

    public function isAutowire(): bool
    {
        return $this->autowire;
    }

    /**
     * @param array $definitions
     *
     * @throws ContainerException
     */
    public function addDefinitions(array $definitions): void
    {
        foreach ($definitions as $id => $definition) {
            $this->addDefinition($id, $definition);
        }
    }

    /**
     * @param string $id
     * @param $definition
     *
     * @throws ContainerException
     */
    public function addDefinition(string $id, $definition): void
    {
        if ($this->hasDefinition($id)) {
            throw new ContainerException("More than one definition is found for entry or class $id");
        }

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

    /**
     * @param string $id
     *
     * @return null|mixed
     */
    public function getDefinition(string $id)
    {
        return $this->definitions[$id] ?? null;
    }

    /**
     * @param $definition
     *
     * @return mixed
     */
    private function transformDefinition($definition)
    {
        if ($definition instanceof Closure) {
            return new ClosureDefinition($definition);
        }

        if (is_string($definition)) {
            return new ClassDefinition($definition);
        }

        return $definition;
    }

    /**
     * @param string $id
     *
     * @return bool
     */
    public function hasDefinition(string $id): bool
    {
        return array_key_exists($id, $this->definitions);
    }

    /**
     * @param string $id
     * @param mixed $entry
     *
     * @return mixed
     */
    private function addEntry(string $id, $entry)
    {
        return $this->entries[$id] = $entry;
    }

    /**
     * @param string $id
     *
     * @return null|mixed
     */
    public function getEntry(string $id)
    {
        return $this->entries[$id] ?? null;
    }
}