samson\core\Core::loadMetadata()

Complexity

Conditions	19
Paths	2520

Size

Total Lines	115
Code Lines	58

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	222.519

Importance

Changes

0

<?php declare(strict_types=1);
    protected function loadMetadata(array $metadataCollection, array $modulesToLoad, array $classes)
    {
        // Load annotation and parse classes
        new Injectable();
        new InjectArgument(['var' => 'type']);

        $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 = [];
        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['\\'.$interface][] = $classesMetadata[$class]->name;
                    }
                }
            }
        }

        // Gather all class implementations
        $serviceAliasesByClass = [];
        foreach (get_declared_classes() as $class) {
            if (array_key_exists($class, $classesMetadata)) {
                $serviceAliasesByClass['\\' . $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 (array_key_exists($propertyMetadata->dependency, $implementsByAlias)) {
                    $propertyMetadata->dependency = $implementsByAlias[$propertyMetadata->dependency][0];
                } elseif (array_key_exists($propertyMetadata->dependency, $serviceAliasesByClass)) {
                    $propertyMetadata->dependency = $serviceAliasesByClass[$propertyMetadata->dependency][0];
                } else {

Blank line found at start of control structure

                }
            }
            foreach ($metadata->methodsMetadata as $method => $methodMetadata) {
                foreach ($methodMetadata->dependencies as $argument => $dependency) {
                    if (array_key_exists($dependency, $implementsByAlias)) {
                        $methodMetadata->dependencies[$argument] = $implementsByAlias[$dependency][0];
                    } elseif (array_key_exists($dependency, $serviceAliasesByClass)) {
                        $methodMetadata->dependencies[$argument] = $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
        $containerPath = $this->path().'www/cache/Container.php';
        file_put_contents($containerPath, $this->builder->build($metadataCollection));
        require_once($containerPath);

        // Inject current core into container
        $this->container = new \Container();

It seems like new \Container() of type object<Container> is incompatible with the declared type object<samsonframework\di\ContainerInterface> of property $container.

        $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);

        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));
        }

    }