Slick\WebStack\UserInterface\Console\ModuleCommandTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	generateModuleConfig()	0	11	4
A	retrieveInstalledModules()	0	3	2
A	checkModuleNotExists()	0	18	3
A	checkConfigFile()	0	8	3
A	retrieveModuleName()	0	11	3
A	possibleNames()	0	11	1
A	checkModuleExists()	0	18	3
A	renderTable()	0	24	5

<?php

/**
 * This file is part of web-stack
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Slick\WebStack\UserInterface\Console;

use Slick\ModuleApi\Infrastructure\SlickModuleInterface;
use Slick\WebStack\Infrastructure\Exception\InvalidModuleName;
use Symfony\Component\Console\Style\SymfonyStyle;

/**
 * ModuleCommandTrait
 *
 * @package Slick\WebStack\Infrastructure
 */
trait ModuleCommandTrait
{
    /**
     * @return array<string>
     */
    public function retrieveInstalledModules(): array
    {
        return file_exists($this->moduleListFile) ? require $this->moduleListFile : [];
    }

    /**
     * Checks if a module does not exist in the given list of modules
     *
     * @param string $moduleName The name of the module to check
     * @param array<string> $modules The list of modules to check against
     * @return false|string Returns false if the module already exists, otherwise returns the modified module name
     */
    protected function checkModuleNotExists(string $moduleName, array $modules): false|string
    {
        try {
            $retrieveModuleName = $this->retrieveModuleName($moduleName);
            if (in_array(ltrim($retrieveModuleName, '\\'), $modules)) {
                $this->outputStyle?->writeln(
                    "<comment>The '$moduleName' module is already enabled. No changes have been made.</comment>"
                );
                return false;
            }
        } catch (InvalidModuleName $exception) {
            $this->outputStyle?->writeln(
                "<error>{$exception->getMessage()}</error>"
            );
            return false;
        }

        return $retrieveModuleName;
    }

    /**
     * Checks if the config file exists and creates it if it doesn't.
     *
     * @return void
     */
    private function checkConfigFile(): void
    {
        $filename = $this->moduleListFile;
        if (!file_exists($filename)) {
            if (!is_dir($this->appRoot . '/config/modules')) {
                mkdir($this->appRoot . '/config/modules', 0755, true);
            }
            file_put_contents($filename, "<?php\n\nreturn [];\n");
        }
    }

    /**
     * Generates a module configuration file contents.
     *
     * @param array<string> $modules The modules to include in the configuration file.
     *
     * @return string The generated module configuration file content.
     */
    protected function generateModuleConfig(array $modules): string
    {
        $fixed = [];
        foreach ($modules as $module) {
            $fixedModule = str_ends_with(ltrim($module, '\\'), '::class');
            $fixed[] = $fixedModule ? $module : "\\" . ltrim($module, '\\') . "::class";
        }

        return empty($fixed)
            ? "<?php\n\nreturn [];\n"
            : "<?php\n\nreturn [\n    " . implode(",\n    ", $fixed) . "\n];\n";
    }

    /**
     * Retrieves the module class name.
     *
     * @param string $moduleName The module name.
     *
     * @return class-string The module name.

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

     *
     * @throws InvalidModuleName If the module name classname cannot be determined.
     */
    protected function retrieveModuleName(string $moduleName): string
    {
        foreach ($this->possibleNames($moduleName) as $name) {
            if (class_exists($name)) {
                return $name;
            }
        }

        throw new InvalidModuleName(
            "Could not determine module name classname. Check SlickModuleInterface "
            ."implementation for module '$moduleName'"
        );
    }

    /**
     * Returns possible names for a module.
     *
     * @param string $module The name of the module.
     * @return array<string> An array containing possible names for the module.
     */
    protected function possibleNames(string $module): array
    {
        $camelCaseModule = str_replace(' ', '', ucwords(str_replace(['_', '-'], ' ', $module)));
        $withoutSuffix = str_replace('Module', '', $camelCaseModule);
        $uppercaseModule = strtoupper($withoutSuffix);
        return [
            $module,
            "\\Slick\\WebStack\\{$camelCaseModule}Module",
            "\\Slick\\$withoutSuffix\\{$camelCaseModule}Module",
            "\\Slick\\$uppercaseModule\\{$camelCaseModule}Module",
            "\\Slick\\WebStack\\$camelCaseModule",
        ];
    }

    /**
     * Checks if a module exists in the given array of modules.
     *
     * @param string $moduleName The name of the module to check.
     * @param array<string> $modules The array of modules to search in.
     * @return false|string Returns the retrieved module name if it exists, otherwise returns false.
     */
    protected function checkModuleExists(string $moduleName, array $modules): false|string
    {
        try {
            $retrieveModuleName = $this->retrieveModuleName($moduleName);
            if (!in_array(ltrim($retrieveModuleName, '\\'), $modules)) {
                $this->outputStyle?->writeln(
                    "<comment>The '$moduleName' module is not enabled. No changes have been made.</comment>"
                );
                return false;
            }
        } catch (InvalidModuleName $exception) {
            $this->outputStyle?->writeln(
                "<error>{$exception->getMessage()}</error>"
            );
            return false;
        }

        return $retrieveModuleName;
    }

    /**
     * Renders a table of available modules.
     *
     * @param array<SlickModuleInterface> $modules The array of modules to display in the table.
     * @return void
     */
    protected function renderTable(array $modules, SymfonyStyle $style): void
    {
        $installedModules = $this->retrieveInstalledModules();
        $table = $style->createTable();
        $table->setHeaderTitle("Available Modules");
        $table->setHeaders(["Name", "Description", "Enabled"]);

        foreach ($modules as $module) {
            $installed = "   <info>√</info>";
            $core = "   <fg=gray>-</>";
            $moduleName = is_object($module) ? get_class($module) : $this->retrieveModuleName($module->name());
            $notInstalled = "   <fg=red>x</>";
            $status = $this->checkModuleNotExists($moduleName, $installedModules) ? $notInstalled : $installed;
            if (in_array($module->name(), ["console", "dispatcher", "front_controller"])) {
                $status = $core;
            }
            $table->addRow([$module->name(), $module->description(), $status]);
        }
        $table->setColumnMaxWidth(1, 100);

        $table->render();
        $this->outputStyle?->write("  (<info>√</info>) enabled, ");
        $this->outputStyle?->write("(<fg=gray>-</>) core, ");
        $this->outputStyle?->write("(<fg=red>x</>) not enabled.\n");
    }
}