Sensorario\Container\Container

Complexity

Total Complexity

13

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.45%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	loadServices()	0	4	1
A	getServicesConfiguration()	0	4	1
A	getResolver()	0	12	3
A	__construct()	0	18	1
A	ensureServiceIsDefined()	0	10	2
A	get()	0	18	2
A	has()	0	4	1
A	contains()	0	5	1
A	hasArguments()	0	4	1

<?php

namespace Sensorario\Container;

use Sensorario\Container\Objects\Argument;
use Sensorario\Container\Objects\Service;
use Sensorario\Container\Resolver\ConstructorResolver;
use Sensorario\Container\Resolver\MethodResolver;
use Sensorario\Container\Resolver\Resolver;

class Container implements \Psr\Container\ContainerInterface
{
    private $services = [];

    private $builder;

    private $resolver;

    private $construcrtorResolver;

    private $methodResolver;

    private $register;

    public function __construct()
    {
        $this->register = new Register();

        $this->construcrtorResolver = new ConstructorResolver();

        $this->resolver = new Resolver();
        $this->resolver->setConstructorResolver($this->construcrtorResolver);

        $this->methodResolver = new MethodResolver();

        $this->builder = new ArgumentBuilder();
        $this->builder->setContainer($this);

        $this->methodResolver->setArgumentBuilder(
            $this->builder
        );
    }

    public function loadServices(array $services) : void
    {
        $this->services = $services;
    }

    public function getServicesConfiguration() : array
    {
        return $this->services;
    }

    private function ensureServiceIsDefined(string $serviceName) : bool
    {
        if (!$this->contains($serviceName)) {
            throw new \RuntimeException(
                'Oops! Service ' . $serviceName . ' not defined'
            );
        }

        return true;
    }

    public function get($serviceName)
    {
        $this->ensureServiceIsDefined($serviceName);

        $service = Service::box([
            'name' => $serviceName,
            'services' => $this->services,
        ]);

        if (!$this->register->has($service)) {
            $this->register->store(
                $service,
                $this->getResolver($service)
            );
        }

        return $this->register->get($service);
    }

    public function getResolver(Service $service)
    {
        if ($service->hasMethodInjection()) {
            return $this->methodResolver;
        }

        if ($service->hasSimpleInjection()) {
            return $this->resolver;
        }

        return $this->construcrtorResolver;
    }

    public function has($id)
    {
        return $this->contains($id);
    }

    public function contains(string $serviceName) : bool
    {
        $service = Argument::fromString($serviceName);
        return isset($this->services[$service->getServiceName()]);
    }

    public function hasArguments(string $serviceName) : bool
    {
        return isset($this->services[$serviceName]['params']);
    }
}