Majora\Bundle\FrameworkExtraBundle\DependencyInjection\Compiler\LoaderCompilerPass

Complexity

Total Complexity

17

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

8.93%

Importance

Changes	4
Bugs	0	Features	3

1 Method

Rating	Name	Duplication	Size	Complexity
F	process()	0	80	17

<?php

namespace Majora\Bundle\FrameworkExtraBundle\DependencyInjection\Compiler;

use Majora\Framework\Loader\Bridge\Doctrine\AbstractDoctrineLoader;
use Majora\Framework\Loader\LoaderInterface;
use Majora\Framework\Model\CollectionableInterface;
use Majora\Framework\Model\LazyPropertiesInterface;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Compiler pass to register loaders setUp.
 */
class LoaderCompilerPass implements CompilerPassInterface
{
    /**
     * {@inheritdoc}
     *
     * Processes "majora.loader" tags
     */
    public function process(ContainerBuilder $container)
    {
        $loaderCollectionDefinition = $container->findDefinition('majora.loader.collection');
        $loaderTags = $container->findTaggedServiceIds('majora.loader');

        foreach ($loaderTags as $loaderId => $tags) {
            $loaderDefinition = $container->getDefinition($loaderId);
            $loaderReflection = new \ReflectionClass($loaderDefinition->getClass());

            foreach ($tags as $attributes) {
                $method = $loaderReflection->implementsInterface(LoaderInterface::class) ?
                    'configureMetadata' : ($loaderReflection->hasMethod('setUp') ?
                        'setUp' : ''
                    )
                ;
                if (isset($attributes['entityClass']) || isset($attributes['entityCollection'])) {
                    @trigger_error('"entityClass" and "entityCollection" attributes for tag "majora.loader" are deprecated and will be removed in 2.0. Please "entity" and "collection" instead.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                }
                $entityClass = isset($attributes['entity']) ? $attributes['entity'] : $attributes['entityClass'];
                $collectionClass = isset($attributes['collection']) ? $attributes['collection'] : $attributes['entityCollection'];
                $entityReflection = new \ReflectionClass($entityClass);

                if ($method) {
                    if (!$entityReflection->implementsInterface(CollectionableInterface::class)) {
                        throw new \InvalidArgumentException(sprintf(
                            'Cannot support "%s" class into "%s" : managed items have to be %s.',
                            $entityClass,
                            $loaderDefinition->getClass(),
                            CollectionableInterface::class
                        ));
                    }
                    $arguments = array(
                        $entityClass,
                        array_map(
                            function ($property) { return $property->getName(); },
                            $entityReflection->getProperties()
                        ),
                        $collectionClass,
                    );

                    if (isset($attributes['repository'])) {
                        @trigger_error('Repository injection tag "majora.loader" is deprecated and will be removed in 2.0. Please inject it by constructor.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

                        $arguments[] = new Reference($attributes['repository']);
                    }

                    $loaderDefinition->addMethodCall($method, $arguments);
                }

                // for doctrine, loaders cannot self enable objects lazy loading
                // so we have to check class / attribute and register service into event proxy
                if ($container->hasDefinition('majora.doctrine.event_proxy')
                    && !empty($attributes['lazy'])
                    && $loaderReflection->isSubclassOf(AbstractDoctrineLoader::class)
                ) {
                    if (!$entityReflection->implementsInterface(LazyPropertiesInterface::class)) {
                        throw new \InvalidArgumentException(sprintf(
                            'Class %s has to implement %s to be able to lazy load her properties.',
                            $entityClass,
                            LazyPropertiesInterface::class
                        ));
                    }
                    $container->getDefinition('majora.doctrine.event_proxy')
                        ->addMethodCall('registerDoctrineLazyLoader', array(
                            $entityClass,
                            new Reference($loaderId),
                        ))
                    ;
                }

                if (!isset($attributes['alias'])) {
                    throw new \InvalidArgumentException(sprintf('Alias not define for "%s" loader.', $loaderId));
                }

                $loaderCollectionDefinition->addMethodCall(
                    'add',
                    array($attributes['alias'], new Reference($loaderId))
                );
            }
        }
    }
}