DebugExpression.php

<?php
declare(strict_types=1);

namespace Arkitect\CLI\Command;

use Arkitect\Analyzer\FileParserFactory;
use Arkitect\Analyzer\ParsingError;
use Arkitect\Analyzer\ParsingErrors;
use Arkitect\ClassSet;
use Arkitect\CLI\TargetPhpVersion;
use Arkitect\Rules\Violations;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class DebugExpression extends Command
{
    /** @var string|null */
    public static $defaultDescription = <<< 'EOT'
Check which classes respect an expression
EOT;

    /** @var string */
    public static $help = <<< 'EOT'
Check which classes respect an expression
EOT;

    public function __construct()
    {
        parent::__construct('debug:expression');
    }

    protected function configure(): void
    {
        $this
            ->setHelp(self::$help)
            ->addArgument('expression', InputArgument::REQUIRED)
            ->addArgument('arguments', InputArgument::IS_ARRAY)
            ->addOption(
                'from-dir',
                'd',
                InputOption::VALUE_REQUIRED,
                'The folder in which to search the classes',
                '.'
            )
            ->addOption(
                'target-php-version',
                't',
                InputOption::VALUE_OPTIONAL,
                'Target php version to use for parsing'
            );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $fileParser = $this->getParser($input);

        $classSet = ClassSet::fromDir($input->getOption('from-dir'));
        $ruleName = $input->getArgument('expression');
        /** @var class-string $ruleFQCN */
        $ruleFQCN = 'Arkitect\Expression\ForClasses\\'.$ruleName;
        $arguments = $input->getArgument('arguments');

        $argumentError = $this->getArgumentsError($arguments, $ruleName, $ruleFQCN);
        if (null !== $argumentError) {
            $output->writeln($argumentError);

            return 2;
        }

        $rule = new $ruleFQCN(...$arguments);

        foreach ($classSet as $file) {
            $result = $fileParser->parse($file->getContents(), $file->getRelativePathname());

            $this->showParsingErrors($result->parsingErrors(), $output);

            foreach ($result->classDescriptions() as $classDescription) {
                $violations = new Violations();
                $rule->evaluate($classDescription, $violations, '');
                if (0 === $violations->count()) {
                    $output->writeln($classDescription->getFQCN());
                }
            }
        }

        return 0;
    }

    /**
     * @throws \Arkitect\Exceptions\PhpVersionNotValidException
     */
    private function getParser(InputInterface $input): \Arkitect\Analyzer\Parser
    {
        $phpVersion = $input->getOption('target-php-version');
        $targetPhpVersion = TargetPhpVersion::create($phpVersion);
        $fileParser = FileParserFactory::createFileParser($targetPhpVersion, true, null);

        return $fileParser;
    }

    private function showParsingErrors(ParsingErrors $parsingErrors, OutputInterface $output): void
    {
        if (\count($parsingErrors) > 0) {
            $output->writeln('WARNING: Some files could not be parsed for these errors:');

            /** @var ParsingError $parsedError */
            foreach ($parsingErrors as $parsedError) {
                $output->writeln(' - '.$parsedError);
            }

            $output->writeln('');
        }
    }

    private function getArgumentsError(array $arguments, string $ruleName, string $ruleFQCN): ?string
    {
        try {
            /** @var class-string $ruleFQCN */
            $expressionReflection = new \ReflectionClass($ruleFQCN);
        } catch (\ReflectionException $exception) {
            return "Error: Expression '$ruleName' not found.";
        }

        $constructorReflection = $expressionReflection->getConstructor();
        if (null === $constructorReflection) {
            $maxNumberOfArguments = 0;
            $minNumberOfArguments = 0;
        } else {
            $maxNumberOfArguments = $constructorReflection->getNumberOfParameters();
            $minNumberOfArguments = $constructorReflection->getNumberOfRequiredParameters();
        }

        if (\count($arguments) < $minNumberOfArguments) {
            return "Error: Too few arguments for '$ruleName'.";
        }

        if (\count($arguments) > $maxNumberOfArguments) {
            return "Error: Too many arguments for '$ruleName'.";
        }

        return null;
    }
}