Valkyrja\Console\Command\CommandsList

Complexity

Total Complexity

23

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Importance

Changes

0

<?php
class CommandsList extends Commander
{
    use Provides;

    /** @var string */
    public const string COMMAND = 'commands';

A parse error occurred: Syntax error, unexpected T_STRING, expecting '=' on line 43 at column 24

    /** @var string */
    public const string PATH = '[' . self::COMMAND . '][ {namespace:[a-zA-Z0-9]+}]';
    /** @var string */
    public const string SHORT_DESCRIPTION = 'List all the commands';
    /** @var string */
    public const string DESCRIPTION = 'List all the commands';

    public function __construct(
        protected Console $console,
        InputContract $input = new Input(),
        OutputContract $output = new Output()
    ) {
        parent::__construct($input, $output);
    }

    /**
     * @inheritDoc
     *
     * @param string|null $namespace [optional] The namespace to show commands for
     */
    public function run(string|null $namespace = null): int
    {
        $commands        = $this->console->all();
        $longestLength   = 0;
        $previousSection = '';

        $this->filterCommands($commands, $longestLength, $namespace);

        $this->applicationMessage();
        $this->sectionDivider();

        $this->usageMessage('command [options] [arguments]');

        $this->optionsSection(...$this->input->getGlobalOptions());
        $this->sectionDivider();

        $this->sectionTitleMessage(
            'Commands' . ($namespace !== null && $namespace !== '' ? " for the \"$namespace\" namespace" : '')
        );

        foreach ($commands as $command) {
            if ($namespace === null) {
                $this->commandSection($command, $previousSection);
            }

            $this->sectionMessage(
                ($namespace === null || $namespace === '' ? static::TAB : '') . ($command->getName() ?? ''),
                $command->getDescription() ?? '',
                $longestLength + 2
            );
        }

        return ExitCode::SUCCESS;
    }

    /**
     * @inheritDoc
     */
    protected function getArguments(): array
    {
        return [
            new Argument('namespace', 'The namespace to list commands for'),
        ];
    }

    /**
     * Filter the commands by type and name.
     *
     * @param Command[]   $commands      The commands
     * @param int         $longestLength The longest length
     * @param string|null $namespace     [optional] The namespace to show commands
     *                                   for
     *
     * @return void
     */
    protected function filterCommands(array &$commands, int &$longestLength, string|null $namespace = null): void
    {
        $globalCommands = [];

        /** @var Command $command */
        foreach ($commands as $key => $command) {
            $name = $command->getName();

            if ($name === null || $name === '') {
                continue;
            }

            $parts            = explode(':', $name);
            $commandName      = $parts[1] ?? null;
            $commandNamespace = $commandName !== null && $commandName !== ''
                ? $parts[0]
                : 'global';

            // If there was a namespace passed to the command (commands
            // namespace)  and the namespace for this command doesn't match
            // what was passed then get rid of it so only commands in the
            // namespace are shown.
            if ($commandNamespace !== $namespace && $namespace !== null) {
                unset($commands[$key]);

                continue;
            }

            $longestLength = max(strlen($name), $longestLength);

            // If this is a global namespaced command
            if ($commandNamespace === 'global') {
                // Set it in the global commands array so when we show the list
                // of commands global commands will be at the top
                $globalCommands[] = $command;

                // Unset from the commands list to avoid duplicates
                unset($commands[$key]);
            }
        }

        // Sort the global commands by name
        $this->sortCommands($globalCommands);
        // Sort the rest of the commands by name
        $this->sortCommands($commands);

        // Set the commands as the merged results of the global and other
        // commands with the global commands at the top of the list
        $commands = array_merge($globalCommands, $commands);
    }

    /**
     * The command section.
     *
     * @param Command $command         The current command
     * @param string  $previousSection The previous section
     *
     * @return void
     */
    protected function commandSection(Command $command, string &$previousSection): void
    {
        $parts          = explode(':', $command->getName() ?? '');
        $commandName    = $parts[1] ?? null;
        $currentSection = $commandName !== null && $commandName !== ''
            ? $parts[0]
            : 'global';

        if ($previousSection !== $currentSection) {
            $this->output->getFormatter()->cyan();
            $this->output->writeMessage(static::TAB);
            $this->output->writeMessage($currentSection, true);

            $previousSection = $currentSection;
        }
    }

    /**
     * Sort commands by name.
     *
     * @param Command[] $commands The commands
     *
     * @return void
     */
    protected function sortCommands(array &$commands): void
    {
        usort(
            $commands,
            static fn (Command $item1, Command $item2) => $item1->getName() <=> $item2->getName()