samsonframework\container\definition\builder\DefinitionBuilder

Complexity

Total Complexity

10

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	defineParameter()	0	4	1
A	defineImplementors()	0	6	1
A	addDefinition()	0	19	3
A	hasDefinition()	0	4	1
A	getDefinitionCollection()	0	4	1
A	getParameterCollection()	0	4	1
A	getImplementors()	0	4	1

<?php declare(strict_types = 1);
/**
 * Created by PhpStorm.
 * User: root
 * Date: 02.08.16
 * Time: 0:46.
 */
namespace samsonframework\container\definition\builder;

use samsonframework\container\definition\AbstractDefinition;
use samsonframework\container\definition\ClassBuilderInterface;
use samsonframework\container\definition\ClassDefinition;
use samsonframework\container\definition\exception\ClassDefinitionAlreadyExistsException;
use samsonframework\container\definition\parameter\exception\ParameterAlreadyExistsException;
use samsonframework\container\definition\parameter\ParameterBuilder;
use samsonframework\container\definition\parameter\ParameterBuilderInterface;
use samsonframework\container\definition\reference\ClassReference;
use samsonframework\container\definition\reference\ReferenceDependencyInterface;
use samsonframework\container\definition\reference\ReferenceInterface;

/**
 * Class DefinitionBuilder
 *
 * @author Ruslan Molodyko <molodyko@samsonos.com>
 */
class DefinitionBuilder extends AbstractDefinition
{
    /** @var  ClassDefinition[] Definition collection */
    protected $definitionCollection = [];
    /** @var  ParameterBuilder */
    protected $parameterBuilder;
    /** @var array Collection of interface => [classes]*/
    protected $implementors = [];

    /**
     * DefinitionBuilder constructor.
     *
     * @param ParameterBuilder $parameterBuilder
     * @param AbstractDefinition|null $parentDefinition
     */
    public function __construct(ParameterBuilder $parameterBuilder, AbstractDefinition $parentDefinition = null)
    {
        parent::__construct($parentDefinition);

        $this->parameterBuilder = $parameterBuilder;
        $this->parameterBuilder->setParentDefinition($this);
    }

    /**
     * Define parameters
     *
     * @param string $name
     * @param ReferenceInterface $reference
     * @return ParameterBuilderInterface
     * @throws ParameterAlreadyExistsException
     */
    public function defineParameter(string $name, ReferenceInterface $reference): ParameterBuilderInterface
    {
        return $this->parameterBuilder->defineParameter($name, $reference);
    }

    /**
     * Define interface implementors
     *
     * @param string $interfaceName
     * @param ReferenceInterface $class
     * @return DefinitionBuilder
     */
    public function defineImplementors(string $interfaceName, ReferenceInterface $class): DefinitionBuilder
    {
        $this->implementors[$interfaceName] = $class;

        return $this;
    }

    /**
     * Add new class definition
     *
     * @param $className
     * @param string $serviceName
     * @return ClassBuilderInterface
     * @throws \InvalidArgumentException
     * @throws ClassDefinitionAlreadyExistsException
     */
    public function addDefinition($className, string $serviceName = null): ClassBuilderInterface
    {
        // Check if class already exists
        if ($this->hasDefinition($className)) {
            throw new ClassDefinitionAlreadyExistsException();
        }

        // Create new definition
        $classDefinition = new ClassDefinition($this);
        $classDefinition->setClassName(new ClassReference($className));
        if ($serviceName) {

The expression $serviceName of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $classDefinition->setServiceName($serviceName);
        }

        // Register definition
        $this->definitionCollection[$className] = $classDefinition;

        return $classDefinition;
    }

    /**
     * When definition for class name is exists in collection
     *
     * @param $className
     * @return bool
     */
    public function hasDefinition($className): bool
    {
        return array_key_exists($className, $this->definitionCollection);
    }

    /**
     * @return ClassDefinition[]
     */
    public function getDefinitionCollection(): array
    {
        return $this->definitionCollection;
    }

    /**
     * @return ReferenceInterface[]
     */
    public function getParameterCollection(): array
    {
        return $this->parameterBuilder->getParameterCollection();
    }

    /**
     * @return array
     */
    public function getImplementors(): array
    {
        return $this->implementors;
    }
}