Stitcher\App

Complexity

Total Complexity

21

Size/Duplication

Total Lines	126
Duplicated Lines	17.46 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

73.77%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	12	1
A	get()	0	4	1
A	developmentServer()	11	11	2
A	productionServer()	11	11	2
A	loadConfig()	0	6	2
A	loadServices()	0	11	2
A	loadPlugins()	0	14	3
A	registerPluginDefinition()	0	8	1
A	loadPluginConfiguration()	0	20	4
A	loadPluginServices()	0	14	3

<?php

namespace Stitcher;

use Illuminate\Support\Arr;
use Pageon\Config;
use Stitcher\Application\DevelopmentServer;
use Stitcher\Application\ProductionServer;
use Stitcher\Exception\InvalidConfiguration;
use Stitcher\Exception\InvalidPlugin;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;

class App
{
    /** @var ContainerBuilder */
    protected static $container;

    public static function init()
    {
        Config::init();

        self::$container = new ContainerBuilder();

        self::loadConfig(Config::all());

        self::loadServices('services.yaml');

        self::loadPlugins();
    }

    public static function get(string $id)
    {
        return self::$container->get($id);
    }

    public static function developmentServer(): DevelopmentServer

This method seems to be duplicated in your project.

    {
        try {
            /** @var DevelopmentServer $server */
            $server = self::get(DevelopmentServer::class);

            return $server;
        } catch (ParameterNotFoundException $e) {
            throw InvalidConfiguration::missingParameter($e->getKey());
        }
    }

    public static function productionServer(): ProductionServer

This method seems to be duplicated in your project.

    {
        try {
            /** @var ProductionServer $server */
            $server = self::get(ProductionServer::class);

            return $server;
        } catch (ParameterNotFoundException $e) {
            throw InvalidConfiguration::missingParameter($e->getKey());
        }
    }

    protected static function loadConfig(array $config): void
    {
        foreach ($config as $key => $value) {
            self::$container->setParameter($key, $value);
        }
    }

    protected static function loadServices(string $servicesPath): void
    {
        $loader = new YamlFileLoader(self::$container, new FileLocator(__DIR__));

        $loader->load($servicesPath);

        /** @var Definition $definition */
        foreach (self::$container->getDefinitions() as $id => $definition) {
            self::$container->setAlias($definition->getClass(), $id);
        }
    }

    protected static function loadPlugins(): void
    {
        foreach (Config::plugins() as $pluginClass) {
            if (!class_implements($pluginClass, Plugin::class)) {
                throw InvalidPlugin::doesntImplementPluginInterface($pluginClass);
            }

            self::loadPluginConfiguration($pluginClass);

            self::loadPluginServices($pluginClass);

            self::registerPluginDefinition($pluginClass);
        }
    }

    protected static function loadPluginConfiguration(string $pluginClass): void
    {
        $configurationPath = forward_static_call([$pluginClass, 'getConfigurationPath']);

        if (!$configurationPath) {
            return;
        }

        if (!file_exists($configurationPath)) {
            throw InvalidPlugin::configurationFileNotFound($pluginClass, $configurationPath);
        }

        $pluginConfiguration = require $configurationPath;

        if (!is_array($pluginConfiguration)) {
            throw InvalidPlugin::configurationMustBeArray($pluginClass, $configurationPath);
        }

        self::loadConfig(Arr::dot($pluginConfiguration));
    }

    protected static function loadPluginServices(string $pluginClass): void
    {
        $servicesPath = forward_static_call([$pluginClass, 'getServicesPath']);

        if (!$servicesPath) {
            return;
        }

        if (!file_exists($servicesPath)) {
            throw InvalidPlugin::serviceFileNotFound($pluginClass, $servicesPath);
        }

        self::loadServices($servicesPath);
    }

    protected static function registerPluginDefinition(string $pluginClass): void
    {
        $definition = new Definition($pluginClass);

        $definition->setAutowired(true);

        self::$container->setDefinition($pluginClass, $definition);
    }
}