KGzocha\Bundle\SearcherBundle\DependencyInjection\CompilerPass\DefinitionBuilder

Complexity

Total Complexity

9

Size/Duplication

Total Lines	118
Duplicated Lines	30.51 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

96.3%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	buildDefinition()	0	22	2
A	buildFromService()	18	18	2
A	buildFromClass()	18	18	2
A	getDefinition()	0	9	2

<?php

namespace KGzocha\Bundle\SearcherBundle\DependencyInjection\CompilerPass;

use Symfony\Component\Config\Definition\Exception\InvalidDefinitionException;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;

/**
 * @author Krzysztof Gzocha <krzysztof@propertyfinder.ae>
 */
class DefinitionBuilder
{
    const CLASS_PARAMETER = 'class';
    const SERVICE_PARAMETER = 'service';

    /**
     * @var ParametersValidator
     */
    private $parameterValidator;

    /**
     * @param ParametersValidator $parameterValidator
     */
    public function __construct(ParametersValidator $parameterValidator)
    {
        $this->parameterValidator = $parameterValidator;
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $contextId
     * @param string           $definitionName
     * @param array            $config
     *
     * @return Definition
     *
     * @throws InvalidDefinitionException
     */
    public function buildDefinition(
        ContainerBuilder $container,
        $contextId,
        $definitionName,
        array &$config
    ) {
        $this->parameterValidator->validateParameters($contextId, $config);

        if (isset($config[self::SERVICE_PARAMETER])) {
            return $this->buildFromService(
                $container,
                $definitionName,
                $config[self::SERVICE_PARAMETER]
            );
        }

        return $this->buildFromClass(
            $container,
            $definitionName,
            $config[self::CLASS_PARAMETER]
        );
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $definitionName
     * @param string           $oldServiceName
     *
     * @return Definition
     */
    private function buildFromService(
        ContainerBuilder $container,
        $definitionName,
        $oldServiceName
    ) {
        if (!$container->hasDefinition($oldServiceName)) {
            throw new InvalidDefinitionException(sprintf(
                'Could not create "%s" service, because configured service "%s" does not exist.',
                $definitionName,
                $oldServiceName
            ));
        }

        return $container->setDefinition(
            $definitionName,
            $container->getDefinition($oldServiceName)
        );
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $definitionName
     * @param string           $className
     *
     * @return Definition
     */
    private function buildFromClass(
        ContainerBuilder $container,
        $definitionName,
        $className
    ) {
        if (!class_exists($className)) {
            throw new InvalidDefinitionException(sprintf(
                'Could not create service "%s", because class "%s" does not exist.',
                $definitionName,
                $className
            ));
        }

        return $container->setDefinition(
            $definitionName,
            $this->getDefinition($className)
        );
    }

    /**
     * @param string $className
     *
     * @return Definition
     */
    private function getDefinition($className)
    {
        $definition = new Definition($className);
        if (method_exists($definition, 'setLazy')) {
            $definition->setLazy(true);
        }

        return $definition;
    }
}