ONGR\ElasticsearchBundle\DependencyInjection\Compiler\MappingPass

Complexity

Total Complexity

16

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

<?php
use Symfony\Component\DependencyInjection\Definition;

class MappingPass implements CompilerPassInterface
{
    /**
     * @var array
     */
    private $indexes = [];

    /**
     * @var string
     */
    private $defaultIndex = null;

    public function process(ContainerBuilder $container)
    {
        $kernelDir = $container->getParameter('kernel.project_dir');
        $parser = $container->get(DocumentParser::class);

        $indexClasses = [];
        $indexSettingsArray = [];
        foreach ($container->getParameter(Configuration::ONGR_SOURCE_DIR) as $dir) {
            foreach ($this->getNamespaces($kernelDir . $dir) as $namespace) {
                $indexClasses[$namespace] = $namespace;
            }
        }

        $overwrittenClasses = [];
        $indexOverrides = $container->getParameter(Configuration::ONGR_INDEXES_OVERRIDE);

        foreach ($indexOverrides as $name => $indexOverride) {
            $class = isset($indexOverride['class']) ? $indexOverride['class'] : $name;

            if (!isset($indexClasses[$class])) {
                throw new \RuntimeException(
                    sprintf(
                        'Document `%s` defined in ongr_elasticsearch.indexes config could not been found',
                        $class,
                    )

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected ')'

                );
            }

            $indexSettings = $this->parseIndexSettingsFromClass($parser, $class);

            if ($class !== $name) {
                $indexSettings->setIndexName('ongr.es.index.'.$name);
            }

            if (isset($indexOverride['alias'])) {
                $indexSettings->setAlias($indexOverride['alias']);
            }

            if (isset($indexOverride['settings'])) {
                $indexSettings->setIndexMetadata($indexOverride['settings']);
            }

            if (isset($indexOverride['hosts'])) {
                $indexSettings->setHosts($indexOverride['hosts']);
            }

            if (isset($indexOverride['default'])) {
                $indexSettings->setDefaultIndex($indexOverride['default']);
            }

            $indexSettingsArray[$name] = $indexSettings;
            $overwrittenClasses[$class] = $class;
        }

        foreach (array_diff($indexClasses, $overwrittenClasses) as $indexClass) {
            try {
                $indexSettingsArray[$indexClass] = $this->parseIndexSettingsFromClass($parser, $indexClass);
            } catch (DocumentIndexParserException $e) {}
        }

        foreach($indexSettingsArray as $indexSettings) {
            $this->createIndex($container, $indexSettings);
        }

        $container->setParameter(Configuration::ONGR_INDEXES, $this->indexes);
        $container->setParameter(
            Configuration::ONGR_DEFAULT_INDEX,
            $this->defaultIndex ?? current(array_keys($this->indexes))
        );
    }

    private function parseIndexSettingsFromClass(DocumentParser $parser, string $className) : IndexSettings
    {
        $class = new \ReflectionClass($className);

        /** @var Index $document */
        $document = $parser->getIndexAnnotation($class);

        if ($document === null) {
            throw new DocumentIndexParserException();
        }

        $indexSettings = new IndexSettings(
            $className,
            $className,
            $parser->getIndexAliasName($class),
            $parser->getIndexMetadata($class),
            $parser->getPropertyMetadata($class),
            $document->hosts,
            $parser->isDefaultIndex($class)
        );

        $indexSettings->setIndexMetadata(['settings' => [
            'number_of_replicas' => $document->numberOfReplicas,
            'number_of_shards' => $document->numberOfShards,
        ]]);

        return $indexSettings;
    }

    private function createIndex(Container $container, IndexSettings $indexSettings) {
        $converterDefinition = $container->getDefinition(Converter::class);

        $indexSettingsDefinition = new Definition(
            IndexSettings::class,
            [
                $indexSettings->getNamespace(),
                $indexSettings->getAlias(),
                $indexSettings->getAlias(),
                $indexSettings->getIndexMetadata(),
                $indexSettings->getPropertyMetadata(),
                $indexSettings->getHosts(),
                $indexSettings->isDefaultIndex(),
            ]
        );

        $indexServiceDefinition = new Definition(IndexService::class, [
            $indexSettings->getNamespace(),
            $converterDefinition,
            $container->getDefinition('event_dispatcher'),
            $indexSettingsDefinition,
            $container->getParameter(Configuration::ONGR_PROFILER_CONFIG)
                ? $container->getDefinition('ongr.esb.tracer') : null
        ]);

        $indexServiceDefinition->setPublic(true);
        $converterDefinition->addMethodCall(
            'addClassMetadata',
            [
                $indexSettings->getNamespace(),
                $indexSettings->getPropertyMetadata()
            ]
        );

        $container->setDefinition($indexSettings->getIndexName(), $indexServiceDefinition);
        $this->indexes[$indexSettings->getAlias()] = $indexSettings->getIndexName();
        $isCurrentIndexDefault = $indexSettings->isDefaultIndex();
        if ($this->defaultIndex && $isCurrentIndexDefault) {
            throw new \RuntimeException(