Valkyrja\Cli\Routing\Router

Complexity

Total Complexity

28

Size/Duplication

Total Lines	268
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	dispatchCommand()	0	37	3
A	askToRunSimilarCommands()	0	29	2
A	addOptionsToCommand()	0	25	5
A	attemptToMatchCommand()	0	37	5
A	commandMatched()	0	9	1
A	__construct()	0	11	1
A	checkCommandNameForTypo()	0	19	4
A	dispatch()	0	18	2
A	addParametersToCommand()	0	5	1
A	addArgumentsToCommand()	0	27	4

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <melechmizrachi@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Cli\Routing;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Cli\Interaction\Enum\ExitCode;
use Valkyrja\Cli\Interaction\Factory\Contract\OutputFactory;
use Valkyrja\Cli\Interaction\Input\Contract\Input;
use Valkyrja\Cli\Interaction\Message\Answer;
use Valkyrja\Cli\Interaction\Message\Banner;
use Valkyrja\Cli\Interaction\Message\Contract\Answer as AnswerContract;
use Valkyrja\Cli\Interaction\Message\ErrorMessage;
use Valkyrja\Cli\Interaction\Message\NewLine;
use Valkyrja\Cli\Interaction\Message\Question;
use Valkyrja\Cli\Interaction\Option\Option;
use Valkyrja\Cli\Interaction\Output\Contract\Output;
use Valkyrja\Cli\Middleware;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandDispatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandMatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandNotMatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\ExitedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\ThrowableCaughtHandler;
use Valkyrja\Cli\Routing\Collection\Contract\Collection;
use Valkyrja\Cli\Routing\Command\HelpCommand;

The type Valkyrja\Cli\Routing\Command\HelpCommand was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Cli\Routing\Contract\Router as Contract;
use Valkyrja\Cli\Routing\Data\Contract\Command;
use Valkyrja\Cli\Routing\Data\Option\HelpOptionParameter;

The type Valkyrja\Cli\Routing\Data\Option\HelpOptionParameter was not found. Maybe you did not declare it correctly or list all dependencies?

use Valkyrja\Cli\Routing\Enum\ArgumentValueMode;
use Valkyrja\Cli\Routing\Exception\RuntimeException;
use Valkyrja\Container\Contract\Container;
use Valkyrja\Dispatcher\Contract\Dispatcher;

use function in_array;

/**
 * Class Router.
 *
 * @author Melech Mizrachi
 */
class Router implements Contract
{
    public function __construct(
        protected Container $container = new \Valkyrja\Container\Container(),
        protected Dispatcher $dispatcher = new \Valkyrja\Dispatcher\Dispatcher(),
        protected Collection $collection = new \Valkyrja\Cli\Routing\Collection\Collection(),
        protected OutputFactory $outputFactory = new \Valkyrja\Cli\Interaction\Factory\OutputFactory(),
        protected ThrowableCaughtHandler $throwableCaughtHandler = new Middleware\Handler\ThrowableCaughtHandler(),
        protected CommandMatchedHandler $commandMatchedHandler = new Middleware\Handler\CommandMatchedHandler(),
        protected CommandNotMatchedHandler $commandNotMatchedHandler = new Middleware\Handler\CommandNotMatchedHandler(),
        protected CommandDispatchedHandler $commandDispatchedHandler = new Middleware\Handler\CommandDispatchedHandler(),
        protected ExitedHandler $exitedHandler = new Middleware\Handler\ExitedHandler(),
    ) {
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function dispatch(Input $input): Output
    {
        // Attempt to match the command
        $matchedCommand = $this->attemptToMatchCommand($input);

        // If the command was not matched an output returned
        if ($matchedCommand instanceof Output) {
            // Dispatch RouteNotMatchedMiddleware
            return $this->commandNotMatchedHandler->commandNotMatched(
                input: $input,
                output: $matchedCommand
            );
        }

        return $this->dispatchCommand(
            input: $input,
            command: $matchedCommand
        );
    }

    /**
     * @inheritDoc
     */
    #[Override]
    public function dispatchCommand(Input $input, Command $command): Output
    {
        // The command has been matched
        $this->commandMatched($command);

        // Dispatch the RouteMatchedMiddleware
        $commandAfterMiddleware = $this->commandMatchedHandler->commandMatched(
            input: $input,
            command: $command
        );

        // If the return value after middleware is an output return it
        if ($commandAfterMiddleware instanceof Output) {
            return $commandAfterMiddleware;
        }

        // Set the command after middleware has potentially modified it in the service container
        $this->container->setSingleton(Command::class, $commandAfterMiddleware);

        $dispatch  = $commandAfterMiddleware->getDispatch();
        $arguments = $dispatch->getArguments();

        // Attempt to dispatch the route using any one of the callable options
        $output = $this->dispatcher->dispatch(
            dispatch: $dispatch,
            arguments: $arguments
        );

        if (! $output instanceof Output) {
            throw new RuntimeException('All commands must return an output');
        }

        return $this->commandDispatchedHandler->commandDispatched(
            input: $input,
            output: $output,
            command: $commandAfterMiddleware
        );
    }

    /**
     * Match a command, or a response if no command exists, from a given input.
     */
    protected function attemptToMatchCommand(Input $input): Command|Output
    {
        $commandName = $input->getCommandName();

        // Try to get the command
        $command = $this->collection->get(
            name: $commandName
        );

        // Return the command if it was found
        if ($command !== null) {
            if (
                $input->hasOption(HelpOptionParameter::NAME)
                || $input->hasOption(HelpOptionParameter::SHORT_NAME)
            ) {
                $command = $this->collection->get(name: HelpCommand::NAME);
                $input   = $input->withOptions(
                    new Option('command', $commandName),
                );

                if ($command === null) {
                    throw new RuntimeException('Help command does not exist');
                }
            }

            return $this->addParametersToCommand($input, $command);
        }

        $errorText = "Command `$commandName` was not found.";

        $output = $this->outputFactory
            ->createOutput(exitCode: ExitCode::ERROR)
            ->withMessages(
                new Banner(new ErrorMessage($errorText))
            );

        return $this->checkCommandNameForTypo($input, $output);
    }

    /**
     * Add the parameters from the input to the command.
     */
    protected function addParametersToCommand(Input $input, Command $command): Command
    {
        $command = $this->addArgumentsToCommand($input, $command);

        return $this->addOptionsToCommand($input, $command);
    }

    /**
     * Add the arguments from the input to the command.
     */
    protected function addArgumentsToCommand(Input $input, Command $command): Command
    {
        $arguments          = [...$input->getArguments()];
        $argumentParameters = $command->getArguments();

        foreach ($argumentParameters as $key => $argumentParameter) {
            $argumentParameterArguments = [];

            // Array arguments must be last, and will take up all the remaining arguments from the input
            if ($argumentParameter->getValueMode() === ArgumentValueMode::ARRAY) {
                $argumentParameterArguments = $arguments;

                $arguments = [];
            } elseif (isset($arguments[$key])) {
                // If not an array type then we should match each argument in order of appearance
                $argumentParameterArguments[] = $arguments[$key];

                unset($arguments[$key]);
            }

            $argumentParameters[$key] = $argumentParameter
                ->withArguments(...$argumentParameterArguments)

$argumentParameterArguments of type Valkyrja\Cli\Interaction\Argument\Contract\Argument[] is incompatible with the type Valkyrja\Cli\Interaction\Argument\Contract\Argument expected by parameter $arguments of Valkyrja\Cli\Routing\Data\Contract\ArgumentParameter::withArguments().

                ->validateValues();
        }

        return $command
            ->withArguments(...$argumentParameters);
    }

    /**
     * Add the options from the input to the command.
     */
    protected function addOptionsToCommand(Input $input, Command $command): Command
    {
        $options          = $input->getOptions();
        $optionParameters = [...$command->getOptions()];

        foreach ($optionParameters as $key => $optionParameter) {
            $optionParameterOptions = [];

            foreach ($options as $option) {
                // Add the option only if it matches the name or one of the short names
                if (
                    $optionParameter->getName() === $option->getName()
                    || in_array($option->getName(), $optionParameter->getShortNames(), true)
                ) {
                    $optionParameterOptions[] = $option;
                }
            }

            $optionParameters[$key] = $optionParameter
                ->withOptions(...$optionParameterOptions)
                ->validateValues();
        }

        return $command
            ->withOptions(...$optionParameters);
    }

    /**
     * Check the command name from the input for a typo.
     */
    protected function checkCommandNameForTypo(Input $input, Output $output): Command|Output
    {
        $name = $input->getCommandName();

        $commands = [];

        foreach ($this->collection->all() as $command) {
            similar_text($command->getName(), $name, $percent);

            if ($percent >= 60) {
                $commands[] = $command;
            }
        }

        if ($commands !== []) {
            return $this->askToRunSimilarCommands($output, $commands);
        }

        return $output;
    }

    /**
     * Ask the user if they want to run similar commands.
     *
     * @param Command[] $commands The list of commands
     */
    protected function askToRunSimilarCommands(Output $output, array $commands): Command|Output
    {
        $command = null;

        $commandNames = array_map(static fn (Command $command) => $command->getName(), $commands);

        $output = $output
            ->withAddedMessages(
                new NewLine(),
                new Question(
                    'Did you mean to run one of the following commands?',
                    function (Output $output, AnswerContract $answer) use (&$command, $commands): Output {
                        $response = $answer->getUserResponse();
                        $command  = $response !== 'no'
                            ? array_filter($commands, static fn (Command $command): bool => $command->getName() === $response)[0] ?? null
                            : null;

                        return $output;
                    },
                    new Answer(
                        defaultResponse: 'no',
                        allowedResponses: $commandNames
                    ),
                ),
            )
            ->writeMessages();

        return $command
            ?? $output;
    }

    /**
     * Do various stuff after the route has been matched.
     */
    protected function commandMatched(Command $command): void
    {
        $this->commandMatchedHandler->add(...$command->getCommandMatchedMiddleware());
        $this->commandDispatchedHandler->add(...$command->getCommandDispatchedMiddleware());
        $this->throwableCaughtHandler->add(...$command->getThrowableCaughtMiddleware());
        $this->exitedHandler->add(...$command->getExitedMiddleware());

        // Set the found command in the service container
        $this->container->setSingleton(Command::class, $command);
    }
}