AbstractApplication::__construct() - Code Metrics - Inspection of "Se agrega soporte para comandos de cli." - derafu/derafu-lib-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6a582f...5c28cd )

by Esteban De La Fuente
created 2025-01-09 16:46 UTC
AbstractApplication::__construct() A

↳ Parent: AbstractApplication
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	2
CRAP Score	1
Importance

Changes
Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
<?php

declare(strict_types=1);

/**
 * Derafu: Biblioteca PHP (Núcleo).
 * Copyright (C) Derafu <https://www.derafu.org>
 *
 * Este programa es software libre: usted puede redistribuirlo y/o modificarlo
 * bajo los términos de la Licencia Pública General Affero de GNU publicada por
 * la Fundación para el Software Libre, ya sea la versión 3 de la Licencia, o
 * (a su elección) cualquier versión posterior de la misma.
 *
 * Este programa se distribuye con la esperanza de que sea útil, pero SIN
 * GARANTÍA ALGUNA; ni siquiera la garantía implícita MERCANTIL o de APTITUD
 * PARA UN PROPÓSITO DETERMINADO. Consulte los detalles de la Licencia Pública
 * General Affero de GNU para obtener una información más detallada.
 *
 * Debería haber recibido una copia de la Licencia Pública General Affero de GNU
 * junto a este programa.
 *
 * En caso contrario, consulte <http://www.gnu.org/licenses/agpl.html>.
 */

namespace Derafu\Lib\Core\Foundation\Abstract;

use Derafu\Lib\Core\Foundation\Adapter\ServiceAdapter;
use Derafu\Lib\Core\Foundation\Configuration;
use Derafu\Lib\Core\Foundation\Contract\ApplicationInterface;
use Derafu\Lib\Core\Foundation\Contract\ConfigurationInterface;
use Derafu\Lib\Core\Foundation\Contract\KernelInterface;
use Derafu\Lib\Core\Foundation\Contract\PackageInterface;
use Derafu\Lib\Core\Foundation\Contract\ServiceInterface;
use LogicException;
use RuntimeException;
use Symfony\Component\Console\Application as SymfonyConsoleApplication;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;

/**
 * Clase base para la clase principal de la aplicación.
 */
abstract class AbstractApplication implements ApplicationInterface
{
    /**
     * Instancia del núcleo de la aplicación.
     *
     * @var KernelInterface
     */
    private KernelInterface $kernel;

    /**
     * Instancia de la clase para el patrón singleton.
     *
     * @var self
     */
    private static self $instance;

    /**
     * Constructor de la aplicación.
     *
     * Debe ser privado para respetar el patrón singleton.
     *
     * @param string|array|null $config Configuración de la aplicación.
     * Puede ser la clase que implementa la configuración, una ruta al archivo
     * de configuración o un arreglo con la configuración.
     */
    private function __construct(string|array|null $config)
    {
        $this->initialize($config);
    }

    /**
     * Inicializa la aplicación.
     *
     * @param string|array|null $config
     */
    protected function initialize(string|array|null $config)
    {
        // Cargar configuración.
        $configuration = $this->resolveConfiguration($config);

        // Iniciar el kernel.
        $kernelClass = $configuration->getKernelClass();
        $this->kernel = new $kernelClass();
        $this->kernel->initialize($configuration);
    }

    /**
     * Resuelve y carga la configuración de la aplicación.
     *
     * @param string|array|null $config
     * @return ConfigurationInterface
     */
    protected function resolveConfiguration(
        string|array|null $config
    ): ConfigurationInterface {
        if ($config === null) {

            return new Configuration();
        }

        if (is_array($config)) {

            return new Configuration($config);
        }

        if (class_exists($config)) {
            return new $config();
        }

        return new Configuration($config);
    }

    /**
     * {@inheritdoc}
     */
    public function path(?string $path = null): string
    {
        return $this->kernel->getConfiguration()->resolvePath($path);
    }

    /**
     * {@inheritdoc}
     */
    public function config(string $name, mixed $default = null): mixed
    {
        return $this->kernel->getConfiguration()->get($name, $default);
    }

    /**
     * {@inheritdoc}
     */
    public function hasPackage(string $package): bool
    {
        $servicesPrefix = $this->kernel->getConfiguration()->getServicesPrefix();
        $service = $servicesPrefix . $package;

        return $this->kernel->getContainer()->has($service);
    }

    /**
     * {@inheritdoc}
     */
    public function getPackage(string $package): PackageInterface
    {
        $servicesPrefix = $this->kernel->getConfiguration()->getServicesPrefix();
        $service = $servicesPrefix . $package;

        try {
            $instance = $this->kernel->getContainer()->get($service);
        } catch (ServiceNotFoundException $e) {
            $instance = null;
        }

        if (!$instance instanceof PackageInterface) {
            throw new LogicException(sprintf(
                'El paquete %s no existe en la aplicación.',
                $package
            ));
        }

        $config = $this->kernel->getConfiguration()->getPackageConfiguration(
            $package
        );
        $instance->setConfiguration($config);

        return $instance;
    }

    /**
     * {@inheritdoc}
     */
    public function getPackages(): array
    {
        $packages = [];
        $ids = $this->kernel->getContainer()->findTaggedServiceIds('package');
        $servicesPrefix = $this->kernel->getConfiguration()->getServicesPrefix();
        foreach ($ids as $id => $tags) {
            $packages[str_replace($servicesPrefix, '', $id)] =
                $this->kernel->getContainer()->get($id)
            ;
        }

        return $packages;
    }

    /**
     * {@inheritdoc}
     */
    public function hasService(string $service): bool
    {
        return $this->kernel->getContainer()->has($service);
    }

    /**
     * {@inheritdoc}
     */
    public function getService(string $service): ServiceInterface
    {
        $instance = $this->kernel->getContainer()->get($service);

        if ($instance instanceof ServiceInterface) {
            return $instance;
        }

        return new ServiceAdapter($instance);
        return new ServiceAdapter(/** @scrutinizer ignore-type */ $instance);
    }

    /**
     * {@inheritdoc}
     */
    public static function getInstance(string|array|null $config = null): static
    {
        if (!isset(self::$instance)) {
            $class = static::class;
            self::$instance = new $class($config);
        }

        assert(self::$instance instanceof static);

        return self::$instance;
    }

    /**
     * {@inheritdoc}
     */
    public function run(): int
    {
        // Validar que sea una ejecución de línea de comandos.
        if (php_sapi_name() !== 'cli') {
            throw new RuntimeException(
                'Esta aplicación solo puede ejecutarse en la línea de comandos.'
            );
        }

        // Crear instancia de Symfony Console Application.
        $consoleApp = new SymfonyConsoleApplication();

        // Registrar comandos del contenedor.
        $commands = $this->kernel
            ->getContainer()
            ->findTaggedServiceIds('service:command')
        ;
        foreach ($commands as $id => $tags) {
            $command = $this->kernel->getContainer()->get($id);
            if ($command instanceof Command) {
                $consoleApp->add($command);
            }
        }

        // Ejecutar la consola.
        return $consoleApp->run();
    }
}

derafu / derafu-lib-core

Push — master ( 6a582f...5c28cd )

AbstractApplication::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
