Sensorario\Container\Container

Complexity

Total Complexity

10

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
A	loadServices()	0	4	1
A	getServicesConfiguration()	0	4	1
A	ensureServiceIsDefined()	0	8	2
A	get()	0	19	3
A	contains()	0	5	1
A	hasArguments()	0	4	1

<?php

namespace Sensorario\Container;

use Sensorario\Container\Resolver\ConstructorResolver;
use Sensorario\Container\Resolver\MethodResolver;
use Sensorario\Container\Resolver\Resolver;

class Container
{
    private $services = array();

    private $builder;

    private $resolver;

    private $construcrtorResolver;

    private $methodResolver;

    public function __construct()
    {
        $this->resolver = new Resolver();

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

        $this->methodResolver = new MethodResolver();

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

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

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

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

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

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

        $service = Objects\Service::box(array(
            'name' => $serviceName,
            'services' => $this->services,
        ));

        if ($service->isConstructorInjection()) {
            return $this->methodResolver->resolve($service, $this->builder);

The call to MethodResolver::resolve() has too many arguments starting with $this->builder.

        } else {
            if ($service->isMethodInjection()) {
                return $this->resolver->resolve($service);
            }

            return $this->construcrtorResolver->resolve($service);
        }
    }

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

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