22042339290

Committed 15 Feb 2026 08:14PM UTC coverage: 92.957% (-0.2%) from 93.171%

Build # 22042339290

Build Type

push

github

Committed by

keradus

Commit Message

test: check PHP env in CI jobs

Coverage Stats

29302 of 31522 relevant lines covered (92.96%)

44.04 hits per line

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

86.41

/src/Documentation/FixerDocumentGenerator.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\Documentation;

use PhpCsFixer\Console\Command\HelpCommand;
use PhpCsFixer\Differ\FullDiffer;
use PhpCsFixer\Fixer\ConfigurableFixerInterface;
use PhpCsFixer\Fixer\FixerInterface;
use PhpCsFixer\FixerConfiguration\AliasedFixerOption;
use PhpCsFixer\FixerConfiguration\AllowedValueSubset;
use PhpCsFixer\FixerConfiguration\DeprecatedFixerOptionInterface;
use PhpCsFixer\FixerConfiguration\FixerOptionInterface;
use PhpCsFixer\FixerDefinition\CodeSampleInterface;
use PhpCsFixer\FixerDefinition\FileSpecificCodeSampleInterface;
use PhpCsFixer\FixerDefinition\VersionSpecificCodeSampleInterface;
use PhpCsFixer\Future;
use PhpCsFixer\Preg;
use PhpCsFixer\RuleSet\AutomaticRuleSetDefinitionInterface;
use PhpCsFixer\RuleSet\DeprecatedRuleSetDefinitionInterface;
use PhpCsFixer\RuleSet\RuleSet;
use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
use PhpCsFixer\RuleSet\RuleSets;
use PhpCsFixer\StdinFileInfo;
use PhpCsFixer\Tokenizer\Tokens;
use PhpCsFixer\Utils;

/**
 * @readonly
 *
 * @internal
 *
 * @no-named-arguments Parameter names are not covered by the backward compatibility promise.
 */
final class FixerDocumentGenerator
{
    private DocumentationLocator $locator;

    private FullDiffer $differ;

    /** @var array<string, RuleSetDefinitionInterface> */
    private array $ruleSetDefinitions;

    public function __construct(DocumentationLocator $locator)
    {
        $this->locator = $locator;
        $this->differ = new FullDiffer();
        $this->ruleSetDefinitions = RuleSets::getSetDefinitions();
    }

    public function generateFixerDocumentation(FixerInterface $fixer): string
    {
        $name = $fixer->getName();
        $title = "Rule ``{$name}``";
        $titleLine = str_repeat('=', \strlen($title));
        $doc = "{$titleLine}\n{$title}\n{$titleLine}";

        $definition = $fixer->getDefinition();
        $doc .= "\n\n".RstUtils::toRst($definition->getSummary());

        $description = $definition->getDescription();

        if (null !== $description) {
            $description = RstUtils::toRst($description);
            $doc .= <<<RST


                Description
                -----------

                {$description}
                RST;
        }

        $header = static function (string $message, string $underline = '-'): string {
            $line = str_repeat($underline, \strlen($message));

            return "{$message}\n{$line}\n";
        };

        $tags = DocumentationTagGenerator::analyseRule($fixer);
        $warnings = array_map(
            static function (DocumentationTag $tag): string {
                $titleLine = str_repeat('~', \strlen($tag->title));

                return \sprintf(
                    "\n%s\n%s\n\n%s",
                    $tag->title,
                    $titleLine,
                    null === $tag->description ? '' : RstUtils::toRst($tag->description, 0),
                );
            },
            $tags,
        );

        if ([] !== $warnings) {
            $warningsHeader = 1 === \count($warnings) ? 'Warning' : 'Warnings';

            $doc .= "\n\n".$header($warningsHeader).implode("\n", $warnings);
        }

        if ($fixer instanceof ConfigurableFixerInterface) {
            $fixerInFutureMode = self::createFixerInFutureMode($fixer);

            $doc .= <<<'RST'


                Configuration
                -------------
                RST;

            $configurationDefinition = $fixer->getConfigurationDefinition();

            foreach ($configurationDefinition->getOptions() as $option) {
                $optionInfo = "``{$option->getName()}``";
                $optionInfo .= "\n".str_repeat('~', \strlen($optionInfo));

                if ($option instanceof DeprecatedFixerOptionInterface) {
                    $deprecationMessage = RstUtils::toRst($option->getDeprecationMessage());
                    $optionInfo .= "\n\n.. warning:: This option is deprecated and will be removed in the next major version. {$deprecationMessage}";
                }

                $optionInfo .= "\n\n".RstUtils::toRst($option->getDescription());

                if ($option instanceof AliasedFixerOption) {
                    $optionInfo .= "\n\n.. note:: The previous name of this option was ``{$option->getAlias()}`` but it is now deprecated and will be removed in the next major version.";
                }

                $allowed = HelpCommand::getDisplayableAllowedValues($option);

                if (null === $allowed) {
                    $allowedKind = 'Allowed types';
                    $allowedTypes = $option->getAllowedTypes();
                    if (null !== $allowedTypes) {
                        $allowed = array_map(
                            static fn (string $value): string => '``'.Utils::convertArrayTypeToList($value).'``',
                            $allowedTypes,
                        );
                    }
                } else {
                    $allowedKind = 'Allowed values';
                    $allowed = array_map(static fn ($value): string => $value instanceof AllowedValueSubset
                        ? 'a subset of ``'.Utils::toString($value->getAllowedValues()).'``'
                        : '``'.Utils::toString($value).'``', $allowed);
                }

                if (null !== $allowed) {
                    $allowed = Utils::naturalLanguageJoin($allowed, '');
                    $optionInfo .= "\n\n{$allowedKind}: {$allowed}";
                }

                if ($option->hasDefault()) {
                    $optionInfo .= \sprintf("\n\nDefault value: ``%s``", Utils::toString($option->getDefault()));

                    $optionInFutureMode = array_find(
                        $fixerInFutureMode->getConfigurationDefinition()->getOptions(),
                        static fn (FixerOptionInterface $opt): bool => $option->getName() === $opt->getName(),
                    );
                    \assert(null !== $optionInFutureMode); // if rule exist in v3, shall exist in future mode too, as it does not remove options
                    if ($optionInFutureMode->getDefault() !== $option->getDefault()) {
                        $optionInfo .= \sprintf("\n\nDefault value (future-mode): ``%s``", Utils::toString($optionInFutureMode->getDefault()));
                    }
                } else {
                    $optionInfo .= "\n\nThis option is required.";
                }

                $doc .= "\n\n{$optionInfo}";
            }
        }

        $samples = $definition->getCodeSamples();

        if (0 !== \count($samples)) {
            $doc .= <<<'RST'


                Examples
                --------
                RST;

            foreach ($samples as $index => $sample) {
                $title = \sprintf('Example #%d', $index + 1);
                $titleLine = str_repeat('~', \strlen($title));
                $doc .= "\n\n{$title}\n{$titleLine}";

                if ($fixer instanceof ConfigurableFixerInterface) {
                    if (null === $sample->getConfiguration()) {
                        $doc .= "\n\n*Default* configuration.";
                    } else {
                        $doc .= \sprintf(
                            "\n\nWith configuration: ``%s``.",
                            Utils::toString($sample->getConfiguration()),
                        );
                    }
                }

                $doc .= "\n".$this->generateSampleDiff($fixer, $sample, $index + 1, $name);
            }
        }

        $ruleSetConfigs = self::getSetsOfRule($name);

        if ([] !== $ruleSetConfigs) {
            $plural = 1 !== \count($ruleSetConfigs) ? 's' : '';
            $doc .= <<<RST


                Rule sets
                ---------

                The rule is part of the following rule set{$plural}:\n\n
                RST;

            foreach ($ruleSetConfigs as $set => $config) {
                $ruleSetPath = $this->locator->getRuleSetsDocumentationFilePath($set);
                $ruleSetPath = substr($ruleSetPath, strrpos($ruleSetPath, '/'));

                \assert(isset($this->ruleSetDefinitions[$set]));
                $ruleSetDefinition = $this->ruleSetDefinitions[$set];

                if ($ruleSetDefinition instanceof AutomaticRuleSetDefinitionInterface) {
                    continue;
                }

                $deprecatedDesc = ($ruleSetDefinition instanceof DeprecatedRuleSetDefinitionInterface) ? ' *(deprecated)*' : '';

                $configInfo = (null !== $config)
                    ? " with config:\n\n  ``".Utils::toString($config)."``\n"
                    : '';

                $doc .= <<<RST
                    - `{$set} <./../../ruleSets{$ruleSetPath}>`_{$deprecatedDesc}{$configInfo}\n
                    RST;
            }

            $doc = trim($doc);
        }

        $reflectionObject = new \ReflectionObject($fixer);
        $className = str_replace('\\', '\\\\', $reflectionObject->getName());
        $fileName = $reflectionObject->getFileName();
        $fileName = str_replace('\\', '/', $fileName);
        $fileName = substr($fileName, (int) strrpos($fileName, '/src/Fixer/') + 1);
        $fileName = "`{$className} <./../../../{$fileName}>`_";

        $testFileName = Preg::replace('~.*\K/src/(?=Fixer/)~', '/tests/', $fileName);
        $testFileName = Preg::replace('~PhpCsFixer\\\\\\\\\K(?=Fixer\\\\\\\)~', 'Tests\\\\\\\\', $testFileName);
        $testFileName = Preg::replace('~(?= <|\.php>)~', 'Test', $testFileName);

        $doc .= <<<RST


            References
            ----------

            - Fixer class: {$fileName}
            - Test class: {$testFileName}

            The test class defines officially supported behaviour. Each test case is a part of our backward compatibility promise.
            RST;

        $doc = str_replace("\t", '<TAB>', $doc);

        return "{$doc}\n";
    }

    /**
     * @internal
     *
     * @return array<string, null|array<string, mixed>>
     */
    public static function getSetsOfRule(string $ruleName): array
    {
        static $ruleSetCache = null;

        if (null === $ruleSetCache) {
            $definitionNames = array_keys(
                array_filter(
                    RuleSets::getSetDefinitions(),
                    static fn (RuleSetDefinitionInterface $definition): bool => !$definition instanceof AutomaticRuleSetDefinitionInterface,
                ),
            );
            $ruleSetCache = array_combine(
                $definitionNames,
                array_map(
                    static fn (string $name): RuleSet => new RuleSet([$name => true]),
                    $definitionNames,
                ),
            );
        }

        $ruleSetConfigs = [];

        foreach ($ruleSetCache as $set => $ruleSet) {
            if ($ruleSet->hasRule($ruleName)) {
                $ruleSetConfigs[$set] = $ruleSet->getRuleConfiguration($ruleName);
            }
        }

        return $ruleSetConfigs;
    }

    /**
     * @param list<FixerInterface> $fixers
     */
    public function generateFixersDocumentationIndex(array $fixers): string
    {
        $overrideGroups = [
            'PhpUnit' => 'PHPUnit',
            'PhpTag' => 'PHP Tag',
            'Phpdoc' => 'PHPDoc',
        ];

        usort($fixers, static fn (FixerInterface $a, FixerInterface $b): int => \get_class($a) <=> \get_class($b));

        $documentation = <<<'RST'
            =======================
            List of Available Rules
            =======================
            RST;

        $currentGroup = null;

        foreach ($fixers as $fixer) {
            $namespace = Preg::replace('/^.*\\\(.+)\\\.+Fixer$/', '$1', \get_class($fixer));
            $group = $overrideGroups[$namespace] ?? Preg::replace('/(?<=[[:lower:]])(?=[[:upper:]])/', ' ', $namespace);

            if ($group !== $currentGroup) {
                $underline = str_repeat('-', \strlen($group));
                $documentation .= "\n\n{$group}\n{$underline}\n";

                $currentGroup = $group;
            }

            $path = './'.$this->locator->getFixerDocumentationFileRelativePath($fixer);

            $tags = array_map(
                static fn (DocumentationTag $tag): string => $tag->type,
                DocumentationTagGenerator::analyseRule($fixer),
            );

            $attributes = 0 === \count($tags)
                ? ''
                : ' *('.implode(', ', $tags).')*';

            $summary = str_replace('`', '``', $fixer->getDefinition()->getSummary());

            $documentation .= <<<RST

                - `{$fixer->getName()} <{$path}>`_{$attributes}

                  {$summary}
                RST;
        }

        return "{$documentation}\n";
    }

    /**
     * @template T of FixerInterface
     *
     * @param T $fixer
     *
     * @return T
     */
    private static function createFixerInFutureMode(FixerInterface $fixer): FixerInterface
    {
        $object = Future::runWithEnforcedFutureMode(
            static fn () => (new \ReflectionObject($fixer))->newInstance(),
        );

        \assert($object instanceof $fixer);

        return $object;
    }

    private function generateSampleDiff(FixerInterface $fixer, CodeSampleInterface $sample, int $sampleNumber, string $ruleName): string
    {
        if ($sample instanceof VersionSpecificCodeSampleInterface && !$sample->isSuitableFor(\PHP_VERSION_ID)) {
            $existingFile = @file_get_contents($this->locator->getFixerDocumentationFilePath($fixer));

            if (false !== $existingFile) {
                Preg::match("/\\RExample #{$sampleNumber}\\R.+?(?<diff>\\R\\.\\. code-block:: diff\\R\\R.*?)\\R(?:\\R\\S|$)/s", $existingFile, $matches);

                if (isset($matches['diff'])) {
                    return $matches['diff'];
                }
            }

            $error = <<<RST

                .. error::
                   Cannot generate diff for code sample #{$sampleNumber} of rule {$ruleName}:
                   the sample is not suitable for current version of PHP (%s).
                RST;

            return \sprintf($error, \PHP_VERSION);
        }

        $old = $sample->getCode();

        $tokens = Tokens::fromCode($old);
        $file = $sample instanceof FileSpecificCodeSampleInterface
            ? $sample->getSplFileInfo()
            : new StdinFileInfo();

        if ($fixer instanceof ConfigurableFixerInterface) {
            $fixer->configure($sample->getConfiguration() ?? []);
        }

        $fixer->fix($file, $tokens);

        $diff = $this->differ->diff($old, $tokens->generateCode());
        $diff = Preg::replace('/@@[ \+\-\d,]+@@\n/', '', $diff);
        $diff = Preg::replace('/\r/', '^M', $diff);
        $diff = Preg::replace('/^ $/m', '', $diff);
        $diff = Preg::replace('/\n$/', '', $diff);
        $diff = RstUtils::indent($diff, 3);

        return <<<RST

            .. code-block:: diff

               {$diff}
            RST;
    }
}

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\Documentation;
16
17	use PhpCsFixer\Console\Command\HelpCommand;
18	use PhpCsFixer\Differ\FullDiffer;
19	use PhpCsFixer\Fixer\ConfigurableFixerInterface;
20	use PhpCsFixer\Fixer\FixerInterface;
21	use PhpCsFixer\FixerConfiguration\AliasedFixerOption;
22	use PhpCsFixer\FixerConfiguration\AllowedValueSubset;
23	use PhpCsFixer\FixerConfiguration\DeprecatedFixerOptionInterface;
24	use PhpCsFixer\FixerConfiguration\FixerOptionInterface;
25	use PhpCsFixer\FixerDefinition\CodeSampleInterface;
26	use PhpCsFixer\FixerDefinition\FileSpecificCodeSampleInterface;
27	use PhpCsFixer\FixerDefinition\VersionSpecificCodeSampleInterface;
28	use PhpCsFixer\Future;
29	use PhpCsFixer\Preg;
30	use PhpCsFixer\RuleSet\AutomaticRuleSetDefinitionInterface;
31	use PhpCsFixer\RuleSet\DeprecatedRuleSetDefinitionInterface;
32	use PhpCsFixer\RuleSet\RuleSet;
33	use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
34	use PhpCsFixer\RuleSet\RuleSets;
35	use PhpCsFixer\StdinFileInfo;
36	use PhpCsFixer\Tokenizer\Tokens;
37	use PhpCsFixer\Utils;
38
39	/**
40	* @readonly
41	*
42	* @internal
43	*
44	* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
45	*/
46	final class FixerDocumentGenerator
47	{
48	private DocumentationLocator $locator;
49
50	private FullDiffer $differ;
51
52	/** @var array<string, RuleSetDefinitionInterface> */
53	private array $ruleSetDefinitions;
54
55	public function __construct(DocumentationLocator $locator)
56	{
57	$this->locator = $locator;	6✔
58	$this->differ = new FullDiffer();	6✔
59	$this->ruleSetDefinitions = RuleSets::getSetDefinitions();	6✔
60	}
61
62	public function generateFixerDocumentation(FixerInterface $fixer): string
63	{
64	$name = $fixer->getName();	5✔
65	$title = "Rule ``{$name}``";	5✔
66	$titleLine = str_repeat('=', \strlen($title));	5✔
67	$doc = "{$titleLine}\n{$title}\n{$titleLine}";	5✔
68
69	$definition = $fixer->getDefinition();	5✔
70	$doc .= "\n\n".RstUtils::toRst($definition->getSummary());	5✔
71
72	$description = $definition->getDescription();	5✔
73
74	if (null !== $description) {	5✔
75	$description = RstUtils::toRst($description);	2✔
76	$doc .= <<<RST	2✔
77
78
79	Description
80	-----------
81
82	{$description}	2✔
83	RST;	2✔
84	}
85
86	$header = static function (string $message, string $underline = '-'): string {	5✔
87	$line = str_repeat($underline, \strlen($message));	5✔
88
89	return "{$message}\n{$line}\n";	5✔
90	};	5✔
91
92	$tags = DocumentationTagGenerator::analyseRule($fixer);	5✔
93	$warnings = array_map(	5✔
94	static function (DocumentationTag $tag): string {	5✔
95	$titleLine = str_repeat('~', \strlen($tag->title));	5✔
96
97	return \sprintf(	5✔
98	"\n%s\n%s\n\n%s",	5✔
99	$tag->title,	5✔
100	$titleLine,	5✔
101	null === $tag->description ? '' : RstUtils::toRst($tag->description, 0),	5✔
102	);	5✔
103	},	5✔
104	$tags,	5✔
105	);	5✔
106
107	if ([] !== $warnings) {	5✔
108	$warningsHeader = 1 === \count($warnings) ? 'Warning' : 'Warnings';	5✔
109
110	$doc .= "\n\n".$header($warningsHeader).implode("\n", $warnings);	5✔
111	}
112
113	if ($fixer instanceof ConfigurableFixerInterface) {	5✔
114	$fixerInFutureMode = self::createFixerInFutureMode($fixer);	3✔
115
116	$doc .= <<<'RST'
117
118
119	Configuration
120	-------------
121	RST;
122
123	$configurationDefinition = $fixer->getConfigurationDefinition();	3✔
124
125	foreach ($configurationDefinition->getOptions() as $option) {	3✔
126	$optionInfo = "``{$option->getName()}``";	3✔
127	$optionInfo .= "\n".str_repeat('~', \strlen($optionInfo));	3✔
128
129	if ($option instanceof DeprecatedFixerOptionInterface) {	3✔
130	$deprecationMessage = RstUtils::toRst($option->getDeprecationMessage());	×
131	$optionInfo .= "\n\n.. warning:: This option is deprecated and will be removed in the next major version. {$deprecationMessage}";	×
132	}
133
134	$optionInfo .= "\n\n".RstUtils::toRst($option->getDescription());	3✔
135
136	if ($option instanceof AliasedFixerOption) {	3✔
137	$optionInfo .= "\n\n.. note:: The previous name of this option was ``{$option->getAlias()}`` but it is now deprecated and will be removed in the next major version.";	×
138	}
139
140	$allowed = HelpCommand::getDisplayableAllowedValues($option);	3✔
141
142	if (null === $allowed) {	3✔
143	$allowedKind = 'Allowed types';	2✔
144	$allowedTypes = $option->getAllowedTypes();	2✔
145	if (null !== $allowedTypes) {	2✔
146	$allowed = array_map(	2✔
147	static fn (string $value): string => '``'.Utils::convertArrayTypeToList($value).'``',	2✔
148	$allowedTypes,	2✔
149	);	2✔
150	}
151	} else {
152	$allowedKind = 'Allowed values';	3✔
153	$allowed = array_map(static fn ($value): string => $value instanceof AllowedValueSubset	3✔
154	? 'a subset of ``'.Utils::toString($value->getAllowedValues()).'``'	1✔
155	: '``'.Utils::toString($value).'``', $allowed);	3✔
156	}
157
158	if (null !== $allowed) {	3✔
159	$allowed = Utils::naturalLanguageJoin($allowed, '');	3✔
160	$optionInfo .= "\n\n{$allowedKind}: {$allowed}";	3✔
161	}
162
163	if ($option->hasDefault()) {	3✔
164	$optionInfo .= \sprintf("\n\nDefault value: ``%s``", Utils::toString($option->getDefault()));	3✔
165
166	$optionInFutureMode = array_find(	3✔
167	$fixerInFutureMode->getConfigurationDefinition()->getOptions(),	3✔
168	static fn (FixerOptionInterface $opt): bool => $option->getName() === $opt->getName(),	3✔
169	);	3✔
170	\assert(null !== $optionInFutureMode); // if rule exist in v3, shall exist in future mode too, as it does not remove options	3✔
171	if ($optionInFutureMode->getDefault() !== $option->getDefault()) {	3✔
172	$optionInfo .= \sprintf("\n\nDefault value (future-mode): ``%s``", Utils::toString($optionInFutureMode->getDefault()));	×
173	}
174	} else {
175	$optionInfo .= "\n\nThis option is required.";	1✔
176	}
177
178	$doc .= "\n\n{$optionInfo}";	3✔
179	}
180	}
181
182	$samples = $definition->getCodeSamples();	5✔
183
184	if (0 !== \count($samples)) {	5✔
185	$doc .= <<<'RST'
186
187
188	Examples
189	--------
190	RST;
191
192	foreach ($samples as $index => $sample) {	5✔
193	$title = \sprintf('Example #%d', $index + 1);	5✔
194	$titleLine = str_repeat('~', \strlen($title));	5✔
195	$doc .= "\n\n{$title}\n{$titleLine}";	5✔
196
197	if ($fixer instanceof ConfigurableFixerInterface) {	5✔
198	if (null === $sample->getConfiguration()) {	3✔
199	$doc .= "\n\nDefault configuration.";	2✔
200	} else {
201	$doc .= \sprintf(	3✔
202	"\n\nWith configuration: ``%s``.",	3✔
203	Utils::toString($sample->getConfiguration()),	3✔
204	);	3✔
205	}
206	}
207
208	$doc .= "\n".$this->generateSampleDiff($fixer, $sample, $index + 1, $name);	5✔
209	}
210	}
211
212	$ruleSetConfigs = self::getSetsOfRule($name);	5✔
213
214	if ([] !== $ruleSetConfigs) {	5✔
215	$plural = 1 !== \count($ruleSetConfigs) ? 's' : '';	2✔
216	$doc .= <<<RST	2✔
217
218
219	Rule sets
220	---------
221
222	The rule is part of the following rule set{$plural}:\n\n	2✔
223	RST;	2✔
224
225	foreach ($ruleSetConfigs as $set => $config) {	2✔
226	$ruleSetPath = $this->locator->getRuleSetsDocumentationFilePath($set);	2✔
227	$ruleSetPath = substr($ruleSetPath, strrpos($ruleSetPath, '/'));	2✔
228
229	\assert(isset($this->ruleSetDefinitions[$set]));	2✔
230	$ruleSetDefinition = $this->ruleSetDefinitions[$set];	2✔
231
232	if ($ruleSetDefinition instanceof AutomaticRuleSetDefinitionInterface) {	2✔
233	continue;	×
234	}
235
236	$deprecatedDesc = ($ruleSetDefinition instanceof DeprecatedRuleSetDefinitionInterface) ? ' (deprecated)' : '';	2✔
237
238	$configInfo = (null !== $config)	2✔
239	? " with config:\n\n ``".Utils::toString($config)."``\n"	1✔
240	: '';	2✔
241
242	$doc .= <<<RST	2✔
243	- `{$set} <./../../ruleSets{$ruleSetPath}>`_{$deprecatedDesc}{$configInfo}\n	2✔
244	RST;	2✔
245	}
246
247	$doc = trim($doc);	2✔
248	}
249
250	$reflectionObject = new \ReflectionObject($fixer);	5✔
251	$className = str_replace('\\', '\\\\', $reflectionObject->getName());	5✔
252	$fileName = $reflectionObject->getFileName();	5✔
253	$fileName = str_replace('\\', '/', $fileName);	5✔
254	$fileName = substr($fileName, (int) strrpos($fileName, '/src/Fixer/') + 1);	5✔
255	$fileName = "`{$className} <./../../../{$fileName}>`_";	5✔
256
257	$testFileName = Preg::replace('~.*\K/src/(?=Fixer/)~', '/tests/', $fileName);	5✔
258	$testFileName = Preg::replace('~PhpCsFixer\\\\\\\\\K(?=Fixer\\\\\\\)~', 'Tests\\\\\\\\', $testFileName);	5✔
259	$testFileName = Preg::replace('~(?= <\|\.php>)~', 'Test', $testFileName);	5✔
260
261	$doc .= <<<RST	5✔
262
263
264	References
265	----------
266
267	- Fixer class: {$fileName}	5✔
268	- Test class: {$testFileName}	5✔
269
270	The test class defines officially supported behaviour. Each test case is a part of our backward compatibility promise.
271	RST;	5✔
272
273	$doc = str_replace("\t", '<TAB>', $doc);	5✔
274
275	return "{$doc}\n";	5✔
276	}
277
278	/**
279	* @internal
280	*
281	* @return array<string, null\|array<string, mixed>>
282	*/
283	public static function getSetsOfRule(string $ruleName): array
284	{
285	static $ruleSetCache = null;	5✔
286
287	if (null === $ruleSetCache) {	5✔
288	$definitionNames = array_keys(	×
289	array_filter(	×
290	RuleSets::getSetDefinitions(),	×
291	static fn (RuleSetDefinitionInterface $definition): bool => !$definition instanceof AutomaticRuleSetDefinitionInterface,	×
292	),	×
293	);	×
294	$ruleSetCache = array_combine(	×
295	$definitionNames,	×
296	array_map(	×
297	static fn (string $name): RuleSet => new RuleSet([$name => true]),	×
298	$definitionNames,	×
299	),	×
300	);	×
301	}
302
303	$ruleSetConfigs = [];	5✔
304
305	foreach ($ruleSetCache as $set => $ruleSet) {	5✔
306	if ($ruleSet->hasRule($ruleName)) {	5✔
307	$ruleSetConfigs[$set] = $ruleSet->getRuleConfiguration($ruleName);	2✔
308	}
309	}
310
311	return $ruleSetConfigs;	5✔
312	}
313
314	/**
315	* @param list<FixerInterface> $fixers
316	*/
317	public function generateFixersDocumentationIndex(array $fixers): string
318	{
319	$overrideGroups = [	1✔
320	'PhpUnit' => 'PHPUnit',	1✔
321	'PhpTag' => 'PHP Tag',	1✔
322	'Phpdoc' => 'PHPDoc',	1✔
323	];	1✔
324
325	usort($fixers, static fn (FixerInterface $a, FixerInterface $b): int => \get_class($a) <=> \get_class($b));	1✔
326
327	$documentation = <<<'RST'	1✔
328	=======================
329	List of Available Rules
330	=======================
331	RST;	1✔
332
333	$currentGroup = null;	1✔
334
335	foreach ($fixers as $fixer) {	1✔
336	$namespace = Preg::replace('/^.*\\\(.+)\\\.+Fixer$/', '$1', \get_class($fixer));	1✔
337	$group = $overrideGroups[$namespace] ?? Preg::replace('/(?<=[[:lower:]])(?=[[:upper:]])/', ' ', $namespace);	1✔
338
339	if ($group !== $currentGroup) {	1✔
340	$underline = str_repeat('-', \strlen($group));	1✔
341	$documentation .= "\n\n{$group}\n{$underline}\n";	1✔
342
343	$currentGroup = $group;	1✔
344	}
345
346	$path = './'.$this->locator->getFixerDocumentationFileRelativePath($fixer);	1✔
347
348	$tags = array_map(	1✔
349	static fn (DocumentationTag $tag): string => $tag->type,	1✔
350	DocumentationTagGenerator::analyseRule($fixer),	1✔
351	);	1✔
352
353	$attributes = 0 === \count($tags)	1✔
354	? ''	1✔
355	: ' ('.implode(', ', $tags).')';	1✔
356
357	$summary = str_replace('`', '``', $fixer->getDefinition()->getSummary());	1✔
358
359	$documentation .= <<<RST	1✔
360
361	- `{$fixer->getName()} <{$path}>`_{$attributes}	1✔
362
363	{$summary}	1✔
364	RST;	1✔
365	}
366
367	return "{$documentation}\n";	1✔
368	}
369
370	/**
371	* @template T of FixerInterface
372	*
373	* @param T $fixer
374	*
375	* @return T
376	*/
377	private static function createFixerInFutureMode(FixerInterface $fixer): FixerInterface
378	{
379	$object = Future::runWithEnforcedFutureMode(	3✔
380	static fn () => (new \ReflectionObject($fixer))->newInstance(),	3✔
381	);	3✔
382
383	\assert($object instanceof $fixer);	3✔
384
385	return $object;	3✔
386	}
387
388	private function generateSampleDiff(FixerInterface $fixer, CodeSampleInterface $sample, int $sampleNumber, string $ruleName): string
389	{
390	if ($sample instanceof VersionSpecificCodeSampleInterface && !$sample->isSuitableFor(\PHP_VERSION_ID)) {	5✔
391	$existingFile = @file_get_contents($this->locator->getFixerDocumentationFilePath($fixer));	×
392
393	if (false !== $existingFile) {	×
394	Preg::match("/\\RExample #{$sampleNumber}\\R.+?(?<diff>\\R\\.\\. code-block:: diff\\R\\R.*?)\\R(?:\\R\\S\|$)/s", $existingFile, $matches);	×
395
396	if (isset($matches['diff'])) {	×
397	return $matches['diff'];	×
398	}
399	}
400
401	$error = <<<RST	×
402
403	.. error::
404	Cannot generate diff for code sample #{$sampleNumber} of rule {$ruleName}:	×
405	the sample is not suitable for current version of PHP (%s).
406	RST;	×
407
408	return \sprintf($error, \PHP_VERSION);	×
409	}
410
411	$old = $sample->getCode();	5✔
412
413	$tokens = Tokens::fromCode($old);	5✔
414	$file = $sample instanceof FileSpecificCodeSampleInterface	5✔
415	? $sample->getSplFileInfo()	×
416	: new StdinFileInfo();	5✔
417
418	if ($fixer instanceof ConfigurableFixerInterface) {	5✔
419	$fixer->configure($sample->getConfiguration() ?? []);	3✔
420	}
421
422	$fixer->fix($file, $tokens);	5✔
423
424	$diff = $this->differ->diff($old, $tokens->generateCode());	5✔
425	$diff = Preg::replace('/@@[ \+\-\d,]+@@\n/', '', $diff);	5✔
426	$diff = Preg::replace('/\r/', '^M', $diff);	5✔
427	$diff = Preg::replace('/^ $/m', '', $diff);	5✔
428	$diff = Preg::replace('/\n$/', '', $diff);	5✔
429	$diff = RstUtils::indent($diff, 3);	5✔
430
431	return <<<RST	5✔
432
433	.. code-block:: diff
434
435	{$diff}	5✔
436	RST;	5✔
437	}
438	}

keradus / PHP-CS-Fixer / 22042339290

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