21825447715

Committed 09 Feb 2026 12:39PM UTC coverage: 92.955% (-0.001%) from 92.956%

Build # 21825447715

Build Type

push

github

Committed by

web-flow

Commit Message

UX: enable parallel runner by default (#9408)

Coverage Stats

2 of 2 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

29293 of 31513 relevant lines covered (92.96%)

43.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.01

/src/Console/Command/FixCommand.php

<?php

declare(strict_types=1);

/*
 * This file is part of PHP CS Fixer.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *     Dariusz Rumiński <dariusz.ruminski@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace PhpCsFixer\Console\Command;

use PhpCsFixer\Config;
use PhpCsFixer\ConfigInterface;
use PhpCsFixer\ConfigurationException\InvalidConfigurationException;
use PhpCsFixer\Console\Application;
use PhpCsFixer\Console\ConfigurationResolver;
use PhpCsFixer\Console\Output\ErrorOutput;
use PhpCsFixer\Console\Output\OutputContext;
use PhpCsFixer\Console\Output\Progress\ProgressOutputFactory;
use PhpCsFixer\Console\Output\Progress\ProgressOutputType;
use PhpCsFixer\Console\Report\FixReport\ReporterFactory;
use PhpCsFixer\Console\Report\FixReport\ReportSummary;
use PhpCsFixer\Error\ErrorsManager;
use PhpCsFixer\Fixer\FixerInterface;
use PhpCsFixer\FixerFactory;
use PhpCsFixer\RuleSet\RuleSets;
use PhpCsFixer\Runner\Event\FileProcessed;
use PhpCsFixer\Runner\Runner;
use PhpCsFixer\ToolInfoInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Console\Terminal;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Stopwatch\Stopwatch;

/**
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
 *
 * @final
 *
 * @TODO 4.0: mark as final
 *
 * @internal
 *
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise.
 */
#[AsCommand(name: 'fix', description: 'Fixes a directory or a file.')]
/* final */ class FixCommand extends Command
{
    /** @TODO PHP 8.0 - remove the property */
    protected static $defaultName = 'fix';

    /** @TODO PHP 8.0 - remove the property */
    protected static $defaultDescription = 'Fixes a directory or a file.';

    private EventDispatcherInterface $eventDispatcher;

    private ErrorsManager $errorsManager;

    private Stopwatch $stopwatch;

    private ConfigInterface $defaultConfig;

    private ToolInfoInterface $toolInfo;

    private ProgressOutputFactory $progressOutputFactory;

    public function __construct(ToolInfoInterface $toolInfo)
    {
        parent::__construct();

        $this->eventDispatcher = new EventDispatcher();
        $this->errorsManager = new ErrorsManager();
        $this->stopwatch = new Stopwatch();
        $this->defaultConfig = new Config();
        $this->toolInfo = $toolInfo;
        $this->progressOutputFactory = new ProgressOutputFactory();
    }

    /**
     * {@inheritdoc}
     *
     * Override here to only generate the help copy when used.
     */
    public function getHelp(): string
    {
        return <<<'EOF'
            The <info>%command.name%</info> command tries to %command.name% as much coding standards
            problems as possible on a given file or files in a given directory and its subdirectories:

                <info>$ php %command.full_name% /path/to/dir</info>
                <info>$ php %command.full_name% /path/to/file</info>

            By default <comment>--path-mode</comment> is set to `override`, which means, that if you specify the path to a file or a directory via
            command arguments, then the paths provided to a `Finder` in config file will be ignored. You can use <comment>--path-mode=intersection</comment>
            to merge paths from the config file and from the argument:

                <info>$ php %command.full_name% --path-mode=intersection /path/to/dir</info>

            The <comment>--format</comment> option for the output format. Supported formats are `@auto` (default one on v4+), `txt` (default one on v3), `json`, `xml`, `checkstyle`, `junit` and `gitlab`.

            * `@auto` aims to auto-select best reporter for given CI or local execution (resolution into best format is outside of BC promise and is future-ready)
              * `gitlab` for GitLab
            * `@auto,{format}` takes `@auto` under CI, and {format} otherwise

            NOTE: the output for the following formats are generated in accordance with schemas

            * `checkstyle` follows the common `"checkstyle" XML schema </doc/schemas/fix/checkstyle.xsd>`_
            * `gitlab` follows the `codeclimate JSON schema </doc/schemas/fix/codeclimate.json>`_
            * `json` follows the `own JSON schema </doc/schemas/fix/schema.json>`_
            * `junit` follows the `JUnit XML schema from Jenkins </doc/schemas/fix/junit-10.xsd>`_
            * `xml` follows the `own XML schema </doc/schemas/fix/xml.xsd>`_

            The <comment>--quiet</comment> Do not output any message.

            The <comment>--verbose</comment> option will show the applied rules. When using the `txt` format it will also display progress notifications.

            NOTE: if there is an error like "errors reported during linting after fixing", you can use this to be even more verbose for debugging purpose

            * `-v`: verbose
            * `-vv`: very verbose
            * `-vvv`: debug

            EOF. /* @TODO: 4.0 - change to @PER */ <<<'EOF'

            The <comment>--rules</comment> option allows to explicitly select rules to use,
            overriding the default PSR-12 or your own project config:

                <info>$ php %command.full_name% . --rules=line_ending,full_opening_tag,indentation_type</info>

            You can also exclude the rules you don't want by placing a dash in front of the rule name, like <comment>-name_of_fixer</comment>.

                <info>$ php %command.full_name% . --rules=@Symfony,-@PSR1,-blank_line_before_statement,strict_comparison</info>

            Complete configuration for rules can be supplied using a `json` formatted string as well.

                <info>$ php %command.full_name% . --rules='{"concat_space": {"spacing": "none"}}'</info>

            The <comment>--dry-run</comment> flag will run the fixer without making changes to your files.

            The <comment>--sequential</comment> flag will enforce sequential analysis even if parallel config is provided.

            The <comment>--diff</comment> flag can be used to let the fixer output all the changes it makes.

            The <comment>--allow-risky</comment> option (pass `yes` or `no`) allows you to set whether risky rules may run. Default value is taken from config file.
            A rule is considered risky if it could change code behaviour. By default no risky rules are run.

            The <comment>--stop-on-violation</comment> flag stops the execution upon first file that needs to be fixed.

            The <comment>--show-progress</comment> option allows you to choose the way process progress is rendered:

            * <comment>none</comment>: disables progress output;
            * <comment>dots</comment>: multiline progress output with number of files and percentage on each line.
            * <comment>bar</comment>: single line progress output with number of files and calculated percentage.

            If the option is not provided, it defaults to <comment>bar</comment> unless a config file that disables output is used, in which case it defaults to <comment>none</comment>. This option has no effect if the verbosity of the command is less than <comment>verbose</comment>.

                <info>$ php %command.full_name% --verbose --show-progress=dots</info>

            By using <comment>--using-cache</comment> option with `yes` or `no` you can set if the caching
            mechanism should be used.

            The command can also read from standard input, in which case it won't
            automatically fix anything:

                <info>$ cat foo.php | php %command.full_name% --diff -</info>

            Finally, if you don't need BC kept on CLI level, you might use `PHP_CS_FIXER_FUTURE_MODE` to start using options that
            would be default in next MAJOR release and to forbid using deprecated configuration:

                <info>$ PHP_CS_FIXER_FUTURE_MODE=1 php %command.full_name% -v --diff</info>

            Exit code
            ---------

            Exit code of the `%command.name%` command is built using following bit flags:

            *  0 - OK.
            *  1 - General error (or PHP minimal requirement not matched).
            *  4 - Some files have invalid syntax (only in dry-run mode).
            *  8 - Some files need fixing (only in dry-run mode).
            * 16 - Configuration error of the application.
            * 32 - Configuration error of a Fixer.
            * 64 - Exception raised within the application.

            EOF;
    }

    protected function configure(): void
    {
        $reporterFactory = new ReporterFactory();
        $reporterFactory->registerBuiltInReporters();
        $formats = $reporterFactory->getFormats();
        array_unshift($formats, '@auto', '@auto,txt');

        $progressOutputTypes = ProgressOutputType::all();

        $this->setDefinition(
            [
                new InputArgument('path', InputArgument::IS_ARRAY, 'The path(s) that rules will be run against (each path can be a file or directory).'),
                new InputOption('path-mode', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Specify path mode (%s).', ConfigurationResolver::PATH_MODE_VALUES), ConfigurationResolver::PATH_MODE_OVERRIDE, ConfigurationResolver::PATH_MODE_VALUES),
                new InputOption('allow-risky', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Are risky fixers allowed (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),
                new InputOption('config', '', InputOption::VALUE_REQUIRED, 'The path to a config file.'),
                new InputOption('dry-run', '', InputOption::VALUE_NONE, 'Only shows which files would have been modified.'),
                new InputOption('rules', '', InputOption::VALUE_REQUIRED, 'List of rules that should be run against configured paths.', null, static function () {
                    $fixerFactory = new FixerFactory();
                    $fixerFactory->registerBuiltInFixers();
                    $fixers = array_map(static fn (FixerInterface $fixer) => $fixer->getName(), $fixerFactory->getFixers());

                    return array_merge(RuleSets::getSetDefinitionNames(), $fixers);
                }),
                new InputOption('using-cache', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Should cache be used (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),
                new InputOption('allow-unsupported-php-version', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Should the command refuse to run on unsupported PHP version (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),
                new InputOption('cache-file', '', InputOption::VALUE_REQUIRED, 'The path to the cache file.'),
                new InputOption('diff', '', InputOption::VALUE_NONE, 'Prints diff for each file.'),
                new InputOption('format', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('To output results in other formats (%s).', $formats), null, $formats),
                new InputOption('stop-on-violation', '', InputOption::VALUE_NONE, 'Stop execution on first violation.'),
                new InputOption('show-progress', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Type of progress indicator (%s).', $progressOutputTypes), null, $progressOutputTypes),
                new InputOption('sequential', '', InputOption::VALUE_NONE, 'Enforce sequential analysis.'),
            ],
        );
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $verbosity = $output->getVerbosity();

        $passedConfig = $input->getOption('config');
        $passedRules = $input->getOption('rules');

        if (null !== $passedConfig && ConfigurationResolver::IGNORE_CONFIG_FILE !== $passedConfig && null !== $passedRules) {
            throw new InvalidConfigurationException('Passing both `--config` and `--rules` options is not allowed.');
        }

        $resolver = new ConfigurationResolver(
            $this->defaultConfig,
            [
                'allow-risky' => $input->getOption('allow-risky'),
                'config' => $passedConfig,
                'dry-run' => $this->isDryRun($input),
                'rules' => $passedRules,
                'path' => $input->getArgument('path'),
                'path-mode' => $input->getOption('path-mode'),
                'using-cache' => $input->getOption('using-cache'),
                'allow-unsupported-php-version' => $input->getOption('allow-unsupported-php-version'),
                'cache-file' => $input->getOption('cache-file'),
                'format' => $input->getOption('format'),
                'diff' => $input->getOption('diff'),
                'stop-on-violation' => $input->getOption('stop-on-violation'),
                'verbosity' => $verbosity,
                'show-progress' => $input->getOption('show-progress'),
                'sequential' => $input->getOption('sequential'),
            ],
            getcwd(), // @phpstan-ignore argument.type
            $this->toolInfo,
        );

        $reporter = $resolver->getReporter();

        $stdErr = $output instanceof ConsoleOutputInterface
            ? $output->getErrorOutput()
            : ('txt' === $reporter->getFormat() ? $output : null);

        if (null !== $stdErr) {
            $stdErr->writeln(Application::getAboutWithRuntime(true));

            if (version_compare(\PHP_VERSION, ConfigInterface::PHP_VERSION_SYNTAX_SUPPORTED.'.99', '>')) {
                $message = \sprintf(
                    'PHP CS Fixer currently supports PHP syntax only up to PHP %s, current PHP version: %s.',
                    ConfigInterface::PHP_VERSION_SYNTAX_SUPPORTED,
                    \PHP_VERSION,
                );

                if (!$resolver->getUnsupportedPhpVersionAllowed()) {
                    $message .= ' Add `Config::setUnsupportedPhpVersionAllowed(true)` to allow executions on unsupported PHP versions. Such execution may be unstable and you may experience code modified in a wrong way.';
                    $stdErr->writeln(\sprintf(
                        $stdErr->isDecorated() ? '<bg=red;fg=white;>%s</>' : '%s',
                        $message,
                    ));

                    return 1;
                }
                $message .= ' Execution may be unstable. You may experience code modified in a wrong way. Please report such cases at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer. Remove Config::setUnsupportedPhpVersionAllowed(true) to allow executions only on supported PHP versions.';
                $stdErr->writeln(\sprintf(
                    $stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s',
                    $message,
                ));
            }

            $configFile = $resolver->getConfigFile();
            $stdErr->writeln(\sprintf('Loaded config <comment>%s</comment>%s.', $resolver->getConfig()->getName(), null === $configFile ? '' : ' from "'.$configFile.'"'));

            if (null === $configFile && ConfigurationResolver::IGNORE_CONFIG_FILE !== $passedConfig && null === $passedRules) {
                if (false === $input->isInteractive()) {
                    $stdErr->writeln(
                        \sprintf(
                            $stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s',
                            'No config file found. Please create one using `php-cs-fixer init`.',
                        ),
                    );
                } else {
                    $io = new SymfonyStyle($input, $stdErr);
                    $shallCreateConfigFile = 'yes' === $io->choice(
                        'Do you want to create the config file?',
                        ['yes', 'no'],
                        'yes',
                    );
                    if ($shallCreateConfigFile) {
                        $returnCode = $this->getApplication()->doRun(
                            new ArrayInput([
                                'command' => 'init',
                            ]),
                            $output,
                        );
                        $stdErr->writeln('Config file created, re-run the command to put it in action.');

                        return $returnCode;
                    }
                }
            }

            $isParallel = $resolver->getParallelConfig()->getMaxProcesses() > 1;

            $stdErr->writeln(\sprintf(
                'Running analysis on %d core%s.',
                $resolver->getParallelConfig()->getMaxProcesses(),
                $isParallel ? \sprintf(
                    's with %d file%s per process',
                    $resolver->getParallelConfig()->getFilesPerProcess(),
                    $resolver->getParallelConfig()->getFilesPerProcess() > 1 ? 's' : '',
                ) : ' sequentially',
            ));

            if ($resolver->getUsingCache()) {
                $cacheFile = $resolver->getCacheFile();

                if (is_file($cacheFile)) {
                    $stdErr->writeln(\sprintf('Using cache file "%s".', $cacheFile));
                }
            }
        }

        $finder = new \ArrayIterator(array_filter(
            iterator_to_array($resolver->getFinder()),
            static fn (\SplFileInfo $fileInfo) => false !== $fileInfo->getRealPath(),
        ));

        if (null !== $stdErr) {
            if ($resolver->configFinderIsOverridden()) {
                $stdErr->writeln(
                    \sprintf($stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s', 'Paths from configuration have been overridden by paths provided as command arguments.'),
                );
            }

            if ($resolver->configRulesAreOverridden()) {
                $stdErr->writeln(
                    \sprintf($stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s', 'Rules from configuration have been overridden by rules provided as command argument.'),
                );
            }
        }

        $progressType = $resolver->getProgressType();
        $progressOutput = $this->progressOutputFactory->create(
            $progressType,
            new OutputContext(
                $stdErr,
                (new Terminal())->getWidth(),
                \count($finder),
            ),
        );

        $runner = new Runner(
            $finder,
            $resolver->getFixers(),
            $resolver->getDiffer(),
            ProgressOutputType::NONE !== $progressType ? $this->eventDispatcher : null,
            $this->errorsManager,
            $resolver->getLinter(),
            $resolver->isDryRun(),
            $resolver->getCacheManager(),
            $resolver->getDirectory(),
            $resolver->shouldStopOnViolation(),
            $resolver->getParallelConfig(),
            $input,
            $resolver->getConfigFile(),
            $resolver->getRuleCustomisationPolicy(),
        );

        $this->eventDispatcher->addListener(FileProcessed::NAME, [$progressOutput, 'onFixerFileProcessed']);
        $this->stopwatch->start('fixFiles');
        $changed = $runner->fix();
        $this->stopwatch->stop('fixFiles');
        $this->eventDispatcher->removeListener(FileProcessed::NAME, [$progressOutput, 'onFixerFileProcessed']);

        $progressOutput->printLegend();

        $fixEvent = $this->stopwatch->getEvent('fixFiles');

        $reportSummary = new ReportSummary(
            $changed,
            \count($finder),
            (int) $fixEvent->getDuration(), // ignore microseconds fraction
            memory_get_peak_usage(true) + $runner->getWorkersMemoryUsage(),
            OutputInterface::VERBOSITY_VERBOSE <= $verbosity,
            $resolver->isDryRun(),
            $output->isDecorated(),
        );

        $output->isDecorated()
            ? $output->write($reporter->generate($reportSummary))
            : $output->write($reporter->generate($reportSummary), false, OutputInterface::OUTPUT_RAW);

        $invalidErrors = $this->errorsManager->getInvalidErrors();
        $exceptionErrors = $this->errorsManager->getExceptionErrors();
        $lintErrors = $this->errorsManager->getLintErrors();

        if (null !== $stdErr) {
            $errorOutput = new ErrorOutput($stdErr);

            if (\count($invalidErrors) > 0) {
                $errorOutput->listErrors('linting before fixing', $invalidErrors);
            }

            if (\count($exceptionErrors) > 0) {
                $errorOutput->listErrors('fixing', $exceptionErrors);
                if ($isParallel) {
                    $stdErr->writeln('To see details of the error(s), re-run the command with `--sequential -vvv [file]`');
                }
            }

            if (\count($lintErrors) > 0) {
                $errorOutput->listErrors('linting after fixing', $lintErrors);
            }
        }

        $exitStatusCalculator = new FixCommandExitStatusCalculator();

        return $exitStatusCalculator->calculate(
            $resolver->isDryRun(),
            \count($changed) > 0,
            \count($invalidErrors) > 0,
            \count($exceptionErrors) > 0,
            \count($lintErrors) > 0,
        );
    }

    protected function isDryRun(InputInterface $input): bool
    {
        return $input->getOption('dry-run'); // @phpstan-ignore symfonyConsole.optionNotFound (Because PHPStan doesn't recognise the method is overridden in the child class and this parameter is _not_ used in the child class.)
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/*
6	* This file is part of PHP CS Fixer.
7	*
8	* (c) Fabien Potencier <fabien@symfony.com>
9	* Dariusz Rumiński <dariusz.ruminski@gmail.com>
10	*
11	* This source file is subject to the MIT license that is bundled
12	* with this source code in the file LICENSE.
13	*/
14
15	namespace PhpCsFixer\Console\Command;
16
17	use PhpCsFixer\Config;
18	use PhpCsFixer\ConfigInterface;
19	use PhpCsFixer\ConfigurationException\InvalidConfigurationException;
20	use PhpCsFixer\Console\Application;
21	use PhpCsFixer\Console\ConfigurationResolver;
22	use PhpCsFixer\Console\Output\ErrorOutput;
23	use PhpCsFixer\Console\Output\OutputContext;
24	use PhpCsFixer\Console\Output\Progress\ProgressOutputFactory;
25	use PhpCsFixer\Console\Output\Progress\ProgressOutputType;
26	use PhpCsFixer\Console\Report\FixReport\ReporterFactory;
27	use PhpCsFixer\Console\Report\FixReport\ReportSummary;
28	use PhpCsFixer\Error\ErrorsManager;
29	use PhpCsFixer\Fixer\FixerInterface;
30	use PhpCsFixer\FixerFactory;
31	use PhpCsFixer\RuleSet\RuleSets;
32	use PhpCsFixer\Runner\Event\FileProcessed;
33	use PhpCsFixer\Runner\Runner;
34	use PhpCsFixer\ToolInfoInterface;
35	use Symfony\Component\Console\Attribute\AsCommand;
36	use Symfony\Component\Console\Command\Command;
37	use Symfony\Component\Console\Input\ArrayInput;
38	use Symfony\Component\Console\Input\InputArgument;
39	use Symfony\Component\Console\Input\InputInterface;
40	use Symfony\Component\Console\Input\InputOption;
41	use Symfony\Component\Console\Output\ConsoleOutputInterface;
42	use Symfony\Component\Console\Output\OutputInterface;
43	use Symfony\Component\Console\Style\SymfonyStyle;
44	use Symfony\Component\Console\Terminal;
45	use Symfony\Component\EventDispatcher\EventDispatcher;
46	use Symfony\Component\EventDispatcher\EventDispatcherInterface;
47	use Symfony\Component\Stopwatch\Stopwatch;
48
49	/**
50	* @author Fabien Potencier <fabien@symfony.com>
51	* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
52	*
53	* @final
54	*
55	* @TODO 4.0: mark as final
56	*
57	* @internal
58	*
59	* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
60	*/
61	#[AsCommand(name: 'fix', description: 'Fixes a directory or a file.')]
62	/* final */ class FixCommand extends Command
63	{
64	/** @TODO PHP 8.0 - remove the property */
65	protected static $defaultName = 'fix';
66
67	/** @TODO PHP 8.0 - remove the property */
68	protected static $defaultDescription = 'Fixes a directory or a file.';
69
70	private EventDispatcherInterface $eventDispatcher;
71
72	private ErrorsManager $errorsManager;
73
74	private Stopwatch $stopwatch;
75
76	private ConfigInterface $defaultConfig;
77
78	private ToolInfoInterface $toolInfo;
79
80	private ProgressOutputFactory $progressOutputFactory;
81
82	public function __construct(ToolInfoInterface $toolInfo)
83	{
84	parent::__construct();	5✔
85
86	$this->eventDispatcher = new EventDispatcher();	5✔
87	$this->errorsManager = new ErrorsManager();	5✔
88	$this->stopwatch = new Stopwatch();	5✔
89	$this->defaultConfig = new Config();	5✔
90	$this->toolInfo = $toolInfo;	5✔
91	$this->progressOutputFactory = new ProgressOutputFactory();	5✔
92	}
93
94	/**
95	* {@inheritdoc}
96	*
97	* Override here to only generate the help copy when used.
98	*/
99	public function getHelp(): string
100	{
101	return <<<'EOF'	×
102	The <info>%command.name%</info> command tries to %command.name% as much coding standards
103	problems as possible on a given file or files in a given directory and its subdirectories:
104
105	<info>$ php %command.full_name% /path/to/dir</info>
106	<info>$ php %command.full_name% /path/to/file</info>
107
108	By default <comment>--path-mode</comment> is set to `override`, which means, that if you specify the path to a file or a directory via
109	command arguments, then the paths provided to a `Finder` in config file will be ignored. You can use <comment>--path-mode=intersection</comment>
110	to merge paths from the config file and from the argument:
111
112	<info>$ php %command.full_name% --path-mode=intersection /path/to/dir</info>
113
114	The <comment>--format</comment> option for the output format. Supported formats are `@auto` (default one on v4+), `txt` (default one on v3), `json`, `xml`, `checkstyle`, `junit` and `gitlab`.
115
116	* `@auto` aims to auto-select best reporter for given CI or local execution (resolution into best format is outside of BC promise and is future-ready)
117	* `gitlab` for GitLab
118	* `@auto,{format}` takes `@auto` under CI, and {format} otherwise
119
120	NOTE: the output for the following formats are generated in accordance with schemas
121
122	* `checkstyle` follows the common `"checkstyle" XML schema </doc/schemas/fix/checkstyle.xsd>`_
123	* `gitlab` follows the `codeclimate JSON schema </doc/schemas/fix/codeclimate.json>`_
124	* `json` follows the `own JSON schema </doc/schemas/fix/schema.json>`_
125	* `junit` follows the `JUnit XML schema from Jenkins </doc/schemas/fix/junit-10.xsd>`_
126	* `xml` follows the `own XML schema </doc/schemas/fix/xml.xsd>`_
127
128	The <comment>--quiet</comment> Do not output any message.
129
130	The <comment>--verbose</comment> option will show the applied rules. When using the `txt` format it will also display progress notifications.
131
132	NOTE: if there is an error like "errors reported during linting after fixing", you can use this to be even more verbose for debugging purpose
133
134	* `-v`: verbose
135	* `-vv`: very verbose
136	* `-vvv`: debug
137
138	EOF. /* @TODO: 4.0 - change to @PER */ <<<'EOF'	×
139
140	The <comment>--rules</comment> option allows to explicitly select rules to use,
141	overriding the default PSR-12 or your own project config:
142
143	<info>$ php %command.full_name% . --rules=line_ending,full_opening_tag,indentation_type</info>
144
145	You can also exclude the rules you don't want by placing a dash in front of the rule name, like <comment>-name_of_fixer</comment>.
146
147	<info>$ php %command.full_name% . --rules=@Symfony,-@PSR1,-blank_line_before_statement,strict_comparison</info>
148
149	Complete configuration for rules can be supplied using a `json` formatted string as well.
150
151	<info>$ php %command.full_name% . --rules='{"concat_space": {"spacing": "none"}}'</info>
152
153	The <comment>--dry-run</comment> flag will run the fixer without making changes to your files.
154
155	The <comment>--sequential</comment> flag will enforce sequential analysis even if parallel config is provided.
156
157	The <comment>--diff</comment> flag can be used to let the fixer output all the changes it makes.
158
159	The <comment>--allow-risky</comment> option (pass `yes` or `no`) allows you to set whether risky rules may run. Default value is taken from config file.
160	A rule is considered risky if it could change code behaviour. By default no risky rules are run.
161
162	The <comment>--stop-on-violation</comment> flag stops the execution upon first file that needs to be fixed.
163
164	The <comment>--show-progress</comment> option allows you to choose the way process progress is rendered:
165
166	* <comment>none</comment>: disables progress output;
167	* <comment>dots</comment>: multiline progress output with number of files and percentage on each line.
168	* <comment>bar</comment>: single line progress output with number of files and calculated percentage.
169
170	If the option is not provided, it defaults to <comment>bar</comment> unless a config file that disables output is used, in which case it defaults to <comment>none</comment>. This option has no effect if the verbosity of the command is less than <comment>verbose</comment>.
171
172	<info>$ php %command.full_name% --verbose --show-progress=dots</info>
173
174	By using <comment>--using-cache</comment> option with `yes` or `no` you can set if the caching
175	mechanism should be used.
176
177	The command can also read from standard input, in which case it won't
178	automatically fix anything:
179
180	<info>$ cat foo.php \| php %command.full_name% --diff -</info>
181
182	Finally, if you don't need BC kept on CLI level, you might use `PHP_CS_FIXER_FUTURE_MODE` to start using options that
183	would be default in next MAJOR release and to forbid using deprecated configuration:
184
185	<info>$ PHP_CS_FIXER_FUTURE_MODE=1 php %command.full_name% -v --diff</info>
186
187	Exit code
188	---------
189
190	Exit code of the `%command.name%` command is built using following bit flags:
191
192	* 0 - OK.
193	* 1 - General error (or PHP minimal requirement not matched).
194	* 4 - Some files have invalid syntax (only in dry-run mode).
195	* 8 - Some files need fixing (only in dry-run mode).
196	* 16 - Configuration error of the application.
197	* 32 - Configuration error of a Fixer.
198	* 64 - Exception raised within the application.
199
200	EOF;	×
201	}
202
203	protected function configure(): void
204	{
205	$reporterFactory = new ReporterFactory();	5✔
206	$reporterFactory->registerBuiltInReporters();	5✔
207	$formats = $reporterFactory->getFormats();	5✔
208	array_unshift($formats, '@auto', '@auto,txt');	5✔
209
210	$progressOutputTypes = ProgressOutputType::all();	5✔
211
212	$this->setDefinition(	5✔
213	[	5✔
214	new InputArgument('path', InputArgument::IS_ARRAY, 'The path(s) that rules will be run against (each path can be a file or directory).'),	5✔
215	new InputOption('path-mode', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Specify path mode (%s).', ConfigurationResolver::PATH_MODE_VALUES), ConfigurationResolver::PATH_MODE_OVERRIDE, ConfigurationResolver::PATH_MODE_VALUES),	5✔
216	new InputOption('allow-risky', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Are risky fixers allowed (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),	5✔
217	new InputOption('config', '', InputOption::VALUE_REQUIRED, 'The path to a config file.'),	5✔
218	new InputOption('dry-run', '', InputOption::VALUE_NONE, 'Only shows which files would have been modified.'),	5✔
219	new InputOption('rules', '', InputOption::VALUE_REQUIRED, 'List of rules that should be run against configured paths.', null, static function () {	5✔
220	$fixerFactory = new FixerFactory();	×
221	$fixerFactory->registerBuiltInFixers();	×
222	$fixers = array_map(static fn (FixerInterface $fixer) => $fixer->getName(), $fixerFactory->getFixers());	×
223
224	return array_merge(RuleSets::getSetDefinitionNames(), $fixers);	×
225	}),	5✔
226	new InputOption('using-cache', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Should cache be used (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),	5✔
227	new InputOption('allow-unsupported-php-version', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Should the command refuse to run on unsupported PHP version (%s).', ConfigurationResolver::BOOL_VALUES), null, ConfigurationResolver::BOOL_VALUES),	5✔
228	new InputOption('cache-file', '', InputOption::VALUE_REQUIRED, 'The path to the cache file.'),	5✔
229	new InputOption('diff', '', InputOption::VALUE_NONE, 'Prints diff for each file.'),	5✔
230	new InputOption('format', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('To output results in other formats (%s).', $formats), null, $formats),	5✔
231	new InputOption('stop-on-violation', '', InputOption::VALUE_NONE, 'Stop execution on first violation.'),	5✔
232	new InputOption('show-progress', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Type of progress indicator (%s).', $progressOutputTypes), null, $progressOutputTypes),	5✔
233	new InputOption('sequential', '', InputOption::VALUE_NONE, 'Enforce sequential analysis.'),	5✔
234	],	5✔
235	);	5✔
236	}
237
238	protected function execute(InputInterface $input, OutputInterface $output): int
239	{
240	$verbosity = $output->getVerbosity();	5✔
241
242	$passedConfig = $input->getOption('config');	5✔
243	$passedRules = $input->getOption('rules');	5✔
244
245	if (null !== $passedConfig && ConfigurationResolver::IGNORE_CONFIG_FILE !== $passedConfig && null !== $passedRules) {	5✔
246	throw new InvalidConfigurationException('Passing both `--config` and `--rules` options is not allowed.');	×
247	}
248
249	$resolver = new ConfigurationResolver(	5✔
250	$this->defaultConfig,	5✔
251	[	5✔
252	'allow-risky' => $input->getOption('allow-risky'),	5✔
253	'config' => $passedConfig,	5✔
254	'dry-run' => $this->isDryRun($input),	5✔
255	'rules' => $passedRules,	5✔
256	'path' => $input->getArgument('path'),	5✔
257	'path-mode' => $input->getOption('path-mode'),	5✔
258	'using-cache' => $input->getOption('using-cache'),	5✔
259	'allow-unsupported-php-version' => $input->getOption('allow-unsupported-php-version'),	5✔
260	'cache-file' => $input->getOption('cache-file'),	5✔
261	'format' => $input->getOption('format'),	5✔
262	'diff' => $input->getOption('diff'),	5✔
263	'stop-on-violation' => $input->getOption('stop-on-violation'),	5✔
264	'verbosity' => $verbosity,	5✔
265	'show-progress' => $input->getOption('show-progress'),	5✔
266	'sequential' => $input->getOption('sequential'),	5✔
267	],	5✔
268	getcwd(), // @phpstan-ignore argument.type	5✔
269	$this->toolInfo,	5✔
270	);	5✔
271
272	$reporter = $resolver->getReporter();	5✔
273
274	$stdErr = $output instanceof ConsoleOutputInterface	5✔
275	? $output->getErrorOutput()	×
276	: ('txt' === $reporter->getFormat() ? $output : null);	5✔
277
278	if (null !== $stdErr) {	5✔
279	$stdErr->writeln(Application::getAboutWithRuntime(true));	5✔
280
281	if (version_compare(\PHP_VERSION, ConfigInterface::PHP_VERSION_SYNTAX_SUPPORTED.'.99', '>')) {	5✔
282	$message = \sprintf(	×
283	'PHP CS Fixer currently supports PHP syntax only up to PHP %s, current PHP version: %s.',	×
284	ConfigInterface::PHP_VERSION_SYNTAX_SUPPORTED,	×
285	\PHP_VERSION,	×
286	);	×
287
288	if (!$resolver->getUnsupportedPhpVersionAllowed()) {	×
289	$message .= ' Add `Config::setUnsupportedPhpVersionAllowed(true)` to allow executions on unsupported PHP versions. Such execution may be unstable and you may experience code modified in a wrong way.';	×
290	$stdErr->writeln(\sprintf(	×
291	$stdErr->isDecorated() ? '<bg=red;fg=white;>%s</>' : '%s',	×
292	$message,	×
293	));	×
294
295	return 1;	×
296	}
297	$message .= ' Execution may be unstable. You may experience code modified in a wrong way. Please report such cases at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer. Remove Config::setUnsupportedPhpVersionAllowed(true) to allow executions only on supported PHP versions.';	×
298	$stdErr->writeln(\sprintf(	×
299	$stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s',	×
300	$message,	×
301	));	×
302	}
303
304	$configFile = $resolver->getConfigFile();	5✔
305	$stdErr->writeln(\sprintf('Loaded config <comment>%s</comment>%s.', $resolver->getConfig()->getName(), null === $configFile ? '' : ' from "'.$configFile.'"'));	5✔
306
307	if (null === $configFile && ConfigurationResolver::IGNORE_CONFIG_FILE !== $passedConfig && null === $passedRules) {	5✔
308	if (false === $input->isInteractive()) {	×
309	$stdErr->writeln(	×
310	\sprintf(	×
311	$stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s',	×
312	'No config file found. Please create one using `php-cs-fixer init`.',	×
313	),	×
314	);	×
315	} else {
316	$io = new SymfonyStyle($input, $stdErr);	×
317	$shallCreateConfigFile = 'yes' === $io->choice(	×
318	'Do you want to create the config file?',	×
319	['yes', 'no'],	×
320	'yes',	×
321	);	×
322	if ($shallCreateConfigFile) {	×
323	$returnCode = $this->getApplication()->doRun(	×
324	new ArrayInput([	×
325	'command' => 'init',	×
326	]),	×
327	$output,	×
328	);	×
329	$stdErr->writeln('Config file created, re-run the command to put it in action.');	×
330
331	return $returnCode;	×
332	}
333	}
334	}
335
336	$isParallel = $resolver->getParallelConfig()->getMaxProcesses() > 1;	5✔
337
338	$stdErr->writeln(\sprintf(	5✔
339	'Running analysis on %d core%s.',	5✔
340	$resolver->getParallelConfig()->getMaxProcesses(),	5✔
341	$isParallel ? \sprintf(	5✔
342	's with %d file%s per process',	5✔
343	$resolver->getParallelConfig()->getFilesPerProcess(),	5✔
344	$resolver->getParallelConfig()->getFilesPerProcess() > 1 ? 's' : '',	5✔
345	) : ' sequentially',	5✔
346	));	5✔
347
348	if ($resolver->getUsingCache()) {	5✔
UNCOV 349	$cacheFile = $resolver->getCacheFile();	×
350
351	if (is_file($cacheFile)) {	×
352	$stdErr->writeln(\sprintf('Using cache file "%s".', $cacheFile));	×
353	}
354	}
355	}
356
357	$finder = new \ArrayIterator(array_filter(	4✔
358	iterator_to_array($resolver->getFinder()),	4✔
359	static fn (\SplFileInfo $fileInfo) => false !== $fileInfo->getRealPath(),	4✔
360	));	4✔
361
362	if (null !== $stdErr) {	4✔
363	if ($resolver->configFinderIsOverridden()) {	4✔
364	$stdErr->writeln(	2✔
365	\sprintf($stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s', 'Paths from configuration have been overridden by paths provided as command arguments.'),	2✔
366	);	2✔
367	}
368
369	if ($resolver->configRulesAreOverridden()) {	4✔
370	$stdErr->writeln(	×
371	\sprintf($stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s', 'Rules from configuration have been overridden by rules provided as command argument.'),	×
372	);	×
373	}
374	}
375
376	$progressType = $resolver->getProgressType();	3✔
377	$progressOutput = $this->progressOutputFactory->create(	3✔
378	$progressType,	3✔
379	new OutputContext(	3✔
380	$stdErr,	3✔
381	(new Terminal())->getWidth(),	3✔
382	\count($finder),	3✔
383	),	3✔
384	);	3✔
385
386	$runner = new Runner(	3✔
387	$finder,	3✔
388	$resolver->getFixers(),	3✔
389	$resolver->getDiffer(),	3✔
390	ProgressOutputType::NONE !== $progressType ? $this->eventDispatcher : null,	3✔
391	$this->errorsManager,	3✔
392	$resolver->getLinter(),	3✔
393	$resolver->isDryRun(),	3✔
394	$resolver->getCacheManager(),	3✔
395	$resolver->getDirectory(),	3✔
396	$resolver->shouldStopOnViolation(),	3✔
397	$resolver->getParallelConfig(),	3✔
398	$input,	3✔
399	$resolver->getConfigFile(),	3✔
400	$resolver->getRuleCustomisationPolicy(),	3✔
401	);	3✔
402
403	$this->eventDispatcher->addListener(FileProcessed::NAME, [$progressOutput, 'onFixerFileProcessed']);	3✔
404	$this->stopwatch->start('fixFiles');	3✔
405	$changed = $runner->fix();	3✔
406	$this->stopwatch->stop('fixFiles');	3✔
407	$this->eventDispatcher->removeListener(FileProcessed::NAME, [$progressOutput, 'onFixerFileProcessed']);	3✔
408
409	$progressOutput->printLegend();	3✔
410
411	$fixEvent = $this->stopwatch->getEvent('fixFiles');	3✔
412
413	$reportSummary = new ReportSummary(	3✔
414	$changed,	3✔
415	\count($finder),	3✔
416	(int) $fixEvent->getDuration(), // ignore microseconds fraction	3✔
417	memory_get_peak_usage(true) + $runner->getWorkersMemoryUsage(),	3✔
418	OutputInterface::VERBOSITY_VERBOSE <= $verbosity,	3✔
419	$resolver->isDryRun(),	3✔
420	$output->isDecorated(),	3✔
421	);	3✔
422
423	$output->isDecorated()	3✔
424	? $output->write($reporter->generate($reportSummary))	×
425	: $output->write($reporter->generate($reportSummary), false, OutputInterface::OUTPUT_RAW);	3✔
426
427	$invalidErrors = $this->errorsManager->getInvalidErrors();	3✔
428	$exceptionErrors = $this->errorsManager->getExceptionErrors();	3✔
429	$lintErrors = $this->errorsManager->getLintErrors();	3✔
430
431	if (null !== $stdErr) {	3✔
432	$errorOutput = new ErrorOutput($stdErr);	3✔
433
434	if (\count($invalidErrors) > 0) {	3✔
435	$errorOutput->listErrors('linting before fixing', $invalidErrors);	×
436	}
437
438	if (\count($exceptionErrors) > 0) {	3✔
439	$errorOutput->listErrors('fixing', $exceptionErrors);	×
440	if ($isParallel) {	×
441	$stdErr->writeln('To see details of the error(s), re-run the command with `--sequential -vvv [file]`');	×
442	}
443	}
444
445	if (\count($lintErrors) > 0) {	3✔
446	$errorOutput->listErrors('linting after fixing', $lintErrors);	×
447	}
448	}
449
450	$exitStatusCalculator = new FixCommandExitStatusCalculator();	3✔
451
452	return $exitStatusCalculator->calculate(	3✔
453	$resolver->isDryRun(),	3✔
454	\count($changed) > 0,	3✔
455	\count($invalidErrors) > 0,	3✔
456	\count($exceptionErrors) > 0,	3✔
457	\count($lintErrors) > 0,	3✔
458	);	3✔
459	}
460
461	protected function isDryRun(InputInterface $input): bool
462	{
463	return $input->getOption('dry-run'); // @phpstan-ignore symfonyConsole.optionNotFound (Because PHPStan doesn't recognise the method is overridden in the child class and this parameter is _not_ used in the child class.)	5✔
464	}
465	}

PHP-CS-Fixer / PHP-CS-Fixer / 21825447715

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous