Lug\Bundle\ResourceBundle\DependencyInjection\Extension\ResourceConfiguration

Complexity

Total Complexity

20

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

85.86%

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getConfigTreeBuilder()	0	10	1
A	configureBundle()	0	3	1
A	createResourceNodes()	0	11	2
A	createResourceNode()	0	51	3
A	createDriverNode()	0	10	1
A	createDriverMappingNode()	0	9	1
B	createClassNode()	0	22	5
A	createNode()	0	14	4
A	createTreeBuilder()	0	4	1

<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <geloen.eric@gmail.com>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Bundle\ResourceBundle\DependencyInjection\Extension;

use Lug\Bundle\ResourceBundle\ResourceBundleInterface;
use Lug\Component\Resource\Controller\ControllerInterface;
use Lug\Component\Resource\Domain\DomainManagerInterface;
use Lug\Component\Resource\Factory\FactoryInterface;
use Lug\Component\Resource\Model\ResourceInterface;
use Lug\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\Config\Definition\Builder\NodeBuilder;
use Symfony\Component\Config\Definition\Builder\NodeDefinition;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\ConfigurationInterface;
use Symfony\Component\Form\FormTypeInterface;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
class ResourceConfiguration implements ConfigurationInterface
{
    /**
     * @var ResourceBundleInterface
     */
    private $bundle;

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

    /**
     * {@inheritdoc}
     */
    public function getConfigTreeBuilder()
    {
        $treeBuilder = $this->createTreeBuilder();
        $children = $treeBuilder->root($this->bundle->getAlias())->children();

        $this->configureBundle($children);
        $children->append($this->createResourceNodes());

        return $treeBuilder;
    }

    /**
     * @param NodeBuilder $builder
     */
    protected function configureBundle(NodeBuilder $builder)
    {
    }

    /**
     * @return ArrayNodeDefinition
     */
    private function createResourceNodes()
    {
        $resourcesNode = $this->createNode('resources')->addDefaultsIfNotSet();

It seems like you code against a specific sub-type and not the parent class Symfony\Component\Config\Definition\Builder\NodeDefinition as the method addDefaultsIfNotSet() does only exist in the following sub-classes of Symfony\Component\Config\Definition\Builder\NodeDefinition: Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition. Maybe you want to instanceof check for one of these explicitly?

        $childrenNode = $resourcesNode->children();

        foreach ($this->bundle->getResources() as $resource) {
            $childrenNode->append($this->createResourceNode($resource));
        }

        return $resourcesNode;
    }

    /**
     * @param ResourceInterface $resource
     * @param string|null       $name
     *
     * @return ArrayNodeDefinition
     */
    private function createResourceNode(ResourceInterface $resource, $name = null)
    {
        $resourceNode = $this->createNode($name ?: $resource->getName())->addDefaultsIfNotSet();

It seems like you code against a specific sub-type and not the parent class Symfony\Component\Config\Definition\Builder\NodeDefinition as the method addDefaultsIfNotSet() does only exist in the following sub-classes of Symfony\Component\Config\Definition\Builder\NodeDefinition: Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition. Maybe you want to instanceof check for one of these explicitly?

        $childrenNode = $resourceNode->children()
            ->append($this->createDriverNode($resource))
            ->append($this->createClassNode(
                'model',
                $resource->getModel(),
                $resource->getInterfaces(),
                true
            ))
            ->append($this->createClassNode(
                'repository',
                $resource->getRepository(),
                [RepositoryInterface::class],
                true
            ))
            ->append($this->createClassNode(
                'factory',
                $resource->getFactory(),
                [FactoryInterface::class]
            ))
            ->append($this->createClassNode(
                'form',
                $resource->getForm(),
                [FormTypeInterface::class]
            ))
            ->append($this->createClassNode(
                'choice_form',
                $resource->getChoiceForm(),
                [FormTypeInterface::class]
            ))
            ->append($this->createClassNode(
                'domain_manager',
                $resource->getDomainManager(),
                [DomainManagerInterface::class]
            ))
            ->append($this->createClassNode(
                'controller',
                $resource->getController(),
                [ControllerInterface::class]
            ))
            ->append($this->createNode('id_property_path', 'scalar', $resource->getIdPropertyPath()))
            ->append($this->createNode('label_property_path', 'scalar', $resource->getLabelPropertyPath()));

        if ($resource->getTranslation() !== null) {
            $childrenNode->append($this->createResourceNode($resource->getTranslation(), 'translation'));
        }

        return $resourceNode;
    }

    /**
     * @param ResourceInterface $resource
     *
     * @return ArrayNodeDefinition
     */
    private function createDriverNode(ResourceInterface $resource)
    {
        $driverNode = $this->createNode('driver')->addDefaultsIfNotSet();

It seems like you code against a specific sub-type and not the parent class Symfony\Component\Config\Definition\Builder\NodeDefinition as the method addDefaultsIfNotSet() does only exist in the following sub-classes of Symfony\Component\Config\Definition\Builder\NodeDefinition: Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition. Maybe you want to instanceof check for one of these explicitly?

        $driverNode->children()
            ->append($this->createNode('name', 'scalar', $resource->getDriver()))
            ->append($this->createNode('manager', 'scalar', $resource->getDriverManager()))
            ->append($this->createDriverMappingNode($resource));

        return $driverNode;
    }

    /**
     * @param ResourceInterface $resource
     *
     * @return ArrayNodeDefinition
     */
    private function createDriverMappingNode(ResourceInterface $resource)
    {
        $mappingNode = $this->createNode('mapping')->addDefaultsIfNotSet();

It seems like you code against a specific sub-type and not the parent class Symfony\Component\Config\Definition\Builder\NodeDefinition as the method addDefaultsIfNotSet() does only exist in the following sub-classes of Symfony\Component\Config\Definition\Builder\NodeDefinition: Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition. Maybe you want to instanceof check for one of these explicitly?

        $mappingNode->children()
            ->append($this->createNode('path', 'scalar', $resource->getDriverMappingPath()))
            ->append($this->createNode('format', 'scalar', $resource->getDriverMappingFormat()));

        return $mappingNode;
    }

    /**
     * @param string   $name
     * @param string   $class
     * @param string[] $interfaces
     * @param bool     $required
     *
     * @return NodeDefinition
     */
    private function createClassNode($name, $class, array $interfaces = [], $required = false)
    {
        return $this->createNode($name, 'scalar', $class, function ($class) use ($interfaces, $required) {
            if ($class === null) {
                return $required;
            }

            if (!class_exists($class)) {
                return true;
            }

            $classInterfaces = class_implements($class);

            foreach ($interfaces as $interface) {
                if (!in_array($interface, $classInterfaces, true)) {
                    return true;
                }
            }

            return false;
        }, 'The %s %%s does not exist.');
    }

    /**
     * @param string        $name
     * @param string        $type
     * @param mixed         $default
     * @param callable|null $if
     * @param string|null   $then
     *
     * @return ArrayNodeDefinition|NodeDefinition
     */
    private function createNode($name, $type = 'array', $default = null, $if = null, $then = null)
    {
        $node = $this->createTreeBuilder()->root($name, $type);

        if ($default !== null) {
            $node->defaultValue($default);
        }

        if ($if !== null && $then !== null) {
            $node->validate()->ifTrue($if)->thenInvalid(sprintf($then, $name));
        }

        return $node;
    }

    /**
     * @return TreeBuilder
     */
    private function createTreeBuilder()
    {
        return new TreeBuilder();
    }
}