samson\core\Core::loadMetadata()

Complexity

Conditions	23
Paths	16

Size

Total Lines	141
Code Lines	69

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	552

Importance

Changes

0

<?php declare(strict_types=1);
    protected function loadMetadata(array $metadataCollection, array $modulesToLoad, array $classes, $containerName = 'Container', ContainerInterface $parentContainer = null) : ContainerInterface
    {
        static $implementsByAlias;
        static $serviceAliasesByClass;

        $containerPath = $this->path().'www/cache/'.$containerName.'.php';
        if (!file_exists($containerPath)) {

Blank line found at start of control structure

            // Load annotation and parse classes
            new Injectable();
            new InjectArgument(['var' => 'type']);
            new Service(['value' => '']);

            $reader = new AnnotationReader();
            $resolver = new AnnotationResolver(
                new AnnotationClassResolver($reader),
                new AnnotationPropertyResolver($reader),
                new AnnotationMethodResolver($reader)
            );

            $annotationCollector = new AnnotationMetadataCollector($resolver);
            $metadataCollection = $annotationCollector->collect($classes, $metadataCollection);

            // Regroup classes metadata by class name instead of alias
            $classesMetadata = [];
            foreach ($metadataCollection as $alias => $classMetadata) {
                $classesMetadata[$classMetadata->className] = $classMetadata;
            }

            // Gather all interface implementations
            $implementsByAlias = $implementsByAlias ?? [];
            foreach (get_declared_classes() as $class) {
                $classImplements = class_implements($class);
                foreach (get_declared_interfaces() as $interface) {
                    if (in_array($interface, $classImplements, true)) {
                        if (array_key_exists($class, $classesMetadata)) {
                            $implementsByAlias[strtolower('\\' . $interface)][] = $classesMetadata[$class]->name;
                        }
                    }
                }
            }

            // Gather all class implementations
            $serviceAliasesByClass = $serviceAliasesByClass ?? [];
            foreach (get_declared_classes() as $class) {
                if (array_key_exists($class, $classesMetadata)) {
                    $serviceAliasesByClass[strtolower('\\' . $class)][] = $classesMetadata[$class]->name;
                }
            }

            /**
             * TODO: now we need to implement not forcing to load fixed dependencies into modules
             * to give ability to change constructors and inject old variable into properties
             * and them after refactoring remove them. With this we can only specify needed dependencies
             * in new modules, and still have old ones working.
             */

            foreach ($metadataCollection as $alias => $metadata) {
                foreach ($metadata->propertiesMetadata as $property => $propertyMetadata) {
                    if (is_string($propertyMetadata->dependency)) {
                        $dependency = strtolower($propertyMetadata->dependency);
                        if (array_key_exists($dependency, $implementsByAlias)) {
                            $propertyMetadata->dependency = $implementsByAlias[$dependency][0];
                        } elseif (array_key_exists($dependency, $serviceAliasesByClass)) {
                            $propertyMetadata->dependency = $serviceAliasesByClass[$dependency][0];
                        } else {

Blank line found at start of control structure

                        }
                    }
                }
                foreach ($metadata->methodsMetadata as $method => $methodMetadata) {
                    foreach ($methodMetadata->dependencies as $argument => $dependency) {
                        if (is_string($dependency)) {
                            $dependency = strtolower($dependency);
                            if (array_key_exists($dependency, $implementsByAlias)) {
                                $methodMetadata->dependencies[$argument] = $implementsByAlias[$dependency][0];
                                //$methodMetadata->parametersMetadata[$argument]->dependency = $implementsByAlias[$dependency][0];
                            } elseif (array_key_exists($dependency, $serviceAliasesByClass)) {
                                $methodMetadata->dependencies[$argument] = $serviceAliasesByClass[$dependency][0];
                                //$methodMetadata->parametersMetadata[$argument]->dependency = $serviceAliasesByClass[$dependency][0];
                            } else {

Blank line found at start of control structure

                            }
                        }
                    }
                }
            }

            // Generate XML configs
            //(new XMLBuilder())->buildXMLConfig($metadataCollection, getcwd().'/cache/config_');

            // Load container class
            file_put_contents($containerPath,
                $this->builder->build($metadataCollection, $containerName, '', $parentContainer));

The call to ContainerBuilderInterface::build() has too many arguments starting with $parentContainer.

Blank line found at end of control structure

        }

        require_once($containerPath);


        // Inject current core into container
        /** @var ContainerInterface $container */
        $this->container = new $containerName();
        $containerReflection = new \ReflectionClass(get_class($this->container));
        $serviceProperty = $containerReflection->getProperty(Builder::DI_FUNCTION_SERVICES);
        $serviceProperty->setAccessible(true);
        $containerServices = $serviceProperty->getValue($this->container);
        $containerServices['core'] = $this;
        $serviceProperty->setValue($this->container, $containerServices);
        $serviceProperty->setAccessible(false);
        if ($parentContainer !== null) {
            $this->container->delegate($parentContainer);
        }

        foreach ($modulesToLoad as $identifier => $parameters) {
            $instance = $this->container->get($identifier);

            // Set composer parameters
            $instance->composerParameters = $parameters;

            // TODO: Change event signature to single approach
            // Fire core module load event
            Event::fire('core.module_loaded', [$identifier, &$instance]);

            // Signal core module configure event
            Event::signal('core.module.configure', [&$instance, $identifier]);

            if ($instance instanceof PreparableInterface) {
                // Call module preparation handler
                if (!$instance->prepare()) {
                    //throw new \Exception($identifier.' - Module preparation stage failed');
                }
            }

            // Try to set module parent module
            $instance->parent = $this->getClassParentModule(get_parent_class($instance));
        }

        return $this->container;
    }