repo stringlengths 7 63 | file_url stringlengths 81 284 | file_path stringlengths 5 200 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:02:33 2026-01-05 05:24:06 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/SignatureInterface.php | src/Cache/SignatureInterface.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\Cache;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface SignatureInterface
{
public function getPhpVersion(): string;
public function getFixerVersion(): string;
public function getIndent(): string;
public function getLineEnding(): string;
/**
* @return array<string, array<string, mixed>|bool>
*/
public function getRules(): array;
public function getRuleCustomisationPolicyVersion(): string;
public function equals(self $signature): bool;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/FileCacheManager.php | src/Cache/FileCacheManager.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\Cache;
use PhpCsFixer\Hasher;
/**
* Class supports caching information about state of fixing files.
*
* Cache is supported only for phar version and version installed via composer.
*
* File will be processed by PHP CS Fixer only if any of the following conditions is fulfilled:
* - cache is corrupt
* - fixer version changed
* - rules changed
* - file is new
* - file changed
*
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FileCacheManager implements CacheManagerInterface
{
public const WRITE_FREQUENCY = 10;
private FileHandlerInterface $handler;
private SignatureInterface $signature;
private bool $isDryRun;
private DirectoryInterface $cacheDirectory;
private int $writeCounter = 0;
private bool $signatureWasUpdated = false;
private CacheInterface $cache;
public function __construct(
FileHandlerInterface $handler,
SignatureInterface $signature,
bool $isDryRun = false,
?DirectoryInterface $cacheDirectory = null
) {
$this->handler = $handler;
$this->signature = $signature;
$this->isDryRun = $isDryRun;
$this->cacheDirectory = $cacheDirectory ?? new Directory('');
$this->readCache();
}
public function __destruct()
{
if (true === $this->signatureWasUpdated || 0 !== $this->writeCounter) {
$this->writeCache();
}
}
/**
* This class is not intended to be serialized,
* and cannot be deserialized (see __wakeup method).
*/
public function __sleep(): array
{
throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
}
/**
* Disable the deserialization of the class to prevent attacker executing
* code by leveraging the __destruct method.
*
* @see https://owasp.org/www-community/vulnerabilities/PHP_Object_Injection
*/
public function __wakeup(): void
{
throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
}
public function needFixing(string $file, string $fileContent): bool
{
$file = $this->cacheDirectory->getRelativePathTo($file);
return !$this->cache->has($file) || $this->cache->get($file) !== $this->calcHash($fileContent);
}
public function setFile(string $file, string $fileContent): void
{
$this->setFileHash($file, $this->calcHash($fileContent));
}
public function setFileHash(string $file, string $hash): void
{
$file = $this->cacheDirectory->getRelativePathTo($file);
if ($this->isDryRun && $this->cache->has($file) && $this->cache->get($file) !== $hash) {
$this->cache->clear($file);
} else {
$this->cache->set($file, $hash);
}
if (self::WRITE_FREQUENCY === ++$this->writeCounter) {
$this->writeCounter = 0;
$this->writeCache();
}
}
private function readCache(): void
{
$cache = $this->handler->read();
if (null === $cache || !$this->signature->equals($cache->getSignature())) {
$cache = new Cache($this->signature);
$this->signatureWasUpdated = true;
}
$this->cache = $cache;
}
private function writeCache(): void
{
$this->handler->write($this->cache);
}
private function calcHash(string $content): string
{
return Hasher::calculate($content);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/CacheInterface.php | src/Cache/CacheInterface.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\Cache;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface CacheInterface
{
public function getSignature(): SignatureInterface;
public function has(string $file): bool;
public function get(string $file): ?string;
public function set(string $file, string $hash): void;
public function clear(string $file): void;
public function toJson(): string;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/CacheManagerInterface.php | src/Cache/CacheManagerInterface.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\Cache;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface CacheManagerInterface
{
public function needFixing(string $file, string $fileContent): bool;
public function setFile(string $file, string $fileContent): void;
public function setFileHash(string $file, string $hash): void;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/Directory.php | src/Cache/Directory.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\Cache;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class Directory implements DirectoryInterface
{
private string $directoryName;
public function __construct(string $directoryName)
{
$this->directoryName = $directoryName;
}
public function getRelativePathTo(string $file): string
{
$file = $this->normalizePath($file);
if (
'' === $this->directoryName
|| !str_starts_with(strtolower($file), strtolower($this->directoryName.\DIRECTORY_SEPARATOR))
) {
return $file;
}
return substr($file, \strlen($this->directoryName) + 1);
}
private function normalizePath(string $path): string
{
return str_replace(['\\', '/'], \DIRECTORY_SEPARATOR, $path);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/FileHandler.php | src/Cache/FileHandler.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\Cache;
use Symfony\Component\Filesystem\Exception\IOException;
/**
* @author Andreas Möller <am@localheinz.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FileHandler implements FileHandlerInterface
{
private \SplFileInfo $fileInfo;
private int $fileMTime = 0;
public function __construct(string $file)
{
$this->fileInfo = new \SplFileInfo($file);
}
public function getFile(): string
{
return $this->fileInfo->getPathname();
}
public function read(): ?CacheInterface
{
if (!$this->fileInfo->isFile() || !$this->fileInfo->isReadable()) {
return null;
}
$fileObject = $this->fileInfo->openFile('r');
$cache = $this->readFromHandle($fileObject);
$this->fileMTime = $this->getFileCurrentMTime();
unset($fileObject); // explicitly close file handler
return $cache;
}
public function write(CacheInterface $cache): void
{
$this->ensureFileIsWriteable();
$fileObject = $this->fileInfo->openFile('r+');
if (method_exists($cache, 'backfillHashes') && $this->fileMTime < $this->getFileCurrentMTime()) {
$resultOfFlock = $fileObject->flock(\LOCK_EX);
if (false === $resultOfFlock) {
// Lock failed, OK - we continue without the lock.
// noop
}
$oldCache = $this->readFromHandle($fileObject);
$fileObject->rewind();
if (null !== $oldCache) {
$cache->backfillHashes($oldCache);
}
}
$resultOfTruncate = $fileObject->ftruncate(0);
if (false === $resultOfTruncate) {
// Truncate failed. OK - we do not save the cache.
return;
}
$resultOfWrite = $fileObject->fwrite($cache->toJson());
if (false === $resultOfWrite) {
// Write failed. OK - we did not save the cache.
return;
}
$resultOfFlush = $fileObject->fflush();
if (false === $resultOfFlush) {
// Flush failed. OK - part of cache can be missing, in case this was last chunk in this pid.
// noop
}
$this->fileMTime = time(); // we could take the fresh `mtime` of file that we just modified with `$this->getFileCurrentMTime()`, but `time()` should be good enough here and reduce IO operation
}
private function getFileCurrentMTime(): int
{
clearstatcache(true, $this->fileInfo->getPathname());
$mtime = $this->fileInfo->getMTime();
if (false === $mtime) {
// cannot check mtime? OK - let's pretend file is old.
$mtime = 0;
}
return $mtime;
}
private function readFromHandle(\SplFileObject $fileObject): ?CacheInterface
{
try {
$size = $fileObject->getSize();
if (false === $size || 0 === $size) {
return null;
}
$content = $fileObject->fread($size);
if (false === $content) {
return null;
}
return Cache::fromJson($content);
} catch (\InvalidArgumentException $exception) {
return null;
}
}
private function ensureFileIsWriteable(): void
{
if ($this->fileInfo->isFile() && $this->fileInfo->isWritable()) {
// all good
return;
}
if ($this->fileInfo->isDir()) {
throw new IOException(
\sprintf('Cannot write cache file "%s" as the location exists as directory.', $this->fileInfo->getRealPath()),
0,
null,
$this->fileInfo->getPathname(),
);
}
if ($this->fileInfo->isFile() && !$this->fileInfo->isWritable()) {
throw new IOException(
\sprintf('Cannot write to file "%s" as it is not writable.', $this->fileInfo->getRealPath()),
0,
null,
$this->fileInfo->getPathname(),
);
}
$this->createFile($this->fileInfo->getPathname());
}
private function createFile(string $file): void
{
$dir = \dirname($file);
// Ensure path is created, but ignore if already exists. FYI: ignore EA suggestion in IDE,
// `mkdir()` returns `false` for existing paths, so we can't mix it with `is_dir()` in one condition.
if (!@is_dir($dir)) {
@mkdir($dir, 0777, true);
}
if (!@is_dir($dir)) {
throw new IOException(
\sprintf('Directory of cache file "%s" does not exists and couldn\'t be created.', $file),
0,
null,
$file,
);
}
@touch($file);
@chmod($file, 0666);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/FileHandlerInterface.php | src/Cache/FileHandlerInterface.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\Cache;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface FileHandlerInterface
{
public function getFile(): string;
public function read(): ?CacheInterface;
public function write(CacheInterface $cache): void;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/Cache.php | src/Cache/Cache.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\Cache;
use PhpCsFixer\Config\NullRuleCustomisationPolicy;
use PhpCsFixer\Utils;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class Cache implements CacheInterface
{
private SignatureInterface $signature;
/**
* @var array<string, string>
*/
private array $hashes = [];
public function __construct(SignatureInterface $signature)
{
$this->signature = $signature;
}
public function getSignature(): SignatureInterface
{
return $this->signature;
}
public function has(string $file): bool
{
return \array_key_exists($file, $this->hashes);
}
public function get(string $file): ?string
{
if (!$this->has($file)) {
return null;
}
return $this->hashes[$file];
}
public function set(string $file, string $hash): void
{
$this->hashes[$file] = $hash;
}
public function clear(string $file): void
{
unset($this->hashes[$file]);
}
public function toJson(): string
{
try {
return json_encode(
[
'php' => $this->getSignature()->getPhpVersion(),
'version' => $this->getSignature()->getFixerVersion(),
'indent' => $this->getSignature()->getIndent(),
'lineEnding' => $this->getSignature()->getLineEnding(),
'rules' => $this->getSignature()->getRules(),
'ruleCustomisationPolicyVersion' => $this->getSignature()->getRuleCustomisationPolicyVersion(),
'hashes' => $this->hashes,
],
\JSON_THROW_ON_ERROR,
);
} catch (\JsonException $e) {
throw new \UnexpectedValueException(\sprintf(
'Cannot encode cache signature to JSON, error: "%s". If you have non-UTF8 chars in your signature, like in license for `header_comment`, consider enabling `ext-mbstring` or install `symfony/polyfill-mbstring`.',
$e->getMessage(),
));
}
}
/**
* @throws \InvalidArgumentException
*/
public static function fromJson(string $json): self
{
try {
$data = json_decode($json, true, 512, \JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
throw new \InvalidArgumentException(\sprintf(
'Value needs to be a valid JSON string, got "%s", error: "%s".',
$json,
$e->getMessage(),
));
}
$requiredKeys = [
'php',
'version',
'indent',
'lineEnding',
'rules',
// 'ruleCustomisationPolicyVersion', // @TODO v4: require me
'hashes',
];
$missingKeys = array_diff_key(array_flip($requiredKeys), $data);
if (\count($missingKeys) > 0) {
throw new \InvalidArgumentException(\sprintf(
'JSON data is missing keys %s',
Utils::naturalLanguageJoin(array_keys($missingKeys)),
));
}
$signature = new Signature(
$data['php'],
$data['version'],
$data['indent'],
$data['lineEnding'],
$data['rules'],
$data['ruleCustomisationPolicyVersion'] ?? NullRuleCustomisationPolicy::VERSION_FOR_CACHE,
);
$cache = new self($signature);
// before v3.11.1 the hashes were crc32 encoded and saved as integers
// @TODO v4: remove the to string cast/array_map
$cache->hashes = array_map(static fn ($v): string => \is_int($v) ? (string) $v : $v, $data['hashes']);
return $cache;
}
/**
* @internal
*/
public function backfillHashes(self $oldCache): bool
{
if (!$this->getSignature()->equals($oldCache->getSignature())) {
return false;
}
$this->hashes = array_merge($oldCache->hashes, $this->hashes);
return true;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Cache/NullCacheManager.php | src/Cache/NullCacheManager.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\Cache;
/**
* @author Andreas Möller <am@localheinz.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class NullCacheManager implements CacheManagerInterface
{
public function needFixing(string $file, string $fileContent): bool
{
return true;
}
public function setFile(string $file, string $fileContent): void {}
public function setFileHash(string $file, string $hash): void {}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/WarningsDetector.php | src/Console/WarningsDetector.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;
use PhpCsFixer\ComposerJsonReader;
use PhpCsFixer\ToolInfo;
use PhpCsFixer\ToolInfoInterface;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class WarningsDetector
{
private ToolInfoInterface $toolInfo;
/**
* @var list<string>
*/
private array $warnings = [];
public function __construct(ToolInfoInterface $toolInfo)
{
$this->toolInfo = $toolInfo;
}
public function detectOldMajor(): void
{
// @TODO 3.99 to be activated with new MAJOR release 4.0
// $currentMajorVersion = \intval(explode('.', Application::VERSION)[0], 10);
// $nextMajorVersion = $currentMajorVersion + 1;
// $this->warnings[] = "You are running PHP CS Fixer v{$currentMajorVersion}, which is not maintained anymore. Please update to v{$nextMajorVersion}.";
// $this->warnings[] = "You may find an UPGRADE guide at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/v{$nextMajorVersion}.0.0/UPGRADE-v{$nextMajorVersion}.md .";
}
public function detectOldVendor(): void
{
if ($this->toolInfo->isInstalledByComposer()) {
$details = $this->toolInfo->getComposerInstallationDetails();
if (ToolInfo::COMPOSER_LEGACY_PACKAGE_NAME === $details['name']) {
$this->warnings[] = \sprintf(
'You are running PHP CS Fixer installed with old vendor `%s`. Please update to `%s`.',
ToolInfo::COMPOSER_LEGACY_PACKAGE_NAME,
ToolInfo::COMPOSER_PACKAGE_NAME,
);
}
}
}
public function detectNonMonolithic(): void
{
if (filter_var(getenv('PHP_CS_FIXER_NON_MONOLITHIC'), \FILTER_VALIDATE_BOOL)) {
$this->warnings[] = 'Processing non-monolithic files enabled, because `PHP_CS_FIXER_NON_MONOLITHIC` is set. Execution result may be unpredictable - non-monolithic files are not officially supported.';
}
}
public function detectHigherPhpVersion(): void
{
try {
$composerJsonReader = ComposerJsonReader::createSingleton();
$minPhpVersion = $composerJsonReader->getPhp();
if (null === $minPhpVersion) {
$this->warnings[] = 'No PHP version requirement found in composer.json. It is recommended to specify a minimum PHP version supported by your project.';
return;
}
$currentPhpVersion = \PHP_VERSION;
$currentPhpMajorMinor = \sprintf('%d.%d', \PHP_MAJOR_VERSION, \PHP_MINOR_VERSION);
// Compare major.minor versions
if (version_compare($currentPhpMajorMinor, $minPhpVersion, '>')) {
$this->warnings[] = \sprintf(
'You are running PHP CS Fixer on PHP %1$s, but the minimum PHP version supported by your project in composer.json is PHP %2$s. Executing PHP CS Fixer on newer PHP versions may introduce syntax or features not yet available in PHP %2$s, which could cause issues under that version. It is recommended to run PHP CS Fixer on PHP %2$s, to fit your project specifics.',
$currentPhpVersion,
$minPhpVersion,
);
}
} catch (\Throwable $e) {
$this->warnings[] = \sprintf(
'Unable to determine minimum PHP version supported by your project from composer.json: %s',
$e->getMessage(),
);
}
}
/**
* @return list<string>
*/
public function getWarnings(): array
{
if (0 === \count($this->warnings)) {
return [];
}
return array_values(array_unique(array_merge(
$this->warnings,
['If you need help while solving warnings, ask at https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/discussions/, we will help you!'],
)));
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Application.php | src/Console/Application.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;
use PhpCsFixer\Console\Command\CheckCommand;
use PhpCsFixer\Console\Command\DescribeCommand;
use PhpCsFixer\Console\Command\FixCommand;
use PhpCsFixer\Console\Command\HelpCommand;
use PhpCsFixer\Console\Command\InitCommand;
use PhpCsFixer\Console\Command\ListFilesCommand;
use PhpCsFixer\Console\Command\ListSetsCommand;
use PhpCsFixer\Console\Command\SelfUpdateCommand;
use PhpCsFixer\Console\Command\WorkerCommand;
use PhpCsFixer\Console\SelfUpdate\GithubClient;
use PhpCsFixer\Console\SelfUpdate\NewVersionChecker;
use PhpCsFixer\Future;
use PhpCsFixer\PharChecker;
use PhpCsFixer\Runner\Parallel\WorkerException;
use PhpCsFixer\ToolInfo;
use Symfony\Component\Console\Application as BaseApplication;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Command\CompleteCommand;
use Symfony\Component\Console\Command\DumpCompletionCommand;
use Symfony\Component\Console\Command\ListCommand;
use Symfony\Component\Console\Exception\CommandNotFoundException;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @author Fabien Potencier <fabien@symfony.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class Application extends BaseApplication
{
public const NAME = 'PHP CS Fixer';
public const VERSION = '3.92.5-DEV';
public const VERSION_CODENAME = 'Exceptional Exception';
/**
* @readonly
*/
private ToolInfo $toolInfo;
private ?Command $executedCommand = null;
public function __construct()
{
parent::__construct(self::NAME, self::VERSION);
$this->toolInfo = new ToolInfo();
// in alphabetical order
$this->add(new CheckCommand($this->toolInfo));
$this->add(new DescribeCommand());
$this->add(new FixCommand($this->toolInfo));
$this->add(new InitCommand());
$this->add(new ListFilesCommand($this->toolInfo));
$this->add(new ListSetsCommand());
$this->add(new SelfUpdateCommand(
new NewVersionChecker(new GithubClient()),
$this->toolInfo,
new PharChecker(),
));
$this->add(new WorkerCommand($this->toolInfo));
}
// polyfill for `add` method, as it is not available in Symfony 8.0
public function add(Command $command): ?Command
{
if (method_exists($this, 'addCommand')) { // @phpstan-ignore-line
return $this->addCommand($command);
}
return parent::add($command);
}
public static function getMajorVersion(): int
{
return (int) explode('.', self::VERSION)[0];
}
public function doRun(InputInterface $input, OutputInterface $output): int
{
$stdErr = $output instanceof ConsoleOutputInterface
? $output->getErrorOutput()
: ($input->hasParameterOption('--format', true) && 'txt' !== $input->getParameterOption('--format', null, true) ? null : $output);
if (null !== $stdErr) {
$warningsDetector = new WarningsDetector($this->toolInfo);
$warningsDetector->detectOldVendor();
$warningsDetector->detectOldMajor();
try {
$commandName = $this->getCommandName($input);
if (null === $commandName) {
throw new CommandNotFoundException('No command name found.');
}
$command = $this->find($commandName);
if (($command instanceof CheckCommand) || ($command instanceof FixCommand)) {
$warningsDetector->detectHigherPhpVersion();
$warningsDetector->detectNonMonolithic();
}
} catch (CommandNotFoundException $e) {
// no-op
}
$warnings = $warningsDetector->getWarnings();
if (\count($warnings) > 0) {
foreach ($warnings as $warning) {
$stdErr->writeln(\sprintf($stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s', $warning));
}
$stdErr->writeln('');
}
}
$result = parent::doRun($input, $output);
if (
null !== $stdErr
&& $output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE
) {
$triggeredDeprecations = Future::getTriggeredDeprecations();
if (\count($triggeredDeprecations) > 0) {
$stdErr->writeln('');
$stdErr->writeln($stdErr->isDecorated() ? '<bg=yellow;fg=black;>Detected deprecations in use (they will stop working in next major release):</>' : 'Detected deprecations in use (they will stop working in next major release):');
foreach ($triggeredDeprecations as $deprecation) {
$stdErr->writeln(\sprintf('- %s', $deprecation));
}
}
}
return $result;
}
/**
* @internal
*/
public static function getAbout(bool $decorated = false): string
{
$longVersion = \sprintf('%s <info>%s</info>', self::NAME, self::VERSION);
// value of `$commitPlaceholderPossiblyEvaluated` will be changed during phar building, other value will not
$commitPlaceholderPossiblyEvaluated = '@git-commit@';
$commitPlaceholder = implode('', ['@', 'git-commit@']); // do not replace with imploded value, as here we need to prevent phar builder to replace the placeholder
$versionCommit = $commitPlaceholder !== $commitPlaceholderPossiblyEvaluated
? substr($commitPlaceholderPossiblyEvaluated, 0, 7) // for phar builds
: '';
$about = implode('', [
$longVersion,
$versionCommit ? \sprintf(' <info>(%s)</info>', $versionCommit) : '', // @phpstan-ignore-line to avoid `Ternary operator condition is always true|false.`
self::VERSION_CODENAME ? \sprintf(' <info>%s</info>', self::VERSION_CODENAME) : '', // @phpstan-ignore-line to avoid `Ternary operator condition is always true|false.`
' by <comment>Fabien Potencier</comment>, <comment>Dariusz Ruminski</comment> and <comment>contributors</comment>.',
]);
if (false === $decorated) {
return strip_tags($about);
}
return $about;
}
/**
* @internal
*/
public static function getAboutWithRuntime(bool $decorated = false): string
{
$about = self::getAbout(true)."\nPHP runtime: <info>".\PHP_VERSION.'</info>';
if (false === $decorated) {
return strip_tags($about);
}
return $about;
}
public function getLongVersion(): string
{
return self::getAboutWithRuntime(true);
}
protected function getDefaultCommands(): array
{
return [new HelpCommand(), new ListCommand(), new CompleteCommand(), new DumpCompletionCommand()];
}
/**
* @throws \Throwable
*/
protected function doRunCommand(Command $command, InputInterface $input, OutputInterface $output): int
{
$this->executedCommand = $command;
return parent::doRunCommand($command, $input, $output);
}
protected function doRenderThrowable(\Throwable $e, OutputInterface $output): void
{
// Since parallel analysis utilises child processes, and they have their own output,
// we need to capture the output of the child process to determine it there was an exception.
// Default render format is not machine-friendly, so we need to override it for `worker` command,
// in order to be able to easily parse exception data for further displaying on main process' side.
if ($this->executedCommand instanceof WorkerCommand) {
$output->writeln(WorkerCommand::ERROR_PREFIX.json_encode(
[
'class' => \get_class($e),
'message' => $e->getMessage(),
'file' => $e->getFile(),
'line' => $e->getLine(),
'code' => $e->getCode(),
'trace' => $e->getTraceAsString(),
],
\JSON_THROW_ON_ERROR,
));
return;
}
parent::doRenderThrowable($e, $output);
if ($output->isVeryVerbose() && $e instanceof WorkerException) {
$output->writeln('<comment>Original trace from worker:</comment>');
$output->writeln('');
$output->writeln($e->getOriginalTraceAsString());
$output->writeln('');
}
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/ConfigurationResolver.php | src/Console/ConfigurationResolver.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;
use PhpCsFixer\Cache\CacheManagerInterface;
use PhpCsFixer\Cache\Directory;
use PhpCsFixer\Cache\DirectoryInterface;
use PhpCsFixer\Cache\FileCacheManager;
use PhpCsFixer\Cache\FileHandler;
use PhpCsFixer\Cache\NullCacheManager;
use PhpCsFixer\Cache\Signature;
use PhpCsFixer\Config\NullRuleCustomisationPolicy;
use PhpCsFixer\Config\RuleCustomisationPolicyAwareConfigInterface;
use PhpCsFixer\Config\RuleCustomisationPolicyInterface;
use PhpCsFixer\ConfigInterface;
use PhpCsFixer\ConfigurationException\InvalidConfigurationException;
use PhpCsFixer\Console\Output\Progress\ProgressOutputType;
use PhpCsFixer\Console\Report\FixReport\ReporterFactory;
use PhpCsFixer\Console\Report\FixReport\ReporterInterface;
use PhpCsFixer\CustomRulesetsAwareConfigInterface;
use PhpCsFixer\Differ\DifferInterface;
use PhpCsFixer\Differ\NullDiffer;
use PhpCsFixer\Differ\UnifiedDiffer;
use PhpCsFixer\Finder;
use PhpCsFixer\Fixer\DeprecatedFixerInterface;
use PhpCsFixer\Fixer\FixerInterface;
use PhpCsFixer\FixerFactory;
use PhpCsFixer\Future;
use PhpCsFixer\Linter\Linter;
use PhpCsFixer\Linter\LinterInterface;
use PhpCsFixer\ParallelAwareConfigInterface;
use PhpCsFixer\RuleSet\RuleSet;
use PhpCsFixer\RuleSet\RuleSetInterface;
use PhpCsFixer\RuleSet\RuleSets;
use PhpCsFixer\Runner\Parallel\ParallelConfig;
use PhpCsFixer\Runner\Parallel\ParallelConfigFactory;
use PhpCsFixer\StdinFileInfo;
use PhpCsFixer\ToolInfoInterface;
use PhpCsFixer\UnsupportedPhpVersionAllowedConfigInterface;
use PhpCsFixer\Utils;
use PhpCsFixer\WhitespacesFixerConfig;
use PhpCsFixer\WordMatcher;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder as SymfonyFinder;
/**
* The resolver that resolves configuration to use by command line options and config.
*
* @internal
*
* @phpstan-type _Options array{
* allow-risky: null|string,
* cache-file: null|string,
* config: null|string,
* diff: null|string,
* dry-run: null|bool,
* format: null|string,
* path: list<string>,
* path-mode: value-of<self::PATH_MODE_VALUES>,
* rules: null|string,
* sequential: null|string,
* show-progress: null|string,
* stop-on-violation: null|bool,
* using-cache: null|string,
* allow-unsupported-php-version: null|bool,
* verbosity: null|string,
* }
*
* @author Fabien Potencier <fabien@symfony.com>
* @author Katsuhiro Ogawa <ko.fivestar@gmail.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ConfigurationResolver
{
public const IGNORE_CONFIG_FILE = '-';
public const PATH_MODE_OVERRIDE = 'override';
public const PATH_MODE_INTERSECTION = 'intersection';
public const PATH_MODE_VALUES = [
self::PATH_MODE_OVERRIDE,
self::PATH_MODE_INTERSECTION,
];
public const BOOL_YES = 'yes';
public const BOOL_NO = 'no';
public const BOOL_VALUES = [
self::BOOL_YES,
self::BOOL_NO,
];
/**
* @TODO v4: this is no longer needed due to `MARKER-multi-paths-vs-only-cwd-config`
*/
private ?string $deprecatedNestedConfigDir = null;
private ?bool $allowRisky = null;
private ?ConfigInterface $config = null;
private ?string $configFile = null;
private string $cwd;
private ConfigInterface $defaultConfig;
private ?ReporterInterface $reporter = null;
private ?bool $isStdIn = null;
private ?bool $isDryRun = null;
/**
* @var null|list<FixerInterface>
*/
private ?array $fixers = null;
private ?bool $configFinderIsOverridden = null;
private ?bool $configRulesAreOverridden = null;
private ToolInfoInterface $toolInfo;
/**
* @var _Options
*/
private array $options = [
'allow-risky' => null,
'cache-file' => null,
'config' => null,
'diff' => null,
'dry-run' => null,
'format' => null,
'path' => [],
'path-mode' => self::PATH_MODE_OVERRIDE,
'rules' => null,
'sequential' => null,
'show-progress' => null,
'stop-on-violation' => null,
'using-cache' => null,
'allow-unsupported-php-version' => null,
'verbosity' => null,
];
private ?string $cacheFile = null;
private ?CacheManagerInterface $cacheManager = null;
private ?DifferInterface $differ = null;
private ?Directory $directory = null;
/**
* @var null|iterable<\SplFileInfo>
*/
private ?iterable $finder = null;
private ?string $format = null;
private ?Linter $linter = null;
/**
* @var null|list<string>
*/
private ?array $path = null;
/**
* @var null|ProgressOutputType::*
*/
private $progress;
private ?RuleSet $ruleSet = null;
private ?bool $usingCache = null;
private ?bool $isUnsupportedPhpVersionAllowed = null;
private ?RuleCustomisationPolicyInterface $ruleCustomisationPolicy = null;
private ?FixerFactory $fixerFactory = null;
/**
* @param array<string, mixed> $options
*/
public function __construct(
ConfigInterface $config,
array $options,
string $cwd,
ToolInfoInterface $toolInfo
) {
$this->defaultConfig = $config;
$this->cwd = $cwd;
$this->toolInfo = $toolInfo;
foreach ($options as $name => $value) {
$this->setOption($name, $value);
}
}
public function getCacheFile(): ?string
{
if (!$this->getUsingCache()) {
return null;
}
if (null === $this->cacheFile) {
if (null === $this->options['cache-file']) {
$this->cacheFile = $this->getConfig()->getCacheFile();
} else {
$this->cacheFile = $this->options['cache-file'];
}
}
return $this->cacheFile;
}
public function getCacheManager(): CacheManagerInterface
{
if (null === $this->cacheManager) {
$cacheFile = $this->getCacheFile();
if (null === $cacheFile) {
$this->cacheManager = new NullCacheManager();
} else {
$this->cacheManager = new FileCacheManager(
new FileHandler($cacheFile),
new Signature(
\PHP_VERSION,
$this->toolInfo->getVersion(),
$this->getConfig()->getIndent(),
$this->getConfig()->getLineEnding(),
$this->getRules(),
$this->getRuleCustomisationPolicy()->getPolicyVersionForCache(),
),
$this->isDryRun(),
$this->getDirectory(),
);
}
}
return $this->cacheManager;
}
public function getConfig(): ConfigInterface
{
if (null === $this->config) {
foreach ($this->computeConfigFiles() as $configFile) {
if (!file_exists($configFile)) {
continue;
}
$configFileBasename = basename($configFile);
/** @TODO v4 drop handling (triggering error) for v2 config names */
$deprecatedConfigs = [
'.php_cs' => '.php-cs-fixer.php',
'.php_cs.dist' => '.php-cs-fixer.dist.php',
];
if (isset($deprecatedConfigs[$configFileBasename])) {
throw new InvalidConfigurationException("Configuration file `{$configFileBasename}` is outdated, rename to `{$deprecatedConfigs[$configFileBasename]}`.");
}
if (null !== $this->deprecatedNestedConfigDir && str_starts_with($configFile, $this->deprecatedNestedConfigDir)) {
// @TODO v4: when removing, remove also TODO with `MARKER-multi-paths-vs-only-cwd-config`
Future::triggerDeprecation(
new InvalidConfigurationException("Configuration file `{$configFile}` is picked as file inside passed `path` CLI argument. This will be ignored in the future and only config file in `cwd` will be picked. Please use `config` CLI option instead if you want to keep current behaviour."),
);
}
$this->config = self::separatedContextLessInclude($configFile);
$this->configFile = $configFile;
break;
}
if (null === $this->config) {
$this->config = $this->defaultConfig;
}
if ($this->config instanceof CustomRulesetsAwareConfigInterface) {
foreach ($this->config->getCustomRuleSets() as $ruleSet) {
RuleSets::registerCustomRuleSet($ruleSet);
}
}
}
return $this->config;
}
public function getParallelConfig(): ParallelConfig
{
$config = $this->getConfig();
return true !== $this->options['sequential'] && $config instanceof ParallelAwareConfigInterface
? $config->getParallelConfig()
: ParallelConfigFactory::sequential();
}
public function getConfigFile(): ?string
{
if (null === $this->configFile) {
$this->getConfig();
}
return $this->configFile;
}
public function getDiffer(): DifferInterface
{
if (null === $this->differ) {
$this->differ = (true === $this->options['diff']) ? new UnifiedDiffer() : new NullDiffer();
}
return $this->differ;
}
public function getDirectory(): DirectoryInterface
{
if (null === $this->directory) {
$path = $this->getCacheFile();
if (null === $path) {
$absolutePath = $this->cwd;
} else {
$filesystem = new Filesystem();
$absolutePath = $filesystem->isAbsolutePath($path)
? $path
: $this->cwd.\DIRECTORY_SEPARATOR.$path;
$absolutePath = \dirname($absolutePath);
}
$this->directory = new Directory($absolutePath);
}
return $this->directory;
}
/**
* @return list<FixerInterface>
*/
public function getFixers(): array
{
if (null === $this->fixers) {
$this->fixers = $this->createFixerFactory()
->useRuleSet($this->getRuleSet())
->setWhitespacesConfig(new WhitespacesFixerConfig($this->config->getIndent(), $this->config->getLineEnding()))
->getFixers()
;
if (false === $this->getRiskyAllowed()) {
$riskyFixers = array_map(
static fn (FixerInterface $fixer): string => $fixer->getName(),
array_values(array_filter(
$this->fixers,
static fn (FixerInterface $fixer): bool => $fixer->isRisky(),
)),
);
if (\count($riskyFixers) > 0) {
throw new InvalidConfigurationException(\sprintf('The rules contain risky fixers (%s), but they are not allowed to run. Perhaps you forget to use --allow-risky=yes option?', Utils::naturalLanguageJoin($riskyFixers)));
}
}
}
return $this->fixers;
}
public function getLinter(): LinterInterface
{
if (null === $this->linter) {
$this->linter = new Linter();
}
return $this->linter;
}
/**
* Returns path.
*
* @return list<string>
*/
public function getPath(): array
{
if (null === $this->path) {
$filesystem = new Filesystem();
$cwd = $this->cwd;
if (1 === \count($this->options['path']) && '-' === $this->options['path'][0]) {
$this->path = $this->options['path'];
} else {
$this->path = array_map(
static function (string $rawPath) use ($cwd, $filesystem): string {
$path = trim($rawPath);
if ('' === $path) {
throw new InvalidConfigurationException("Invalid path: \"{$rawPath}\".");
}
$absolutePath = $filesystem->isAbsolutePath($path)
? $path
: $cwd.\DIRECTORY_SEPARATOR.$path;
if (!file_exists($absolutePath)) {
throw new InvalidConfigurationException(\sprintf(
'The path "%s" is not readable.',
$path,
));
}
return $absolutePath;
},
$this->options['path'],
);
}
}
return $this->path;
}
/**
* @return ProgressOutputType::*
*
* @throws InvalidConfigurationException
*/
public function getProgressType(): string
{
if (null === $this->progress) {
if ('txt' === $this->resolveFormat()) {
$progressType = $this->options['show-progress'];
if (null === $progressType) {
$progressType = $this->getConfig()->getHideProgress()
? ProgressOutputType::NONE
: ProgressOutputType::BAR;
} elseif (!\in_array($progressType, ProgressOutputType::all(), true)) {
throw new InvalidConfigurationException(\sprintf(
'The progress type "%s" is not defined, supported are %s.',
$progressType,
Utils::naturalLanguageJoin(ProgressOutputType::all()),
));
}
$this->progress = $progressType;
} else {
$this->progress = ProgressOutputType::NONE;
}
}
return $this->progress;
}
public function getReporter(): ReporterInterface
{
if (null === $this->reporter) {
$reporterFactory = new ReporterFactory();
$reporterFactory->registerBuiltInReporters();
$format = $this->resolveFormat();
try {
$this->reporter = $reporterFactory->getReporter($format);
} catch (\UnexpectedValueException $e) {
$formats = $reporterFactory->getFormats();
sort($formats);
throw new InvalidConfigurationException(\sprintf('The format "%s" is not defined, supported are %s.', $format, Utils::naturalLanguageJoin($formats)));
}
}
return $this->reporter;
}
public function getRiskyAllowed(): bool
{
if (null === $this->allowRisky) {
if (null === $this->options['allow-risky']) {
$this->allowRisky = $this->getConfig()->getRiskyAllowed();
} else {
$this->allowRisky = $this->resolveOptionBooleanValue('allow-risky');
}
}
return $this->allowRisky;
}
/**
* Returns rules.
*
* @return array<string, array<string, mixed>|bool>
*/
public function getRules(): array
{
return $this->getRuleSet()->getRules();
}
public function getUsingCache(): bool
{
if (null === $this->usingCache) {
if (null === $this->options['using-cache']) {
$this->usingCache = $this->getConfig()->getUsingCache();
} else {
$this->usingCache = $this->resolveOptionBooleanValue('using-cache');
}
}
$this->usingCache = $this->usingCache && $this->isCachingAllowedForRuntime();
return $this->usingCache;
}
public function getUnsupportedPhpVersionAllowed(): bool
{
if (null === $this->isUnsupportedPhpVersionAllowed) {
if (null === $this->options['allow-unsupported-php-version']) {
$config = $this->getConfig();
$this->isUnsupportedPhpVersionAllowed = $config instanceof UnsupportedPhpVersionAllowedConfigInterface
? $config->getUnsupportedPhpVersionAllowed()
: false;
} else {
$this->isUnsupportedPhpVersionAllowed = $this->resolveOptionBooleanValue('allow-unsupported-php-version');
}
}
return $this->isUnsupportedPhpVersionAllowed;
}
public function getRuleCustomisationPolicy(): RuleCustomisationPolicyInterface
{
if (null === $this->ruleCustomisationPolicy) {
$config = $this->getConfig();
if ($config instanceof RuleCustomisationPolicyAwareConfigInterface) {
$this->ruleCustomisationPolicy = $config->getRuleCustomisationPolicy();
}
$this->ruleCustomisationPolicy ??= new NullRuleCustomisationPolicy();
}
return $this->ruleCustomisationPolicy;
}
/**
* @return iterable<\SplFileInfo>
*/
public function getFinder(): iterable
{
if (null === $this->finder) {
$this->finder = $this->resolveFinder();
}
return $this->finder;
}
/**
* Returns dry-run flag.
*/
public function isDryRun(): bool
{
if (null === $this->isDryRun) {
if ($this->isStdIn()) {
// Can't write to STDIN
$this->isDryRun = true;
} else {
$this->isDryRun = $this->options['dry-run'];
}
}
return $this->isDryRun;
}
public function shouldStopOnViolation(): bool
{
return $this->options['stop-on-violation'];
}
public function configFinderIsOverridden(): bool
{
if (null === $this->configFinderIsOverridden) {
$this->resolveFinder();
}
return $this->configFinderIsOverridden;
}
public function configRulesAreOverridden(): bool
{
if (null === $this->configRulesAreOverridden) {
$this->parseRules();
}
return $this->configRulesAreOverridden;
}
/**
* Compute file candidates for config file.
*
* @TODO v4: don't offer configs from passed `path` CLI argument
*
* @return list<string>
*/
private function computeConfigFiles(): array
{
$configFile = $this->options['config'];
if (self::IGNORE_CONFIG_FILE === $configFile) {
return [];
}
if (null !== $configFile) {
if (false === file_exists($configFile) || false === is_readable($configFile)) {
throw new InvalidConfigurationException(\sprintf('Cannot read config file "%s".', $configFile));
}
return [$configFile];
}
$path = $this->getPath();
if ($this->isStdIn() || 0 === \count($path)) {
$configDir = $this->cwd;
} elseif (1 < \count($path)) {
// @TODO v4: this is no longer needed due to `MARKER-multi-paths-vs-only-cwd-config`
throw new InvalidConfigurationException('For multiple paths config parameter is required.');
} elseif (!is_file($path[0])) {
$configDir = $path[0];
} else {
$dirName = pathinfo($path[0], \PATHINFO_DIRNAME);
$configDir = is_dir($dirName) ? $dirName : $path[0];
}
$candidates = [
$configDir.\DIRECTORY_SEPARATOR.'.php-cs-fixer.php',
$configDir.\DIRECTORY_SEPARATOR.'.php-cs-fixer.dist.php',
// @TODO v4 drop handling (triggering error) for v2 config names
$configDir.\DIRECTORY_SEPARATOR.'.php_cs', // old v2 config, present here only to throw nice error message later
$configDir.\DIRECTORY_SEPARATOR.'.php_cs.dist', // old v2 config, present here only to throw nice error message later
];
if ($configDir !== $this->cwd) {
$candidates[] = $this->cwd.\DIRECTORY_SEPARATOR.'.php-cs-fixer.php';
$candidates[] = $this->cwd.\DIRECTORY_SEPARATOR.'.php-cs-fixer.dist.php';
// @TODO v4 drop handling (triggering error) for v2 config names
$candidates[] = $this->cwd.\DIRECTORY_SEPARATOR.'.php_cs'; // old v2 config, present here only to throw nice error message later
$candidates[] = $this->cwd.\DIRECTORY_SEPARATOR.'.php_cs.dist'; // old v2 config, present here only to throw nice error message later
$this->deprecatedNestedConfigDir = $configDir;
}
return $candidates;
}
private function createFixerFactory(): FixerFactory
{
if (null === $this->fixerFactory) {
$fixerFactory = new FixerFactory();
$fixerFactory->registerBuiltInFixers();
$fixerFactory->registerCustomFixers($this->getConfig()->getCustomFixers());
$this->fixerFactory = $fixerFactory;
}
return $this->fixerFactory;
}
private function resolveFormat(): string
{
if (null === $this->format) {
$formatCandidate = $this->options['format'] ?? $this->getConfig()->getFormat();
$parts = explode(',', $formatCandidate);
if (\count($parts) > 2) {
throw new InvalidConfigurationException(\sprintf('The format "%s" is invalid.', $formatCandidate));
}
$this->format = $parts[0];
if ('@auto' === $this->format) {
$this->format = $parts[1] ?? 'txt';
if (filter_var(getenv('GITLAB_CI'), \FILTER_VALIDATE_BOOL)) {
$this->format = 'gitlab';
}
}
}
return $this->format;
}
private function getRuleSet(): RuleSetInterface
{
if (null === $this->ruleSet) {
$rules = $this->parseRules();
$this->validateRules($rules);
$this->ruleSet = new RuleSet($rules);
}
return $this->ruleSet;
}
private function isStdIn(): bool
{
if (null === $this->isStdIn) {
$this->isStdIn = 1 === \count($this->options['path']) && '-' === $this->options['path'][0];
}
return $this->isStdIn;
}
/**
* @template T
*
* @param iterable<T> $iterable
*
* @return \Traversable<T>
*/
private function iterableToTraversable(iterable $iterable): \Traversable
{
return \is_array($iterable) ? new \ArrayIterator($iterable) : $iterable;
}
/**
* @return array<string, mixed>
*/
private function parseRules(): array
{
$this->configRulesAreOverridden = null !== $this->options['rules'];
if (null === $this->options['rules']) {
$this->configRulesAreOverridden = false;
return $this->getConfig()->getRules();
}
$rules = trim($this->options['rules']);
if ('' === $rules) {
throw new InvalidConfigurationException('Empty rules value is not allowed.');
}
if (str_starts_with($rules, '{')) {
try {
return json_decode($rules, true, 512, \JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
throw new InvalidConfigurationException(\sprintf('Invalid JSON rules input: "%s".', $e->getMessage()));
}
}
$rules = [];
foreach (explode(',', $this->options['rules']) as $rule) {
$rule = trim($rule);
if ('' === $rule) {
throw new InvalidConfigurationException('Empty rule name is not allowed.');
}
if (str_starts_with($rule, '-')) {
$rules[substr($rule, 1)] = false;
} else {
$rules[$rule] = true;
}
}
$this->configRulesAreOverridden = true;
return $rules;
}
/**
* @param array<string, mixed> $rules
*
* @throws InvalidConfigurationException
*/
private function validateRules(array $rules): void
{
/**
* Create a ruleset that contains all configured rules, even when they originally have been disabled.
*
* @see RuleSet::resolveSet()
*/
$ruleSet = [];
foreach ($rules as $key => $value) {
if (\is_int($key)) {
throw new InvalidConfigurationException(\sprintf('Missing value for "%s" rule/set.', $value));
}
$ruleSet[$key] = true;
}
$ruleSet = new RuleSet($ruleSet);
$configuredFixers = array_keys($ruleSet->getRules());
$fixers = $this->createFixerFactory()->getFixers();
$availableFixers = array_map(static fn (FixerInterface $fixer): string => $fixer->getName(), $fixers);
$unknownFixers = array_diff($configuredFixers, $availableFixers);
if (\count($unknownFixers) > 0) {
/**
* @TODO v4: `renamedRulesFromV2ToV3` no longer needed
* @TODO v3.99: decide how to handle v3 to v4 (where legacy rules are already removed)
*/
$renamedRulesFromV2ToV3 = [
'blank_line_before_return' => [
'new_name' => 'blank_line_before_statement',
'config' => ['statements' => ['return']],
],
'final_static_access' => [
'new_name' => 'self_static_accessor',
],
'hash_to_slash_comment' => [
'new_name' => 'single_line_comment_style',
'config' => ['comment_types' => ['hash']],
],
'lowercase_constants' => [
'new_name' => 'constant_case',
'config' => ['case' => 'lower'],
],
'no_extra_consecutive_blank_lines' => [
'new_name' => 'no_extra_blank_lines',
],
'no_multiline_whitespace_before_semicolons' => [
'new_name' => 'multiline_whitespace_before_semicolons',
],
'no_short_echo_tag' => [
'new_name' => 'echo_tag_syntax',
'config' => ['format' => 'long'],
],
'php_unit_ordered_covers' => [
'new_name' => 'phpdoc_order_by_value',
'config' => ['annotations' => ['covers']],
],
'phpdoc_inline_tag' => [
'new_name' => 'general_phpdoc_tag_rename, phpdoc_inline_tag_normalizer and phpdoc_tag_type',
],
'pre_increment' => [
'new_name' => 'increment_style',
'config' => ['style' => 'pre'],
],
'psr0' => [
'new_name' => 'psr_autoloading',
'config' => ['dir' => 'x'],
],
'psr4' => [
'new_name' => 'psr_autoloading',
],
'silenced_deprecation_error' => [
'new_name' => 'error_suppression',
],
'trailing_comma_in_multiline_array' => [
'new_name' => 'trailing_comma_in_multiline',
'config' => ['elements' => ['arrays']],
],
];
$message = 'The rules contain unknown fixers: ';
$hasOldRule = false;
foreach ($unknownFixers as $unknownFixer) {
if (isset($renamedRulesFromV2ToV3[$unknownFixer])) { // Check if present as old renamed rule
$hasOldRule = true;
$message .= \sprintf(
'"%s" is renamed (did you mean "%s"?%s), ',
$unknownFixer,
$renamedRulesFromV2ToV3[$unknownFixer]['new_name'],
isset($renamedRulesFromV2ToV3[$unknownFixer]['config']) ? ' (note: use configuration "'.Utils::toString($renamedRulesFromV2ToV3[$unknownFixer]['config']).'")' : '',
);
} else { // Go to normal matcher if it is not a renamed rule
$matcher = new WordMatcher($availableFixers);
$alternative = $matcher->match($unknownFixer);
$message .= \sprintf(
'"%s"%s, ',
$unknownFixer,
null === $alternative ? '' : ' (did you mean "'.$alternative.'"?)',
);
}
}
$message = substr($message, 0, -2).'.';
if ($hasOldRule) {
$message .= "\nFor more info about updating see: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/v3.0.0/UPGRADE-v3.md#renamed-ruless.";
}
throw new InvalidConfigurationException($message);
}
foreach ($fixers as $fixer) {
$fixerName = $fixer->getName();
if (isset($rules[$fixerName]) && $fixer instanceof DeprecatedFixerInterface) {
$successors = $fixer->getSuccessorsNames();
$messageEnd = [] === $successors
? \sprintf(' and will be removed in version %d.0.', Application::getMajorVersion() + 1)
: \sprintf('. Use %s instead.', str_replace('`', '"', Utils::naturalLanguageJoinWithBackticks($successors)));
Future::triggerDeprecation(new \RuntimeException("Rule \"{$fixerName}\" is deprecated{$messageEnd}"));
}
}
}
/**
* Apply path on config instance.
*
* @return iterable<\SplFileInfo>
*/
private function resolveFinder(): iterable
{
$this->configFinderIsOverridden = false;
if ($this->isStdIn()) {
return new \ArrayIterator([new StdinFileInfo()]);
}
if (!\in_array(
$this->options['path-mode'],
self::PATH_MODE_VALUES,
true,
)) {
throw new InvalidConfigurationException(\sprintf(
'The path-mode "%s" is not defined, supported are %s.',
$this->options['path-mode'],
Utils::naturalLanguageJoin(self::PATH_MODE_VALUES),
));
}
$isIntersectionPathMode = self::PATH_MODE_INTERSECTION === $this->options['path-mode'];
$paths = array_map(
static fn (string $path): string => realpath($path), // @phpstan-ignore return.type
$this->getPath(),
);
if (0 === \count($paths)) {
if ($isIntersectionPathMode) {
return new \ArrayIterator([]);
}
return $this->iterableToTraversable($this->getConfig()->getFinder());
}
$pathsByType = [
'file' => [],
'dir' => [],
];
foreach ($paths as $path) {
if (is_file($path)) {
$pathsByType['file'][] = $path;
} else {
$pathsByType['dir'][] = $path.\DIRECTORY_SEPARATOR;
}
}
$nestedFinder = null;
$currentFinder = $this->iterableToTraversable($this->getConfig()->getFinder());
try {
$nestedFinder = $currentFinder instanceof \IteratorAggregate ? $currentFinder->getIterator() : $currentFinder;
} catch (\Exception $e) {
}
if ($isIntersectionPathMode) {
if (null === $nestedFinder) {
throw new InvalidConfigurationException(
'Cannot create intersection with not-fully defined Finder in configuration file.',
);
}
return new \CallbackFilterIterator(
new \IteratorIterator($nestedFinder),
static function (\SplFileInfo $current) use ($pathsByType): bool {
$currentRealPath = $current->getRealPath();
if (\in_array($currentRealPath, $pathsByType['file'], true)) {
return true;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | true |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/ErrorOutput.php | src/Console/Output/ErrorOutput.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\Output;
use PhpCsFixer\Differ\DiffConsoleFormatter;
use PhpCsFixer\Error\Error;
use PhpCsFixer\Linter\LintingException;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ErrorOutput
{
private OutputInterface $output;
private bool $isDecorated;
public function __construct(OutputInterface $output)
{
$this->output = $output;
$this->isDecorated = $output->isDecorated();
}
/**
* @param list<Error> $errors
*/
public function listErrors(string $process, array $errors): void
{
$this->output->writeln(['', \sprintf(
'Files that were not fixed due to errors reported during %s:',
$process,
)]);
$showDetails = $this->output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE;
$showTrace = $this->output->getVerbosity() >= OutputInterface::VERBOSITY_DEBUG;
foreach ($errors as $i => $error) {
$this->output->writeln(\sprintf('%4d) %s', $i + 1, $error->getFilePath()));
$e = $error->getSource();
if (!$showDetails || null === $e) {
continue;
}
$class = \sprintf('[%s]', \get_class($e));
$message = $e->getMessage();
$code = $e->getCode();
if (0 !== $code) {
$message .= " ({$code})";
}
$length = max(\strlen($class), \strlen($message));
$lines = [
'',
$class,
$message,
'',
];
$this->output->writeln('');
foreach ($lines as $line) {
if (\strlen($line) < $length) {
$line .= str_repeat(' ', $length - \strlen($line));
}
$this->output->writeln(\sprintf(' <error> %s </error>', $this->prepareOutput($line)));
}
if ($showTrace && !$e instanceof LintingException) { // stack trace of lint exception is of no interest
$this->output->writeln('');
$stackTrace = $e->getTrace();
foreach ($stackTrace as $trace) {
if (isset($trace['class']) && Command::class === $trace['class'] && 'run' === $trace['function']) {
$this->output->writeln(' [ ... ]');
break;
}
$this->outputTrace($trace);
}
}
if (Error::TYPE_LINT === $error->getType() && 0 < \count($error->getAppliedFixers())) {
$this->output->writeln('');
$this->output->writeln(\sprintf(' Applied fixers: <comment>%s</comment>', implode(', ', $error->getAppliedFixers())));
$diff = $error->getDiff();
if (null !== $diff) {
$diffFormatter = new DiffConsoleFormatter(
$this->isDecorated,
\sprintf(
'<comment> ---------- begin diff ----------</comment>%s%%s%s<comment> ----------- end diff -----------</comment>',
\PHP_EOL,
\PHP_EOL,
),
);
$this->output->writeln($diffFormatter->format($diff));
}
}
}
}
/**
* @param array{
* function?: string,
* line?: int,
* file?: string,
* class?: class-string,
* type?: '->'|'::',
* args?: list<mixed>,
* object?: object,
* } $trace
*/
private function outputTrace(array $trace): void
{
if (isset($trace['class'], $trace['type'], $trace['function'])) {
$this->output->writeln(\sprintf(
' <comment>%s</comment>%s<comment>%s()</comment>',
$this->prepareOutput($trace['class']),
$this->prepareOutput($trace['type']),
$this->prepareOutput($trace['function']),
));
} elseif (isset($trace['function'])) {
$this->output->writeln(\sprintf(' <comment>%s()</comment>', $this->prepareOutput($trace['function'])));
}
if (isset($trace['file'])) {
$this->output->writeln(
\sprintf(' in <info>%s</info>', $this->prepareOutput($trace['file']))
.(isset($trace['line']) ? \sprintf(' at line <info>%d</info>', $trace['line']) : ' at unknown line'),
);
}
}
private function prepareOutput(string $string): string
{
return $this->isDecorated
? OutputFormatter::escape($string)
: $string;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/OutputContext.php | src/Console/Output/OutputContext.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\Output;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class OutputContext
{
private ?OutputInterface $output;
private int $terminalWidth;
private int $filesCount;
public function __construct(
?OutputInterface $output,
int $terminalWidth,
int $filesCount
) {
$this->output = $output;
$this->terminalWidth = $terminalWidth;
$this->filesCount = $filesCount;
}
public function getOutput(): ?OutputInterface
{
return $this->output;
}
public function getTerminalWidth(): int
{
return $this->terminalWidth;
}
public function getFilesCount(): int
{
return $this->filesCount;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/ProgressOutputFactory.php | src/Console/Output/Progress/ProgressOutputFactory.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\Output\Progress;
use PhpCsFixer\Console\Output\OutputContext;
/**
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ProgressOutputFactory
{
/**
* @var array<ProgressOutputType::*, class-string<ProgressOutputInterface>>
*/
private const OUTPUT_TYPE_MAP = [
ProgressOutputType::NONE => NullOutput::class,
ProgressOutputType::DOTS => DotsOutput::class,
ProgressOutputType::BAR => PercentageBarOutput::class,
];
/**
* @param ProgressOutputType::* $outputType
*/
public function create(string $outputType, OutputContext $context): ProgressOutputInterface
{
if (null === $context->getOutput()) {
$outputType = ProgressOutputType::NONE;
}
if (!$this->isBuiltInType($outputType)) {
throw new \InvalidArgumentException(
\sprintf(
'Something went wrong, "%s" output type is not supported',
$outputType,
),
);
}
$outputClass = self::OUTPUT_TYPE_MAP[$outputType];
// @phpstan-ignore-next-line new.noConstructor
return new $outputClass($context);
}
private function isBuiltInType(string $outputType): bool
{
return \in_array($outputType, ProgressOutputType::all(), true);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/ProgressOutputType.php | src/Console/Output/Progress/ProgressOutputType.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\Output\Progress;
/**
* @TODO PHP 8.1 switch this and similar classes to ENUM
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ProgressOutputType
{
public const NONE = 'none';
public const DOTS = 'dots';
public const BAR = 'bar';
/**
* @return non-empty-list<ProgressOutputType::*>
*/
public static function all(): array
{
return [
self::BAR,
self::DOTS,
self::NONE,
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/PercentageBarOutput.php | src/Console/Output/Progress/PercentageBarOutput.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\Output\Progress;
use PhpCsFixer\Console\Output\OutputContext;
use PhpCsFixer\Runner\Event\FileProcessed;
use Symfony\Component\Console\Helper\ProgressBar;
/**
* Output writer to show the progress of a FixCommand using progress bar (percentage).
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PercentageBarOutput implements ProgressOutputInterface
{
/** @readonly */
private OutputContext $context;
private ProgressBar $progressBar;
public function __construct(OutputContext $context)
{
$this->context = $context;
$this->progressBar = new ProgressBar($context->getOutput(), $this->context->getFilesCount());
$this->progressBar->setBarCharacter('▓'); // dark shade character \u2593
$this->progressBar->setEmptyBarCharacter('░'); // light shade character \u2591
$this->progressBar->setProgressCharacter('');
$this->progressBar->setFormat('normal');
$this->progressBar->start();
}
/**
* This class is not intended to be serialized,
* and cannot be deserialized (see __wakeup method).
*/
public function __sleep(): array
{
throw new \BadMethodCallException('Cannot serialize '.self::class);
}
/**
* Disable the deserialization of the class to prevent attacker executing
* code by leveraging the __destruct method.
*
* @see https://owasp.org/www-community/vulnerabilities/PHP_Object_Injection
*/
public function __wakeup(): void
{
throw new \BadMethodCallException('Cannot unserialize '.self::class);
}
public function onFixerFileProcessed(FileProcessed $event): void
{
$this->progressBar->advance(1);
if ($this->progressBar->getProgress() === $this->progressBar->getMaxSteps()) {
$this->context->getOutput()->write("\n\n");
}
}
public function printLegend(): void {}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/ProgressOutputInterface.php | src/Console/Output/Progress/ProgressOutputInterface.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\Output\Progress;
use PhpCsFixer\Runner\Event\FileProcessed;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface ProgressOutputInterface
{
public function printLegend(): void;
public function onFixerFileProcessed(FileProcessed $event): void;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/DotsOutput.php | src/Console/Output/Progress/DotsOutput.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\Output\Progress;
use PhpCsFixer\Console\Output\OutputContext;
use PhpCsFixer\Runner\Event\FileProcessed;
use Symfony\Component\Console\Output\OutputInterface;
/**
* Output writer to show the progress of a FixCommand using dots and meaningful letters.
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class DotsOutput implements ProgressOutputInterface
{
/**
* File statuses map.
*
* @var array<FileProcessed::STATUS_*, array{symbol: string, format: string, description: string}>
*/
private const EVENT_STATUS_MAP = [
FileProcessed::STATUS_NO_CHANGES => ['symbol' => '.', 'format' => '%s', 'description' => 'no changes'],
FileProcessed::STATUS_FIXED => ['symbol' => 'F', 'format' => '<fg=green>%s</fg=green>', 'description' => 'fixed'],
FileProcessed::STATUS_SKIPPED => ['symbol' => 'S', 'format' => '<fg=cyan>%s</fg=cyan>', 'description' => 'skipped (cached or empty file)'],
FileProcessed::STATUS_NON_MONOLITHIC => ['symbol' => 'M', 'format' => '<bg=magenta>%s</bg=magenta>', 'description' => 'skipped (non-monolithic)'],
FileProcessed::STATUS_INVALID => ['symbol' => 'I', 'format' => '<bg=red>%s</bg=red>', 'description' => 'invalid file syntax (file ignored)'],
FileProcessed::STATUS_EXCEPTION => ['symbol' => 'E', 'format' => '<bg=red>%s</bg=red>', 'description' => 'error'],
FileProcessed::STATUS_LINT => ['symbol' => 'E', 'format' => '<bg=red>%s</bg=red>', 'description' => 'error'],
];
/** @readonly */
private OutputContext $context;
private int $processedFiles = 0;
private int $symbolsPerLine;
public function __construct(OutputContext $context)
{
$this->context = $context;
// max number of characters per line
// - total length x 2 (e.g. " 1 / 123" => 6 digits and padding spaces)
// - 11 (extra spaces, parentheses and percentage characters, e.g. " x / x (100%)")
$this->symbolsPerLine = max(1, $context->getTerminalWidth() - \strlen((string) $context->getFilesCount()) * 2 - 11);
}
/**
* This class is not intended to be serialized,
* and cannot be deserialized (see __wakeup method).
*/
public function __sleep(): array
{
throw new \BadMethodCallException('Cannot serialize '.self::class);
}
/**
* Disable the deserialization of the class to prevent attacker executing
* code by leveraging the __destruct method.
*
* @see https://owasp.org/www-community/vulnerabilities/PHP_Object_Injection
*/
public function __wakeup(): void
{
throw new \BadMethodCallException('Cannot unserialize '.self::class);
}
public function onFixerFileProcessed(FileProcessed $event): void
{
$status = self::EVENT_STATUS_MAP[$event->getStatus()];
$this->getOutput()->write($this->getOutput()->isDecorated() ? \sprintf($status['format'], $status['symbol']) : $status['symbol']);
++$this->processedFiles;
$symbolsOnCurrentLine = $this->processedFiles % $this->symbolsPerLine;
$isLast = $this->processedFiles === $this->context->getFilesCount();
if (0 === $symbolsOnCurrentLine || $isLast) {
$this->getOutput()->write(\sprintf(
'%s %'.\strlen((string) $this->context->getFilesCount()).'d / %d (%3d%%)',
$isLast && 0 !== $symbolsOnCurrentLine ? str_repeat(' ', $this->symbolsPerLine - $symbolsOnCurrentLine) : '',
$this->processedFiles,
$this->context->getFilesCount(),
round($this->processedFiles / $this->context->getFilesCount() * 100),
));
if (!$isLast) {
$this->getOutput()->writeln('');
}
}
}
public function printLegend(): void
{
$symbols = [];
foreach (self::EVENT_STATUS_MAP as $status) {
$symbol = $status['symbol'];
if (isset($symbols[$symbol])) {
continue;
}
$symbols[$symbol] = \sprintf('%s-%s', $this->getOutput()->isDecorated() ? \sprintf($status['format'], $symbol) : $symbol, $status['description']);
}
$this->getOutput()->write(\sprintf("\nLegend: %s\n", implode(', ', $symbols)));
}
private function getOutput(): OutputInterface
{
return $this->context->getOutput();
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Output/Progress/NullOutput.php | src/Console/Output/Progress/NullOutput.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\Output\Progress;
use PhpCsFixer\Runner\Event\FileProcessed;
/**
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class NullOutput implements ProgressOutputInterface
{
public function printLegend(): void {}
public function onFixerFileProcessed(FileProcessed $event): void {}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Internal/Application.php | src/Console/Internal/Application.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\Internal;
use PhpCsFixer\Console\Application as PublicApplication;
use PhpCsFixer\Console\Command\HelpCommand;
use PhpCsFixer\Console\Internal\Command\DecodeIdCommand;
use PhpCsFixer\Console\Internal\Command\DocumentationCommand;
use PhpCsFixer\Console\Internal\Command\ParseCommand;
use Symfony\Component\Console\Application as BaseApplication;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Command\CompleteCommand;
use Symfony\Component\Console\Command\DumpCompletionCommand;
use Symfony\Component\Console\Command\ListCommand;
use Symfony\Component\Filesystem\Filesystem;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class Application extends BaseApplication
{
public function __construct(
?Filesystem $filesystem = null
) {
$filesystem ??= new Filesystem();
parent::__construct(
\sprintf('%s - %s', PublicApplication::NAME, 'internal'),
PublicApplication::VERSION,
);
$this->add(new DecodeIdCommand());
$this->add(new DocumentationCommand($filesystem));
$this->add(new ParseCommand());
}
// polyfill for `add` method, as it is not available in Symfony 8.0
public function add(Command $command): ?Command
{
if (method_exists($this, 'addCommand')) { // @phpstan-ignore-line
return $this->addCommand($command);
}
return parent::add($command);
}
public function getLongVersion(): string
{
return str_replace(
PublicApplication::NAME,
$this->getName(),
PublicApplication::getAboutWithRuntime(true),
);
}
protected function getDefaultCommands(): array
{
return [new HelpCommand(), new ListCommand(), new CompleteCommand(), new DumpCompletionCommand()];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Internal/Command/ParseCommand.php | src/Console/Internal/Command/ParseCommand.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\Internal\Command;
use PhpCsFixer\Tokenizer\Tokens;
use Symfony\Component\Console\Attribute\AsCommand;
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\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'parse', description: 'Parse file into tokens.')]
final class ParseCommand extends Command
{
public const MODE_NATIVE = 'native';
public const MODE_FIXER = 'fixer';
public const FORMAT_DUMP = 'dump';
public const FORMAT_JSON = 'json';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'parse';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Parse file into tokens.';
protected function configure(): void
{
$this
->setDefinition(
[
new InputArgument('path', InputArgument::REQUIRED),
new InputOption('mode', null, InputOption::VALUE_REQUIRED, 'Parsing mode: `fixer` or `native`.', self::MODE_FIXER, [self::MODE_NATIVE, self::MODE_FIXER]),
new InputOption('format', null, InputOption::VALUE_REQUIRED, 'Output format: `json` or `dump`.', self::FORMAT_JSON, [self::FORMAT_DUMP, self::FORMAT_JSON]),
],
)
;
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$stdErr = $output instanceof ConsoleOutputInterface
? $output->getErrorOutput()
: $output;
$path = $input->getArgument('path');
$mode = $input->getOption('mode');
$format = $input->getOption('format');
if (!\in_array($mode, [self::MODE_FIXER, self::MODE_NATIVE], true)) {
$stdErr->writeln('<error>Invalid "mode" option.</error>');
return 1;
}
if (!\in_array($format, [self::FORMAT_DUMP, self::FORMAT_JSON], true)) {
$stdErr->writeln('<error>Invalid "format" option.</error>');
return 1;
}
$code = @file_get_contents($path);
if (false === $code) {
$stdErr->writeln('<error>Cannot read file.</error>');
return 1;
}
if (self::MODE_FIXER === $mode) {
$tokens = Tokens::fromCode($code);
$tokensJson = $tokens->toJson();
} else {
$tokens = \defined('TOKEN_PARSE')
? token_get_all($code, \TOKEN_PARSE)
: token_get_all($code);
$tokensJson = json_encode(\SplFixedArray::fromArray($tokens), \JSON_THROW_ON_ERROR | \JSON_PRETTY_PRINT | \JSON_NUMERIC_CHECK);
}
if (self::FORMAT_DUMP === $format) {
$output->writeln(var_export($tokens, true));
} else {
$output->writeln($tokensJson);
}
return 0;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Internal/Command/DocumentationCommand.php | src/Console/Internal/Command/DocumentationCommand.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\Internal\Command;
use PhpCsFixer\Documentation\DocumentationLocator;
use PhpCsFixer\Documentation\FixerDocumentGenerator;
use PhpCsFixer\Documentation\RuleSetDocumentationGenerator;
use PhpCsFixer\FixerFactory;
use PhpCsFixer\RuleSet\RuleSets;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Finder\Finder;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'documentation', description: 'Dumps the documentation of the project into its "/doc" directory.')]
final class DocumentationCommand extends Command
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'documentation';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Dumps the documentation of the project into its "/doc" directory.';
private Filesystem $filesystem;
public function __construct(Filesystem $filesystem)
{
parent::__construct();
$this->filesystem = $filesystem;
}
protected function configure(): void
{
$this->setAliases(['docs']);
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$locator = new DocumentationLocator();
$fixerFactory = new FixerFactory();
$fixerFactory->registerBuiltInFixers();
$fixers = $fixerFactory->getFixers();
$setDefinitions = RuleSets::getBuiltInSetDefinitions();
$fixerDocumentGenerator = new FixerDocumentGenerator($locator);
$ruleSetDocumentationGenerator = new RuleSetDocumentationGenerator($locator);
// Array of existing fixer docs.
// We first override existing files, and then we will delete files that are no longer needed.
// We cannot remove all files first, as generation of docs is re-using existing docs to extract code-samples for
// VersionSpecificCodeSample under incompatible PHP version.
$docForFixerRelativePaths = [];
foreach ($fixers as $fixer) {
$docForFixerRelativePaths[] = $locator->getFixerDocumentationFileRelativePath($fixer);
$this->filesystem->dumpFile(
$locator->getFixerDocumentationFilePath($fixer),
$fixerDocumentGenerator->generateFixerDocumentation($fixer),
);
}
foreach (
(new Finder())->files()
->in($locator->getFixersDocumentationDirectoryPath())
->notPath($docForFixerRelativePaths) as $file
) {
$this->filesystem->remove($file->getPathname());
}
// Fixer doc. index
$this->filesystem->dumpFile(
$locator->getFixersDocumentationIndexFilePath(),
$fixerDocumentGenerator->generateFixersDocumentationIndex($fixers),
);
// RuleSet docs.
foreach ((new Finder())->files()->in($locator->getRuleSetsDocumentationDirectoryPath()) as $file) {
$this->filesystem->remove($file->getPathname());
}
$paths = [];
foreach ($setDefinitions as $name => $definition) {
$path = $locator->getRuleSetsDocumentationFilePath($name);
$paths[$path] = $definition;
$this->filesystem->dumpFile($path, $ruleSetDocumentationGenerator->generateRuleSetsDocumentation($definition, $fixers));
}
// RuleSet doc. index
$this->filesystem->dumpFile(
$locator->getRuleSetsDocumentationIndexFilePath(),
$ruleSetDocumentationGenerator->generateRuleSetsDocumentationIndex($paths),
);
$output->writeln('Docs updated.');
return 0;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Internal/Command/DecodeIdCommand.php | src/Console/Internal/Command/DecodeIdCommand.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\Internal\Command;
use PhpCsFixer\Tokenizer\Token;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'decode-id', description: 'Get symbolic name of token id.')]
final class DecodeIdCommand extends Command
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'decode-id';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Get symbolic name of token id.';
protected function configure(): void
{
$this
->setDefinition(
[
new InputArgument('id', InputArgument::REQUIRED),
],
)
;
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$stdErr = $output instanceof ConsoleOutputInterface
? $output->getErrorOutput()
: $output;
$id = $input->getArgument('id');
if (false === filter_var($id, \FILTER_VALIDATE_INT)) {
$stdErr->writeln('<error>Non-numeric "id" value.</error>');
return 1;
}
$id = \intval($id, 10);
$name = Token::getNameForId($id);
if (null === $name) {
$stdErr->writeln('<error>Unknown "id".</error>');
return 1;
}
$output->writeln($name);
return 0;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/SelfUpdate/GithubClientInterface.php | src/Console/SelfUpdate/GithubClientInterface.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\SelfUpdate;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface GithubClientInterface
{
/**
* @return list<string>
*/
public function getTags(): array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/SelfUpdate/NewVersionChecker.php | src/Console/SelfUpdate/NewVersionChecker.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\SelfUpdate;
use Composer\Semver\Comparator;
use Composer\Semver\Semver;
use Composer\Semver\VersionParser;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class NewVersionChecker implements NewVersionCheckerInterface
{
private GithubClientInterface $githubClient;
private VersionParser $versionParser;
/**
* @var null|list<string>
*/
private ?array $availableVersions = null;
public function __construct(GithubClientInterface $githubClient)
{
$this->githubClient = $githubClient;
$this->versionParser = new VersionParser();
}
public function getLatestVersion(): string
{
$this->retrieveAvailableVersions();
return $this->availableVersions[0];
}
public function getLatestVersionOfMajor(int $majorVersion): ?string
{
$this->retrieveAvailableVersions();
$semverConstraint = '^'.$majorVersion;
foreach ($this->availableVersions as $availableVersion) {
if (Semver::satisfies($availableVersion, $semverConstraint)) {
return $availableVersion;
}
}
return null;
}
public function compareVersions(string $versionA, string $versionB): int
{
$versionA = $this->versionParser->normalize($versionA);
$versionB = $this->versionParser->normalize($versionB);
if (Comparator::lessThan($versionA, $versionB)) {
return -1;
}
if (Comparator::greaterThan($versionA, $versionB)) {
return 1;
}
return 0;
}
private function retrieveAvailableVersions(): void
{
if (null !== $this->availableVersions) {
return;
}
foreach ($this->githubClient->getTags() as $version) {
try {
$this->versionParser->normalize($version);
if ('stable' === VersionParser::parseStability($version)) {
$this->availableVersions[] = $version;
}
} catch (\UnexpectedValueException $exception) {
// not a valid version tag
}
}
$versions = Semver::rsort($this->availableVersions);
\assert(array_is_list($versions)); // Semver::rsort provides soft `array` type, let's validate and ensure proper type for SCA
$this->availableVersions = $versions;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/SelfUpdate/NewVersionCheckerInterface.php | src/Console/SelfUpdate/NewVersionCheckerInterface.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\SelfUpdate;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface NewVersionCheckerInterface
{
/**
* Returns the tag of the latest version.
*/
public function getLatestVersion(): string;
/**
* Returns the tag of the latest minor/patch version of the given major version.
*/
public function getLatestVersionOfMajor(int $majorVersion): ?string;
/**
* Returns -1, 0, or 1 if the first version is respectively less than,
* equal to, or greater than the second.
*/
public function compareVersions(string $versionA, string $versionB): int;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/SelfUpdate/GithubClient.php | src/Console/SelfUpdate/GithubClient.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\SelfUpdate;
/**
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class GithubClient implements GithubClientInterface
{
private string $url;
public function __construct(string $url = 'https://api.github.com/repos/PHP-CS-Fixer/PHP-CS-Fixer/tags')
{
$this->url = $url;
}
public function getTags(): array
{
$result = @file_get_contents(
$this->url,
false,
stream_context_create([
'http' => [
'header' => 'User-Agent: PHP-CS-Fixer/PHP-CS-Fixer',
],
]),
);
if (false === $result) {
throw new \RuntimeException(\sprintf('Failed to load tags at "%s".', $this->url));
}
try {
/**
* @var list<array{
* name: string,
* zipball_url: string,
* tarball_url: string,
* commit: array{sha: string, url: string},
* }>
*/
$result = json_decode($result, true, 512, \JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
throw new \RuntimeException(\sprintf(
'Failed to read response from "%s" as JSON: %s.',
$this->url,
$e->getMessage(),
));
}
return array_map(
static fn (array $tagData): string => $tagData['name'],
$result,
);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/ListSetsReport/TextReporter.php | src/Console/Report/ListSetsReport/TextReporter.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\Report\ListSetsReport;
use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class TextReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'txt';
}
public function generate(ReportSummary $reportSummary): string
{
$sets = $reportSummary->getSets();
usort($sets, static fn (RuleSetDefinitionInterface $a, RuleSetDefinitionInterface $b): int => $a->getName() <=> $b->getName());
$output = '';
foreach ($sets as $i => $set) {
$output .= \sprintf('%2d) %s', $i + 1, $set->getName()).\PHP_EOL.' '.$set->getDescription().\PHP_EOL;
if ($set->isRisky()) {
$output .= ' Set contains risky rules.'.\PHP_EOL;
}
}
return $output;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/ListSetsReport/ReporterFactory.php | src/Console/Report/ListSetsReport/ReporterFactory.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\Report\ListSetsReport;
use Symfony\Component\Finder\Finder as SymfonyFinder;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ReporterFactory
{
/**
* @var array<string, ReporterInterface>
*/
private array $reporters = [];
public function registerBuiltInReporters(): self
{
/** @var null|list<class-string<ReporterInterface>> $builtInReporters */
static $builtInReporters;
if (null === $builtInReporters) {
$builtInReporters = [];
foreach (SymfonyFinder::create()->files()->name('*Reporter.php')->in(__DIR__) as $file) {
$relativeNamespace = $file->getRelativePath();
/** @var class-string<ReporterInterface> $class */
$class = \sprintf(
'%s\%s%s',
__NAMESPACE__,
'' !== $relativeNamespace ? $relativeNamespace.'\\' : '',
$file->getBasename('.php'),
);
$builtInReporters[] = $class;
}
}
foreach ($builtInReporters as $reporterClass) {
$this->registerReporter(new $reporterClass());
}
return $this;
}
public function registerReporter(ReporterInterface $reporter): self
{
$format = $reporter->getFormat();
if (isset($this->reporters[$format])) {
throw new \UnexpectedValueException(\sprintf('Reporter for format "%s" is already registered.', $format));
}
$this->reporters[$format] = $reporter;
return $this;
}
/**
* @return list<string>
*/
public function getFormats(): array
{
$formats = array_keys($this->reporters);
sort($formats);
return $formats;
}
public function getReporter(string $format): ReporterInterface
{
if (!isset($this->reporters[$format])) {
throw new \UnexpectedValueException(\sprintf('Reporter for format "%s" is not registered.', $format));
}
return $this->reporters[$format];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/ListSetsReport/JsonReporter.php | src/Console/Report/ListSetsReport/JsonReporter.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\Report\ListSetsReport;
use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class JsonReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'json';
}
public function generate(ReportSummary $reportSummary): string
{
$sets = $reportSummary->getSets();
usort($sets, static fn (RuleSetDefinitionInterface $a, RuleSetDefinitionInterface $b): int => $a->getName() <=> $b->getName());
$json = ['sets' => []];
foreach ($sets as $set) {
$setName = $set->getName();
$json['sets'][$setName] = [
'description' => $set->getDescription(),
'isRisky' => $set->isRisky(),
'name' => $setName,
];
}
return json_encode($json, \JSON_THROW_ON_ERROR | \JSON_PRETTY_PRINT);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/ListSetsReport/ReporterInterface.php | src/Console/Report/ListSetsReport/ReporterInterface.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\Report\ListSetsReport;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface ReporterInterface
{
public function getFormat(): string;
/**
* Process changed files array. Returns generated report.
*/
public function generate(ReportSummary $reportSummary): string;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/ListSetsReport/ReportSummary.php | src/Console/Report/ListSetsReport/ReportSummary.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\Report\ListSetsReport;
use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ReportSummary
{
/**
* @var list<RuleSetDefinitionInterface>
*/
private array $sets;
/**
* @param list<RuleSetDefinitionInterface> $sets
*/
public function __construct(array $sets)
{
$this->sets = $sets;
}
/**
* @return list<RuleSetDefinitionInterface>
*/
public function getSets(): array
{
return $this->sets;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/TextReporter.php | src/Console/Report/FixReport/TextReporter.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\Report\FixReport;
use PhpCsFixer\Differ\DiffConsoleFormatter;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class TextReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'txt';
}
public function generate(ReportSummary $reportSummary): string
{
$output = '';
$identifiedFiles = 0;
foreach ($reportSummary->getChanged() as $file => $fixResult) {
++$identifiedFiles;
$output .= \sprintf('%4d) %s', $identifiedFiles, $file);
if ($reportSummary->shouldAddAppliedFixers()) {
$output .= $this->getAppliedFixers(
$reportSummary->isDecoratedOutput(),
$fixResult['appliedFixers'],
);
}
$output .= $this->getDiff($reportSummary->isDecoratedOutput(), $fixResult['diff']);
$output .= \PHP_EOL;
}
return $output.$this->getFooter(
$reportSummary->getTime(),
$identifiedFiles,
$reportSummary->getFilesCount(),
$reportSummary->getMemory(),
$reportSummary->isDryRun(),
);
}
/**
* @param list<string> $appliedFixers
*/
private function getAppliedFixers(bool $isDecoratedOutput, array $appliedFixers): string
{
return \sprintf(
$isDecoratedOutput ? ' (<comment>%s</comment>)' : ' (%s)',
implode(', ', $appliedFixers),
);
}
private function getDiff(bool $isDecoratedOutput, string $diff): string
{
if ('' === $diff) {
return '';
}
$diffFormatter = new DiffConsoleFormatter($isDecoratedOutput, \sprintf(
'<comment> ---------- begin diff ----------</comment>%s%%s%s<comment> ----------- end diff -----------</comment>',
\PHP_EOL,
\PHP_EOL,
));
return \PHP_EOL.$diffFormatter->format($diff).\PHP_EOL;
}
private function getFooter(int $time, int $identifiedFiles, int $files, int $memory, bool $isDryRun): string
{
if (0 === $time || 0 === $memory) {
return '';
}
return \PHP_EOL.\sprintf(
'%s %d of %d %s in %.3f seconds, %.2f MB memory used'.\PHP_EOL,
$isDryRun ? 'Found' : 'Fixed',
$identifiedFiles,
$files,
$isDryRun ? 'files that can be fixed' : 'files',
$time / 1_000,
$memory / 1_024 / 1_024,
);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/XmlReporter.php | src/Console/Report/FixReport/XmlReporter.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\Report\FixReport;
use PhpCsFixer\Console\Application;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class XmlReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'xml';
}
public function generate(ReportSummary $reportSummary): string
{
if (!\extension_loaded('dom')) {
throw new \RuntimeException('Cannot generate report! `ext-dom` is not available!');
}
$dom = new \DOMDocument('1.0', 'UTF-8');
// new nodes should be added to this or existing children
$root = $dom->createElement('report');
$dom->appendChild($root);
$root->appendChild($this->createAboutElement($dom, Application::getAbout()));
$filesXML = $dom->createElement('files');
$root->appendChild($filesXML);
$i = 1;
foreach ($reportSummary->getChanged() as $file => $fixResult) {
$fileXML = $dom->createElement('file');
$fileXML->setAttribute('id', (string) $i++);
$fileXML->setAttribute('name', $file);
$filesXML->appendChild($fileXML);
if ($reportSummary->shouldAddAppliedFixers()) {
$fileXML->appendChild(
$this->createAppliedFixersElement($dom, $fixResult['appliedFixers']),
);
}
if ('' !== $fixResult['diff']) {
$fileXML->appendChild($this->createDiffElement($dom, $fixResult['diff']));
}
}
if (0 !== $reportSummary->getTime()) {
$root->appendChild($this->createTimeElement($reportSummary->getTime(), $dom));
}
if (0 !== $reportSummary->getMemory()) {
$root->appendChild($this->createMemoryElement($reportSummary->getMemory(), $dom));
}
$dom->formatOutput = true;
$result = $dom->saveXML();
if (false === $result) {
throw new \RuntimeException('Failed to generate XML output');
}
return $reportSummary->isDecoratedOutput() ? OutputFormatter::escape($result) : $result;
}
/**
* @param list<string> $appliedFixers
*/
private function createAppliedFixersElement(\DOMDocument $dom, array $appliedFixers): \DOMElement
{
$appliedFixersXML = $dom->createElement('applied_fixers');
foreach ($appliedFixers as $appliedFixer) {
$appliedFixerXML = $dom->createElement('applied_fixer');
$appliedFixerXML->setAttribute('name', $appliedFixer);
$appliedFixersXML->appendChild($appliedFixerXML);
}
return $appliedFixersXML;
}
private function createDiffElement(\DOMDocument $dom, string $diff): \DOMElement
{
$diffXML = $dom->createElement('diff');
$diffXML->appendChild($dom->createCDATASection($diff));
return $diffXML;
}
private function createTimeElement(float $time, \DOMDocument $dom): \DOMElement
{
$time = round($time / 1_000, 3);
$timeXML = $dom->createElement('time');
$timeXML->setAttribute('unit', 's');
$timeTotalXML = $dom->createElement('total');
$timeTotalXML->setAttribute('value', (string) $time);
$timeXML->appendChild($timeTotalXML);
return $timeXML;
}
private function createMemoryElement(float $memory, \DOMDocument $dom): \DOMElement
{
$memory = round($memory / 1_024 / 1_024, 3);
$memoryXML = $dom->createElement('memory');
$memoryXML->setAttribute('value', (string) $memory);
$memoryXML->setAttribute('unit', 'MB');
return $memoryXML;
}
private function createAboutElement(\DOMDocument $dom, string $about): \DOMElement
{
$xml = $dom->createElement('about');
$xml->setAttribute('value', $about);
return $xml;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/GitlabReporter.php | src/Console/Report/FixReport/GitlabReporter.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\Report\FixReport;
use PhpCsFixer\Console\Application;
use PhpCsFixer\Documentation\DocumentationLocator;
use PhpCsFixer\Fixer\FixerInterface;
use PhpCsFixer\FixerFactory;
use SebastianBergmann\Diff\Chunk;
use SebastianBergmann\Diff\Diff;
use SebastianBergmann\Diff\Line;
use SebastianBergmann\Diff\Parser;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* Generates a report according to gitlabs subset of codeclimate json files.
*
* @author Hans-Christian Otto <c.otto@suora.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @see https://github.com/codeclimate/platform/blob/master/spec/analyzers/SPEC.md#data-types
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class GitlabReporter implements ReporterInterface
{
private Parser $diffParser;
private DocumentationLocator $documentationLocator;
private FixerFactory $fixerFactory;
/**
* @var array<string, FixerInterface>
*/
private array $fixers;
public function __construct()
{
$this->diffParser = new Parser();
$this->documentationLocator = new DocumentationLocator();
$this->fixerFactory = new FixerFactory();
$this->fixerFactory->registerBuiltInFixers();
$this->fixers = $this->createFixers();
}
public function getFormat(): string
{
return 'gitlab';
}
/**
* Process changed files array. Returns generated report.
*/
public function generate(ReportSummary $reportSummary): string
{
$about = Application::getAbout();
$report = [];
foreach ($reportSummary->getChanged() as $fileName => $change) {
foreach ($change['appliedFixers'] as $fixerName) {
$fixer = $this->fixers[$fixerName] ?? null;
$report[] = [
'check_name' => 'PHP-CS-Fixer.'.$fixerName,
'description' => null !== $fixer
? $fixer->getDefinition()->getSummary()
: 'PHP-CS-Fixer.'.$fixerName.' (custom rule)',
'content' => [
'body' => \sprintf(
"%s\n%s",
$about,
null !== $fixer
? \sprintf(
'Check [docs](https://cs.symfony.com/doc/rules/%s.html) for more information.',
substr($this->documentationLocator->getFixerDocumentationFileRelativePath($fixer), 0, -4), // -4 to drop `.rst`
)
: 'Check performed with a custom rule.',
),
],
'categories' => ['Style'],
'fingerprint' => md5($fileName.$fixerName),
'severity' => 'minor',
'location' => [
'path' => $fileName,
'lines' => self::getLines($this->diffParser->parse($change['diff'])),
],
];
}
}
$jsonString = json_encode($report, \JSON_THROW_ON_ERROR);
return $reportSummary->isDecoratedOutput() ? OutputFormatter::escape($jsonString) : $jsonString;
}
/**
* @param list<Diff> $diffs
*
* @return array{begin: int, end: int}
*/
private static function getLines(array $diffs): array
{
if (isset($diffs[0])) {
$firstDiff = $diffs[0];
$firstChunk = \Closure::bind(static fn (Diff $diff) => array_shift($diff->chunks), null, $firstDiff)($firstDiff);
if ($firstChunk instanceof Chunk) {
return self::getBeginEndForDiffChunk($firstChunk);
}
}
return ['begin' => 0, 'end' => 0];
}
/**
* @return array{begin: int, end: int}
*/
private static function getBeginEndForDiffChunk(Chunk $chunk): array
{
$start = \Closure::bind(static fn (Chunk $chunk): int => $chunk->start, null, $chunk)($chunk);
$startRange = \Closure::bind(static fn (Chunk $chunk): int => $chunk->startRange, null, $chunk)($chunk);
$lines = \Closure::bind(static fn (Chunk $chunk): array => $chunk->lines, null, $chunk)($chunk);
\assert(\count($lines) > 0);
$firstModifiedLineOffset = array_find_key($lines, static function (Line $line): bool {
$type = \Closure::bind(static fn (Line $line): int => $line->type, null, $line)($line);
return Line::UNCHANGED !== $type;
});
\assert(\is_int($firstModifiedLineOffset));
return [
// offset the start by where the first line is actually modified
'begin' => $start + $firstModifiedLineOffset,
// it's not where last modification takes place, only where diff (with --context) ends
'end' => $start + $startRange,
];
}
/**
* @return array<string, FixerInterface>
*/
private function createFixers(): array
{
$fixers = [];
foreach ($this->fixerFactory->getFixers() as $fixer) {
$fixers[$fixer->getName()] = $fixer;
}
ksort($fixers);
return $fixers;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/JunitReporter.php | src/Console/Report/FixReport/JunitReporter.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\Report\FixReport;
use PhpCsFixer\Console\Application;
use PhpCsFixer\Preg;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class JunitReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'junit';
}
public function generate(ReportSummary $reportSummary): string
{
if (!\extension_loaded('dom')) {
throw new \RuntimeException('Cannot generate report! `ext-dom` is not available!');
}
$dom = new \DOMDocument('1.0', 'UTF-8');
$testsuites = $dom->appendChild($dom->createElement('testsuites'));
$testsuite = $testsuites->appendChild($dom->createElement('testsuite'));
\assert($testsuite instanceof \DOMElement);
$testsuite->setAttribute('name', 'PHP CS Fixer');
$properties = $dom->createElement('properties');
$property = $dom->createElement('property');
$property->setAttribute('name', 'about');
$property->setAttribute('value', Application::getAbout());
$properties->appendChild($property);
$testsuite->appendChild($properties);
if (\count($reportSummary->getChanged()) > 0) {
$this->createFailedTestCases($dom, $testsuite, $reportSummary);
} else {
$this->createSuccessTestCase($dom, $testsuite);
}
if ($reportSummary->getTime() > 0) {
$testsuite->setAttribute(
'time',
\sprintf(
'%.3f',
$reportSummary->getTime() / 1_000,
),
);
}
$dom->formatOutput = true;
$result = $dom->saveXML();
if (false === $result) {
throw new \RuntimeException('Failed to generate XML output');
}
return $reportSummary->isDecoratedOutput() ? OutputFormatter::escape($result) : $result;
}
private function createSuccessTestCase(\DOMDocument $dom, \DOMElement $testsuite): void
{
$testcase = $dom->createElement('testcase');
$testcase->setAttribute('name', 'All OK');
$testcase->setAttribute('assertions', '1');
$testsuite->appendChild($testcase);
$testsuite->setAttribute('tests', '1');
$testsuite->setAttribute('assertions', '1');
$testsuite->setAttribute('failures', '0');
$testsuite->setAttribute('errors', '0');
}
private function createFailedTestCases(\DOMDocument $dom, \DOMElement $testsuite, ReportSummary $reportSummary): void
{
$assertionsCount = 0;
foreach ($reportSummary->getChanged() as $file => $fixResult) {
$testcase = $this->createFailedTestCase(
$dom,
$file,
$fixResult,
$reportSummary->shouldAddAppliedFixers(),
);
$testsuite->appendChild($testcase);
$assertionsCount += (int) $testcase->getAttribute('assertions');
}
$testsuite->setAttribute('tests', (string) \count($reportSummary->getChanged()));
$testsuite->setAttribute('assertions', (string) $assertionsCount);
$testsuite->setAttribute('failures', (string) $assertionsCount);
$testsuite->setAttribute('errors', '0');
}
/**
* @param array{appliedFixers: list<string>, diff: string} $fixResult
*/
private function createFailedTestCase(\DOMDocument $dom, string $file, array $fixResult, bool $shouldAddAppliedFixers): \DOMElement
{
$appliedFixersCount = \count($fixResult['appliedFixers']);
$testName = str_replace('.', '_DOT_', Preg::replace('@\.'.pathinfo($file, \PATHINFO_EXTENSION).'$@', '', $file));
$testcase = $dom->createElement('testcase');
$testcase->setAttribute('name', $testName);
$testcase->setAttribute('file', $file);
$testcase->setAttribute('assertions', (string) $appliedFixersCount);
$failure = $dom->createElement('failure');
$failure->setAttribute('type', 'code_style');
$testcase->appendChild($failure);
if ($shouldAddAppliedFixers) {
$failureContent = "applied fixers:\n---------------\n";
foreach ($fixResult['appliedFixers'] as $appliedFixer) {
$failureContent .= "* {$appliedFixer}\n";
}
} else {
$failureContent = "Wrong code style\n";
}
if ('' !== $fixResult['diff']) {
$failureContent .= "\nDiff:\n---------------\n\n".$fixResult['diff'];
}
$failure->appendChild($dom->createCDATASection(trim($failureContent)));
return $testcase;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/ReporterFactory.php | src/Console/Report/FixReport/ReporterFactory.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\Report\FixReport;
use Symfony\Component\Finder\Finder as SymfonyFinder;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ReporterFactory
{
/** @var array<string, ReporterInterface> */
private array $reporters = [];
public function registerBuiltInReporters(): self
{
/** @var null|list<class-string<ReporterInterface>> $builtInReporters */
static $builtInReporters;
if (null === $builtInReporters) {
$builtInReporters = [];
foreach (SymfonyFinder::create()->files()->name('*Reporter.php')->in(__DIR__) as $file) {
$relativeNamespace = $file->getRelativePath();
/** @var class-string<ReporterInterface> $class */
$class = \sprintf(
'%s\%s%s',
__NAMESPACE__,
'' !== $relativeNamespace ? $relativeNamespace.'\\' : '',
$file->getBasename('.php'),
);
$builtInReporters[] = $class;
}
}
foreach ($builtInReporters as $reporterClass) {
$this->registerReporter(new $reporterClass());
}
return $this;
}
/**
* @return $this
*/
public function registerReporter(ReporterInterface $reporter): self
{
$format = $reporter->getFormat();
if (isset($this->reporters[$format])) {
throw new \UnexpectedValueException(\sprintf('Reporter for format "%s" is already registered.', $format));
}
$this->reporters[$format] = $reporter;
return $this;
}
/**
* @return list<string>
*/
public function getFormats(): array
{
$formats = array_keys($this->reporters);
sort($formats);
return $formats;
}
public function getReporter(string $format): ReporterInterface
{
if (!isset($this->reporters[$format])) {
throw new \UnexpectedValueException(\sprintf('Reporter for format "%s" is not registered.', $format));
}
return $this->reporters[$format];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/JsonReporter.php | src/Console/Report/FixReport/JsonReporter.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\Report\FixReport;
use PhpCsFixer\Console\Application;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class JsonReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'json';
}
public function generate(ReportSummary $reportSummary): string
{
$jsonFiles = [];
foreach ($reportSummary->getChanged() as $file => $fixResult) {
$jsonFile = ['name' => $file];
if ($reportSummary->shouldAddAppliedFixers()) {
$jsonFile['appliedFixers'] = $fixResult['appliedFixers'];
}
if ('' !== $fixResult['diff']) {
$jsonFile['diff'] = $fixResult['diff'];
}
$jsonFiles[] = $jsonFile;
}
$json = [
'about' => Application::getAbout(),
'files' => $jsonFiles,
'time' => [
'total' => round($reportSummary->getTime() / 1_000, 3),
],
'memory' => round($reportSummary->getMemory() / 1_024 / 1_024, 3),
];
$json = json_encode($json, \JSON_THROW_ON_ERROR);
return $reportSummary->isDecoratedOutput() ? OutputFormatter::escape($json) : $json;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/ReporterInterface.php | src/Console/Report/FixReport/ReporterInterface.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\Report\FixReport;
/**
* @author Boris Gorbylev <ekho@ekho.name>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface ReporterInterface
{
public function getFormat(): string;
/**
* Process changed files array. Returns generated report.
*/
public function generate(ReportSummary $reportSummary): string;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/ReportSummary.php | src/Console/Report/FixReport/ReportSummary.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\Report\FixReport;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class ReportSummary
{
/**
* @var array<string, array{appliedFixers: list<string>, diff: string}>
*/
private array $changed;
private int $filesCount;
private int $time;
private int $memory;
private bool $addAppliedFixers;
private bool $isDryRun;
private bool $isDecoratedOutput;
/**
* @param array<string, array{appliedFixers: list<string>, diff: string}> $changed
* @param int $time duration in milliseconds
* @param int $memory memory usage in bytes
*/
public function __construct(
array $changed,
int $filesCount,
int $time,
int $memory,
bool $addAppliedFixers,
bool $isDryRun,
bool $isDecoratedOutput
) {
$this->changed = $changed;
$this->filesCount = $filesCount;
$this->time = $time;
$this->memory = $memory;
$this->addAppliedFixers = $addAppliedFixers;
$this->isDryRun = $isDryRun;
$this->isDecoratedOutput = $isDecoratedOutput;
}
public function isDecoratedOutput(): bool
{
return $this->isDecoratedOutput;
}
public function isDryRun(): bool
{
return $this->isDryRun;
}
/**
* @return array<string, array{appliedFixers: list<string>, diff: string}>
*/
public function getChanged(): array
{
return $this->changed;
}
public function getMemory(): int
{
return $this->memory;
}
public function getTime(): int
{
return $this->time;
}
public function getFilesCount(): int
{
return $this->filesCount;
}
public function shouldAddAppliedFixers(): bool
{
return $this->addAppliedFixers;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Report/FixReport/CheckstyleReporter.php | src/Console/Report/FixReport/CheckstyleReporter.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\Report\FixReport;
use PhpCsFixer\Console\Application;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* @author Kévin Gomez <contact@kevingomez.fr>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class CheckstyleReporter implements ReporterInterface
{
public function getFormat(): string
{
return 'checkstyle';
}
public function generate(ReportSummary $reportSummary): string
{
if (!\extension_loaded('dom')) {
throw new \RuntimeException('Cannot generate report! `ext-dom` is not available!');
}
$dom = new \DOMDocument('1.0', 'UTF-8');
$checkstyles = $dom->appendChild($dom->createElement('checkstyle'));
\assert($checkstyles instanceof \DOMElement);
$checkstyles->setAttribute('version', Application::getAbout());
foreach ($reportSummary->getChanged() as $filePath => $fixResult) {
$file = $checkstyles->appendChild($dom->createElement('file'));
\assert($file instanceof \DOMElement);
$file->setAttribute('name', $filePath);
foreach ($fixResult['appliedFixers'] as $appliedFixer) {
$error = $this->createError($dom, $appliedFixer);
$file->appendChild($error);
}
}
$dom->formatOutput = true;
$result = $dom->saveXML();
if (false === $result) {
throw new \RuntimeException('Failed to generate XML output');
}
return $reportSummary->isDecoratedOutput() ? OutputFormatter::escape($result) : $result;
}
private function createError(\DOMDocument $dom, string $appliedFixer): \DOMElement
{
$error = $dom->createElement('error');
$error->setAttribute('severity', 'warning');
$error->setAttribute('source', 'PHP-CS-Fixer.'.$appliedFixer);
$error->setAttribute('message', 'Found violation(s) of type: '.$appliedFixer);
return $error;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/SelfUpdateCommand.php | src/Console/Command/SelfUpdateCommand.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\Console\Application;
use PhpCsFixer\Console\SelfUpdate\NewVersionCheckerInterface;
use PhpCsFixer\PharCheckerInterface;
use PhpCsFixer\Preg;
use PhpCsFixer\ToolInfoInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @author Igor Wiedler <igor@wiedler.ch>
* @author Stephane PY <py.stephane1@gmail.com>
* @author Grégoire Pineau <lyrixx@lyrixx.info>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'self-update', description: 'Update php-cs-fixer.phar to the latest stable version.')]
final class SelfUpdateCommand extends Command
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'self-update';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Update php-cs-fixer.phar to the latest stable version.';
private NewVersionCheckerInterface $versionChecker;
private ToolInfoInterface $toolInfo;
private PharCheckerInterface $pharChecker;
public function __construct(
NewVersionCheckerInterface $versionChecker,
ToolInfoInterface $toolInfo,
PharCheckerInterface $pharChecker
) {
parent::__construct();
$this->versionChecker = $versionChecker;
$this->toolInfo = $toolInfo;
$this->pharChecker = $pharChecker;
}
/**
* {@inheritdoc}
*
* Override here to only generate the help copy when used.
*/
public function getHelp(): string
{
return <<<'EOT'
The <info>%command.name%</info> command replace your php-cs-fixer.phar by the
latest version released on:
<comment>https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/releases</comment>
<info>$ php php-cs-fixer.phar %command.name%</info>
EOT;
}
protected function configure(): void
{
$this
->setAliases(['selfupdate'])
->setDefinition(
[
new InputOption('--force', '-f', InputOption::VALUE_NONE, 'Force update to next major version if available.'),
],
)
;
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
if ($output instanceof ConsoleOutputInterface) {
$stdErr = $output->getErrorOutput();
$stdErr->writeln(Application::getAboutWithRuntime(true));
}
if (!$this->toolInfo->isInstalledAsPhar()) {
$output->writeln('<error>Self-update is available only for PHAR version.</error>');
return 1;
}
$currentVersion = $this->getApplication()->getVersion();
Preg::match('/^v?(?<major>\d+)\./', $currentVersion, $matches);
$currentMajor = (int) $matches['major'];
try {
$latestVersion = $this->versionChecker->getLatestVersion();
$latestVersionOfCurrentMajor = $this->versionChecker->getLatestVersionOfMajor($currentMajor);
} catch (\Exception $exception) {
$output->writeln(\sprintf(
'<error>Unable to determine newest version: %s</error>',
$exception->getMessage(),
));
return 1;
}
if (1 !== $this->versionChecker->compareVersions($latestVersion, $currentVersion)) {
$output->writeln('<info>PHP CS Fixer is already up-to-date.</info>');
return 0;
}
$remoteTag = $latestVersion;
if (
0 !== $this->versionChecker->compareVersions($latestVersionOfCurrentMajor, $latestVersion)
&& true !== $input->getOption('force')
) {
$output->writeln(\sprintf('<info>A new major version of PHP CS Fixer is available</info> (<comment>%s</comment>)', $latestVersion));
$output->writeln(\sprintf('<info>Before upgrading please read</info> https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/%s/UPGRADE-v%s.md', $latestVersion, $currentMajor + 1));
$output->writeln('<info>If you are ready to upgrade run this command with</info> <comment>-f</comment>');
$output->writeln('<info>Checking for new minor/patch version...</info>');
if (1 !== $this->versionChecker->compareVersions($latestVersionOfCurrentMajor, $currentVersion)) {
$output->writeln('<info>No minor update for PHP CS Fixer.</info>');
return 0;
}
$remoteTag = $latestVersionOfCurrentMajor;
}
$localFilename = $_SERVER['argv'][0];
$realPath = realpath($localFilename);
if (false !== $realPath) {
$localFilename = $realPath;
}
if (!is_writable($localFilename)) {
$output->writeln(\sprintf('<error>No permission to update</error> "%s" <error>file.</error>', $localFilename));
return 1;
}
$tempFilename = \dirname($localFilename).'/'.basename($localFilename, '.phar').'-tmp.phar';
$remoteFilename = $this->toolInfo->getPharDownloadUri($remoteTag);
if (false === @copy($remoteFilename, $tempFilename)) {
$output->writeln(\sprintf('<error>Unable to download new version</error> %s <error>from the server.</error>', $remoteTag));
return 1;
}
chmod($tempFilename, 0777 & ~umask());
$pharInvalidityReason = $this->pharChecker->checkFileValidity($tempFilename);
if (null !== $pharInvalidityReason) {
unlink($tempFilename);
$output->writeln(\sprintf('<error>The download of</error> %s <error>is corrupt (%s).</error>', $remoteTag, $pharInvalidityReason));
$output->writeln('<error>Please re-run the "self-update" command to try again.</error>');
return 1;
}
rename($tempFilename, $localFilename);
$output->writeln(\sprintf('<info>PHP CS Fixer updated</info> (<comment>%s</comment> -> <comment>%s</comment>)', $currentVersion, $remoteTag));
return 0;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/ListSetsCommand.php | src/Console/Command/ListSetsCommand.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\ConfigurationException\InvalidConfigurationException;
use PhpCsFixer\Console\Report\ListSetsReport\ReporterFactory;
use PhpCsFixer\Console\Report\ListSetsReport\ReporterInterface;
use PhpCsFixer\Console\Report\ListSetsReport\ReportSummary;
use PhpCsFixer\Console\Report\ListSetsReport\TextReporter;
use PhpCsFixer\RuleSet\RuleSets;
use PhpCsFixer\Utils;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'list-sets', description: 'List all available RuleSets.')]
final class ListSetsCommand extends Command
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'list-sets';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'List all available RuleSets.';
protected function configure(): void
{
$reporterFactory = new ReporterFactory();
$reporterFactory->registerBuiltInReporters();
$formats = $reporterFactory->getFormats();
\assert([] !== $formats);
$this->setDefinition(
[
new InputOption('format', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('To output results in other formats (%s).', $formats), (new TextReporter())->getFormat(), $formats),
],
);
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$reporter = $this->resolveReporterWithFactory(
$input->getOption('format'),
new ReporterFactory(),
);
$reportSummary = new ReportSummary(
array_values(RuleSets::getSetDefinitions()),
);
$report = $reporter->generate($reportSummary);
$output->isDecorated()
? $output->write(OutputFormatter::escape($report))
: $output->write($report, false, OutputInterface::OUTPUT_RAW);
return 0;
}
private function resolveReporterWithFactory(string $format, ReporterFactory $factory): ReporterInterface
{
try {
$factory->registerBuiltInReporters();
$reporter = $factory->getReporter($format);
} catch (\UnexpectedValueException $e) {
$formats = $factory->getFormats();
sort($formats);
throw new InvalidConfigurationException(\sprintf('The format "%s" is not defined, supported are %s.', $format, Utils::naturalLanguageJoin($formats)));
}
return $reporter;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/HelpCommand.php | src/Console/Command/HelpCommand.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\FixerConfiguration\AllowedValueSubset;
use PhpCsFixer\FixerConfiguration\FixerOptionInterface;
use PhpCsFixer\Utils;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\HelpCommand as BaseHelpCommand;
use Symfony\Component\Console\Formatter\OutputFormatterStyle;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
/**
* @author Fabien Potencier <fabien@symfony.com>
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'help')]
final class HelpCommand extends BaseHelpCommand
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'help';
/**
* Formats the description of an option to include its allowed values.
*
* @param string $description description with a single `%s` placeholder for the allowed values
* @param non-empty-list<string> $allowedValues
*/
public static function getDescriptionWithAllowedValues(string $description, array $allowedValues): string
{
$allowedValues = Utils::naturalLanguageJoinWithBackticks($allowedValues, 'or');
return \sprintf($description, 'can be '.$allowedValues);
}
/**
* Returns the allowed values of the given option that can be converted to a string.
*
* @return null|non-empty-list<AllowedValueSubset|mixed>
*/
public static function getDisplayableAllowedValues(FixerOptionInterface $option): ?array
{
$allowed = $option->getAllowedValues();
if (null !== $allowed) {
$allowed = array_filter($allowed, static fn ($value): bool => !$value instanceof \Closure);
usort($allowed, static function ($valueA, $valueB): int {
if ($valueA instanceof AllowedValueSubset) {
return -1;
}
if ($valueB instanceof AllowedValueSubset) {
return 1;
}
return strcasecmp(
Utils::toString($valueA),
Utils::toString($valueB),
);
});
if (0 === \count($allowed)) {
$allowed = null;
}
}
return $allowed;
}
protected function initialize(InputInterface $input, OutputInterface $output): void
{
$output->getFormatter()->setStyle('url', new OutputFormatterStyle('blue'));
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/DescribeCommand.php | src/Console/Command/DescribeCommand.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\Console\Application;
use PhpCsFixer\Console\ConfigurationResolver;
use PhpCsFixer\Differ\DiffConsoleFormatter;
use PhpCsFixer\Differ\FullDiffer;
use PhpCsFixer\Documentation\DocumentationTag;
use PhpCsFixer\Documentation\DocumentationTagGenerator;
use PhpCsFixer\Documentation\DocumentationTagType;
use PhpCsFixer\Documentation\FixerDocumentGenerator;
use PhpCsFixer\Fixer\ConfigurableFixerInterface;
use PhpCsFixer\Fixer\FixerInterface;
use PhpCsFixer\FixerConfiguration\AliasedFixerOption;
use PhpCsFixer\FixerConfiguration\AllowedValueSubset;
use PhpCsFixer\FixerConfiguration\DeprecatedFixerOption;
use PhpCsFixer\FixerDefinition\CodeSampleInterface;
use PhpCsFixer\FixerDefinition\FileSpecificCodeSampleInterface;
use PhpCsFixer\FixerDefinition\VersionSpecificCodeSampleInterface;
use PhpCsFixer\FixerFactory;
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\ToolInfo;
use PhpCsFixer\Utils;
use PhpCsFixer\WordMatcher;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Exception\RuntimeException;
use Symfony\Component\Console\Formatter\OutputFormatter;
use Symfony\Component\Console\Helper\TreeHelper;
use Symfony\Component\Console\Helper\TreeNode;
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;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'describe', description: 'Describe rule / ruleset.')]
final class DescribeCommand extends Command
{
private const SET_ALIAS_TO_DESCRIBE_CONFIG = '@';
private const SET_ALIAS_TO_DESCRIBE_RULES_WITHOUT_SET = '@-';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'describe';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Describe rule / ruleset.';
/**
* @var ?list<string>
*/
private ?array $setNames = null;
private FixerFactory $fixerFactory;
/**
* @var null|array<string, FixerInterface>
*/
private ?array $fixers = null;
public function __construct(?FixerFactory $fixerFactory = null)
{
parent::__construct();
if (null === $fixerFactory) {
$fixerFactory = new FixerFactory();
$fixerFactory->registerBuiltInFixers();
}
$this->fixerFactory = $fixerFactory;
}
protected function configure(): void
{
$this->setDefinition(
[
new InputArgument('name', InputArgument::OPTIONAL, 'Name of rule / set.', null, fn () => array_merge($this->getSetNames(), array_keys($this->getFixers()))),
new InputOption('config', '', InputOption::VALUE_REQUIRED, 'The path to a .php-cs-fixer.php file.'),
new InputOption('expand', '', InputOption::VALUE_NONE, 'Shall nested sets be expanded into nested rules.'),
new InputOption('format', '', InputOption::VALUE_REQUIRED, 'To output results in other formats (txt, tree).', 'txt', ['txt', 'tree']),
],
);
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
if ($output instanceof ConsoleOutputInterface) {
$stdErr = $output->getErrorOutput();
$stdErr->writeln(Application::getAboutWithRuntime(true));
}
$resolver = new ConfigurationResolver(
new Config(),
['config' => $input->getOption('config')],
getcwd(), // @phpstan-ignore argument.type
new ToolInfo(),
);
$this->fixerFactory->registerCustomFixers($resolver->getConfig()->getCustomFixers());
/** @var ?string $name */
$name = $input->getArgument('name');
$expand = $input->getOption('expand');
$format = $input->getOption('format');
if (null === $name) {
if (false === $input->isInteractive()) {
throw new RuntimeException('Not enough arguments (missing: "name") when not running interactively.');
}
$io = new SymfonyStyle($input, $output);
$shallDescribeConfigInUse = 'yes' === $io->choice(
'Do you want to describe used configuration? (alias:`@`',
['yes', 'no'],
'yes',
);
if ($shallDescribeConfigInUse) {
$name = self::SET_ALIAS_TO_DESCRIBE_CONFIG;
} else {
$name = $io->choice(
'Please select rule / set to describe',
array_merge($this->getSetNames(), array_keys($this->getFixers())),
);
}
}
if ('tree' === $format) {
if (!str_starts_with($name, '@')) {
throw new \InvalidArgumentException(
'The "--format=tree" option is available only when describing a set (name starting with "@").',
);
}
if (!class_exists(TreeHelper::class)) {
throw new \RuntimeException('The "--format=tree" option requires symfony/console 7.3+.');
}
}
if (!str_starts_with($name, '@')) {
if (true === $expand) {
throw new \InvalidArgumentException(
'The "--expand" option is available only when describing a set (name starting with "@").',
);
}
}
try {
if (str_starts_with($name, '@')) {
$this->describeSet($input, $output, $name, $resolver);
return 0;
}
$this->describeRule($output, $name);
} catch (DescribeNameNotFoundException $e) {
$matcher = new WordMatcher(
'set' === $e->getType() ? $this->getSetNames() : array_keys($this->getFixers()),
);
$alternative = $matcher->match($name);
$this->describeList($output, $e->getType());
throw new \InvalidArgumentException(\sprintf(
'%s "%s" not found.%s',
ucfirst($e->getType()),
$name,
null === $alternative ? '' : ' Did you mean "'.$alternative.'"?',
));
}
return 0;
}
private function describeRule(OutputInterface $output, string $name): void
{
$fixers = $this->getFixers();
if (!isset($fixers[$name])) {
throw new DescribeNameNotFoundException($name, 'rule');
}
$fixer = $fixers[$name];
$definition = $fixer->getDefinition();
$output->writeln(\sprintf('<fg=blue>Description of the <info>`%s`</info> rule.</>', $name));
$output->writeln('');
if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERBOSE) {
$output->writeln(\sprintf('Fixer class: <comment>%s</comment>.', \get_class($fixer)));
$output->writeln('');
}
$output->writeln($definition->getSummary());
$description = $definition->getDescription();
if (null !== $description) {
$output->writeln($description);
}
$output->writeln('');
$tags = DocumentationTagGenerator::analyseRule($fixer);
foreach ($tags as $tag) {
if (DocumentationTagType::DEPRECATED === $tag->type) {
Future::triggerDeprecation(new \RuntimeException(str_replace(
'`',
'"',
\sprintf(
'%s%s',
str_replace('This rule', \sprintf('Rule "%s"', $name), $tag->title),
null !== $tag->description ? '. '.$tag->description : '',
),
)));
} elseif (DocumentationTagType::CONFIGURABLE === $tag->type) {
continue; // skip, handled later
}
$output->writeln(\sprintf('<error>%s</error>', $tag->title));
$tagDescription = $tag->description;
if (null !== $tagDescription) {
$tagDescription = Preg::replace('/(`[^`]+`)/', '<info>$1</info>', $tagDescription);
$output->writeln($tagDescription);
}
$output->writeln('');
}
if ($fixer instanceof ConfigurableFixerInterface) {
$configurationDefinition = $fixer->getConfigurationDefinition();
$options = $configurationDefinition->getOptions();
$output->writeln(\sprintf('Fixer is configurable using following option%s:', 1 === \count($options) ? '' : 's'));
foreach ($options as $option) {
$line = '* <info>'.OutputFormatter::escape($option->getName()).'</info>';
$allowed = HelpCommand::getDisplayableAllowedValues($option);
if (null === $allowed) {
$allowedTypes = $option->getAllowedTypes();
if (null !== $allowedTypes) {
$allowed = array_map(
static fn (string $type): string => '<comment>'.$type.'</comment>',
$allowedTypes,
);
}
} else {
$allowed = array_map(static fn ($value): string => $value instanceof AllowedValueSubset
? 'a subset of <comment>'.Utils::toString($value->getAllowedValues()).'</comment>'
: '<comment>'.Utils::toString($value).'</comment>', $allowed);
}
if (null !== $allowed) {
$line .= ' ('.Utils::naturalLanguageJoin($allowed, '').')';
}
$description = Preg::replace('/(`.+?`)/', '<info>$1</info>', OutputFormatter::escape($option->getDescription()));
$line .= ': '.lcfirst(Preg::replace('/\.$/', '', $description)).'; ';
if ($option->hasDefault()) {
$line .= \sprintf(
'defaults to <comment>%s</comment>',
Utils::toString($option->getDefault()),
);
} else {
$line .= '<comment>required</comment>';
}
if ($option instanceof DeprecatedFixerOption) {
$line .= '. <error>DEPRECATED</error>: '.Preg::replace(
'/(`.+?`)/',
'<info>$1</info>',
OutputFormatter::escape(lcfirst($option->getDeprecationMessage())),
);
}
if ($option instanceof AliasedFixerOption) {
$line .= '; <error>DEPRECATED</error> alias: <comment>'.$option->getAlias().'</comment>';
}
$output->writeln($line);
}
$output->writeln('');
}
$codeSamples = array_filter($definition->getCodeSamples(), static function (CodeSampleInterface $codeSample): bool {
if ($codeSample instanceof VersionSpecificCodeSampleInterface) {
return $codeSample->isSuitableFor(\PHP_VERSION_ID);
}
return true;
});
if (0 === \count($definition->getCodeSamples())) {
$output->writeln([
'Fixing examples are not available for this rule.',
'',
]);
} elseif (0 === \count($codeSamples)) {
$output->writeln([
'Fixing examples <error>cannot be</error> demonstrated on the current PHP version.',
'',
]);
} else {
$output->writeln('Fixing examples:');
$differ = new FullDiffer();
$diffFormatter = new DiffConsoleFormatter(
$output->isDecorated(),
\sprintf(
'<comment> ---------- begin diff ----------</comment>%s%%s%s<comment> ----------- end diff -----------</comment>',
\PHP_EOL,
\PHP_EOL,
),
);
foreach ($codeSamples as $index => $codeSample) {
$old = $codeSample->getCode();
$tokens = Tokens::fromCode($old);
$configuration = $codeSample->getConfiguration();
if ($fixer instanceof ConfigurableFixerInterface) {
$fixer->configure($configuration ?? []);
}
$file = $codeSample instanceof FileSpecificCodeSampleInterface
? $codeSample->getSplFileInfo()
: new StdinFileInfo();
$fixer->fix($file, $tokens);
$diff = $differ->diff($old, $tokens->generateCode());
if ($fixer instanceof ConfigurableFixerInterface) {
if (null === $configuration) {
$output->writeln(\sprintf(' * Example #%d. Fixing with the <comment>default</comment> configuration.', $index + 1));
} else {
$output->writeln(\sprintf(' * Example #%d. Fixing with configuration: <comment>%s</comment>.', $index + 1, Utils::toString($codeSample->getConfiguration())));
}
} else {
$output->writeln(\sprintf(' * Example #%d.', $index + 1));
}
$output->writeln([$diffFormatter->format($diff, ' %s'), '']);
}
}
$ruleSetConfigs = FixerDocumentGenerator::getSetsOfRule($name);
if ([] !== $ruleSetConfigs) {
ksort($ruleSetConfigs);
$plural = 1 !== \count($ruleSetConfigs) ? 's' : '';
$output->writeln("The fixer is part of the following rule set{$plural}:");
$ruleSetDefinitions = RuleSets::getSetDefinitions();
foreach ($ruleSetConfigs as $set => $config) {
\assert(isset($ruleSetDefinitions[$set]));
$ruleSetDefinition = $ruleSetDefinitions[$set];
if ($ruleSetDefinition instanceof AutomaticRuleSetDefinitionInterface) {
continue;
}
$deprecatedDesc = ($ruleSetDefinition instanceof DeprecatedRuleSetDefinitionInterface) ? ' *(deprecated)*' : '';
if (null !== $config) {
$output->writeln(\sprintf('* <info>%s</info> with config: <comment>%s</comment>', $set.$deprecatedDesc, Utils::toString($config)));
} else {
$output->writeln(\sprintf('* <info>%s</info> with <comment>default</comment> config', $set.$deprecatedDesc));
}
}
$output->writeln('');
}
}
private function describeSet(InputInterface $input, OutputInterface $output, string $name, ConfigurationResolver $resolver): void
{
if (
!\in_array($name, [self::SET_ALIAS_TO_DESCRIBE_CONFIG, self::SET_ALIAS_TO_DESCRIBE_RULES_WITHOUT_SET], true)
&& !\in_array($name, $this->getSetNames(), true)) {
throw new DescribeNameNotFoundException($name, 'set');
}
if (self::SET_ALIAS_TO_DESCRIBE_CONFIG === $name) {
$aliasedRuleSetDefinition = $this->createRuleSetDefinition(
null,
[],
[
'getDescription' => null === $resolver->getConfigFile() ? 'Default rules, no config file.' : 'Rules defined in used config.',
'getName' => \sprintf('@ - %s', $resolver->getConfig()->getName()),
'getRules' => $resolver->getConfig()->getRules(),
'isRisky' => $resolver->getRiskyAllowed(),
],
);
} elseif (self::SET_ALIAS_TO_DESCRIBE_RULES_WITHOUT_SET === $name) {
$rulesWithoutSet = array_filter(
$this->getFixers(),
static fn (string $name): bool => [] === FixerDocumentGenerator::getSetsOfRule($name),
\ARRAY_FILTER_USE_KEY,
);
$aliasedRuleSetDefinition = $this->createRuleSetDefinition(
null,
[],
[
'getDescription' => 'Rules that are not part of any set.',
'getName' => '@- - rules without set',
'getRules' => array_combine(
array_map(
static fn (FixerInterface $fixer): string => $fixer->getName(),
$rulesWithoutSet,
),
array_fill(0, \count($rulesWithoutSet), true),
),
'isRisky' => array_any(
$rulesWithoutSet,
static fn (FixerInterface $fixer): bool => $fixer->isRisky(),
),
],
);
}
$ruleSetDefinitions = RuleSets::getSetDefinitions();
$ruleSetDefinition = $aliasedRuleSetDefinition ?? $ruleSetDefinitions[$name];
$fixers = $this->getFixers();
if (true === $input->getOption('expand')) {
$ruleSetDefinition = $this->createRuleSetDefinition($ruleSetDefinition, ['expand'], []);
} else {
$output->writeln("You may the '--expand' option to see nested sets expanded into nested rules.");
}
$output->writeln(\sprintf('<fg=blue>Description of the <info>`%s`</info> set.</>', $ruleSetDefinition->getName()));
$output->writeln('');
$output->writeln($this->replaceRstLinks($ruleSetDefinition->getDescription()));
$output->writeln('');
$tags = DocumentationTagGenerator::analyseRuleSet($ruleSetDefinition);
foreach ($tags as $tag) {
if (DocumentationTagType::DEPRECATED === $tag->type) {
Future::triggerDeprecation(new \RuntimeException(str_replace(
'`',
'"',
\sprintf(
'%s%s',
str_replace('This rule set', \sprintf('Rule set "%s"', $name), $tag->title),
null !== $tag->description ? '. '.$tag->description : '',
),
)));
}
$output->writeln(\sprintf('<error>%s</error>', $tag->title));
$tagDescription = $tag->description;
if (null !== $tagDescription) {
$tagDescription = Preg::replace('/(`[^`]+`)/', '<info>$1</info>', $tagDescription);
$output->writeln($tagDescription);
}
$output->writeln('');
}
if ('tree' === $input->getOption('format')) {
$this->describeSetContentAsTree($output, $ruleSetDefinition, $ruleSetDefinitions, $fixers);
} else {
$this->describeSetContentAsTxt($output, $ruleSetDefinition, $ruleSetDefinitions, $fixers);
}
}
/**
* @param array<string, RuleSetDefinitionInterface> $ruleSetDefinitions
* @param array<string, FixerInterface> $fixers
*/
private function createTreeNode(RuleSetDefinitionInterface $ruleSetDefinition, array $ruleSetDefinitions, array $fixers): TreeNode
{
$tags = DocumentationTagGenerator::analyseRuleSet($ruleSetDefinition);
$extra = [] !== $tags
? ' '.implode(' ', array_map(
static fn (DocumentationTag $tag): string => "<error>{$tag->type}</error>",
$tags,
))
: '';
$node = new TreeNode($ruleSetDefinition->getName().$extra);
$rules = $ruleSetDefinition->getRules();
$rulesKeys = array_keys($rules);
natcasesort($rulesKeys);
foreach ($rulesKeys as $rule) {
\assert(isset($rules[$rule]));
$config = $rules[$rule];
if (str_starts_with($rule, '@')) {
$child = $this->createTreeNode($ruleSetDefinitions[$rule], $ruleSetDefinitions, $fixers);
} else {
$fixer = $fixers[$rule];
$tags = DocumentationTagGenerator::analyseRule($fixer);
$extra = [] !== $tags
? ' '.implode(' ', array_map(
static fn (DocumentationTag $tag): string => "<error>{$tag->type}</error>",
$tags,
))
: '';
if (false === $config) {
$extra = \sprintf(' | <error>Configuration: %s</>', Utils::toString($config));
} elseif (true !== $config) {
$extra = \sprintf(' | <comment>Configuration: %s</>', Utils::toString($config));
}
$child = new TreeNode($rule.$extra);
}
$node->addChild($child);
}
return $node;
}
/**
* @param array<string, RuleSetDefinitionInterface> $ruleSetDefinitions
* @param array<string, FixerInterface> $fixers
*/
private function describeSetContentAsTree(OutputInterface $output, RuleSetDefinitionInterface $ruleSetDefinition, array $ruleSetDefinitions, array $fixers): void
{
$io = new SymfonyStyle(
new ArrayInput([]),
$output,
);
$root = $this->createTreeNode($ruleSetDefinition, $ruleSetDefinitions, $fixers);
$tree = TreeHelper::createTree($io, $root);
$tree->render();
}
/**
* @param array<string, RuleSetDefinitionInterface> $ruleSetDefinitions
* @param array<string, FixerInterface> $fixers
*/
private function describeSetContentAsTxt(OutputInterface $output, RuleSetDefinitionInterface $ruleSetDefinition, array $ruleSetDefinitions, array $fixers): void
{
$help = '';
foreach ($ruleSetDefinition->getRules() as $rule => $config) {
if (str_starts_with($rule, '@')) {
\assert(isset($ruleSetDefinitions[$rule]));
$set = $ruleSetDefinitions[$rule];
$tags = DocumentationTagGenerator::analyseRuleSet($set);
$help .= \sprintf(
" * <info>%s</info>%s%s\n | %s\n\n",
$rule,
[] !== $tags ? ' ' : '',
implode(' ', array_map(
static fn (DocumentationTag $tag): string => "<error>{$tag->type}</error>",
$tags,
)),
$this->replaceRstLinks($set->getDescription()),
);
continue;
}
\assert(isset($fixers[$rule]));
$fixer = $fixers[$rule];
$tags = DocumentationTagGenerator::analyseRule($fixer);
$definition = $fixer->getDefinition();
$help .= \sprintf(
" * <info>%s</info>%s%s\n | %s\n%s\n",
$rule,
[] !== $tags ? ' ' : '',
implode(' ', array_map(
static fn (DocumentationTag $tag): string => "<error>{$tag->type}</error>",
$tags,
)),
$definition->getSummary(),
true !== $config ? \sprintf(" <comment>| Configuration: %s</comment>\n", Utils::toString($config)) : '',
);
}
$output->write($help);
}
/**
* @return array<string, FixerInterface>
*/
private function getFixers(): array
{
if (null !== $this->fixers) {
return $this->fixers;
}
$fixers = [];
foreach ($this->fixerFactory->getFixers() as $fixer) {
$fixers[$fixer->getName()] = $fixer;
}
$this->fixers = $fixers;
ksort($this->fixers);
return $this->fixers;
}
/**
* @return list<string>
*/
private function getSetNames(): array
{
if (null !== $this->setNames) {
return $this->setNames;
}
$this->setNames = RuleSets::getSetDefinitionNames();
return $this->setNames;
}
/**
* @param string $type 'rule'|'set'
*/
private function describeList(OutputInterface $output, string $type): void
{
if ($output->getVerbosity() < OutputInterface::VERBOSITY_VERBOSE) {
return;
}
if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE || 'set' === $type) {
$output->writeln('<comment>Defined sets:</comment>');
$items = $this->getSetNames();
foreach ($items as $item) {
$output->writeln(\sprintf('* <info>%s</info>', $item));
}
}
if ($output->getVerbosity() >= OutputInterface::VERBOSITY_VERY_VERBOSE || 'rule' === $type) {
$output->writeln('<comment>Defined rules:</comment>');
$items = array_keys($this->getFixers());
foreach ($items as $item) {
$output->writeln(\sprintf('* <info>%s</info>', $item));
}
}
}
private function replaceRstLinks(string $content): string
{
return Preg::replaceCallback(
'/(`[^<]+<[^>]+>`_)/',
static fn (array $matches) => Preg::replaceCallback(
'/`(.*)<(.*)>`_/',
static fn (array $matches): string => $matches[1].'('.$matches[2].')',
$matches[1],
),
$content,
);
}
/**
* @param list<'expand'> $adjustments
* @param array{getDescription?: string, getName?: string, getRules?: array<string, array<string, mixed>|bool>, isRisky?: bool} $overrides
*/
private function createRuleSetDefinition(?RuleSetDefinitionInterface $ruleSetDefinition, array $adjustments, array $overrides): RuleSetDefinitionInterface
{
return new class($ruleSetDefinition, $adjustments, $overrides) implements RuleSetDefinitionInterface {
private ?RuleSetDefinitionInterface $original;
/** @var list<'expand'> */
private array $adjustments;
/** @var array{getDescription?: string, getName?: string, getRules?: array<string, array<string, mixed>|bool>, isRisky?: bool} */
private array $overrides;
/**
* @param list<'expand'> $adjustments
* @param array{getDescription?: string, getName?: string, getRules?: array<string, array<string, mixed>|bool>, isRisky?: bool} $overrides
*/
public function __construct(
?RuleSetDefinitionInterface $original,
array $adjustments,
array $overrides
) {
$this->original = $original;
$this->adjustments = $adjustments;
$this->overrides = $overrides;
}
public function getDescription(): string
{
return $this->overrides[__FUNCTION__]
?? (null !== $this->original ? $this->original->{__FUNCTION__}() : 'unknown description'); // @phpstan-ignore method.dynamicName
}
public function getName(): string
{
$value = $this->overrides[__FUNCTION__]
?? (null !== $this->original ? $this->original->{__FUNCTION__}() : 'unknown name'); // @phpstan-ignore method.dynamicName
if (\in_array('expand', $this->adjustments, true)) {
$value .= ' (expanded)';
}
return $value;
}
public function getRules(): array
{
$value = $this->overrides[__FUNCTION__]
?? (null !== $this->original ? $this->original->{__FUNCTION__}() : null); // @phpstan-ignore method.dynamicName
if (null === $value) {
throw new \LogicException('Cannot get rules from unknown original rule set and missing overrides.');
}
if (\in_array('expand', $this->adjustments, true)) {
$value = (new RuleSet($value))->getRules();
}
return $value;
}
public function isRisky(): bool
{
$value = $this->overrides[__FUNCTION__]
?? (null !== $this->original ? $this->original->{__FUNCTION__}() : null); // @phpstan-ignore method.dynamicName
if (null === $value) {
throw new \LogicException('Cannot get isRisky from unknown original rule set and missing overrides.');
}
return $value;
}
};
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/FixCommandExitStatusCalculator.php | src/Console/Command/FixCommandExitStatusCalculator.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;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FixCommandExitStatusCalculator
{
// Exit status 1 is reserved for environment constraints not matched.
public const EXIT_STATUS_FLAG_HAS_INVALID_FILES = 4;
public const EXIT_STATUS_FLAG_HAS_CHANGED_FILES = 8;
public const EXIT_STATUS_FLAG_HAS_INVALID_CONFIG = 16;
public const EXIT_STATUS_FLAG_HAS_INVALID_FIXER_CONFIG = 32;
public const EXIT_STATUS_FLAG_EXCEPTION_IN_APP = 64;
public function calculate(
bool $isDryRun,
bool $hasChangedFiles,
bool $hasInvalidErrors,
bool $hasExceptionErrors,
bool $hasLintErrorsAfterFixing
): int {
$exitStatus = 0;
if ($isDryRun) {
if ($hasChangedFiles) {
$exitStatus |= self::EXIT_STATUS_FLAG_HAS_CHANGED_FILES;
}
if ($hasInvalidErrors) {
$exitStatus |= self::EXIT_STATUS_FLAG_HAS_INVALID_FILES;
}
}
if ($hasExceptionErrors || $hasLintErrorsAfterFixing) {
$exitStatus |= self::EXIT_STATUS_FLAG_EXCEPTION_IN_APP;
}
return $exitStatus;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/WorkerCommand.php | src/Console/Command/WorkerCommand.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 Clue\React\NDJson\Decoder;
use Clue\React\NDJson\Encoder;
use PhpCsFixer\Cache\NullCacheManager;
use PhpCsFixer\Config;
use PhpCsFixer\Console\ConfigurationResolver;
use PhpCsFixer\Error\ErrorsManager;
use PhpCsFixer\Runner\Event\FileProcessed;
use PhpCsFixer\Runner\Parallel\ParallelAction;
use PhpCsFixer\Runner\Parallel\ParallelConfigFactory;
use PhpCsFixer\Runner\Parallel\ParallelisationException;
use PhpCsFixer\Runner\Runner;
use PhpCsFixer\ToolInfoInterface;
use React\EventLoop\StreamSelectLoop;
use React\Socket\ConnectionInterface;
use React\Socket\TcpConnector;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
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\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
/**
* @author Greg Korba <greg@codito.dev>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'worker', description: 'Internal command for running fixers in parallel', hidden: true)]
final class WorkerCommand extends Command
{
/** @var string Prefix used before JSON-encoded error printed in the worker's process */
public const ERROR_PREFIX = 'WORKER_ERROR::';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'worker';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Internal command for running fixers in parallel';
private ToolInfoInterface $toolInfo;
private ConfigurationResolver $configurationResolver;
private ErrorsManager $errorsManager;
private EventDispatcherInterface $eventDispatcher;
/** @var list<FileProcessed> */
private array $events;
public function __construct(ToolInfoInterface $toolInfo)
{
parent::__construct();
$this->setHidden(true);
$this->toolInfo = $toolInfo;
$this->errorsManager = new ErrorsManager();
$this->eventDispatcher = new EventDispatcher();
}
protected function configure(): void
{
$this->setDefinition(
[
new InputOption('port', null, InputOption::VALUE_REQUIRED, 'Specifies parallelisation server\'s port.'),
new InputOption('identifier', null, InputOption::VALUE_REQUIRED, 'Specifies parallelisation process\' identifier.'),
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.'),
new InputOption('using-cache', '', InputOption::VALUE_REQUIRED, HelpCommand::getDescriptionWithAllowedValues('Should cache be used (%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('stop-on-violation', '', InputOption::VALUE_NONE, 'Stop execution on first violation.'),
],
);
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$errorOutput = $output instanceof ConsoleOutputInterface ? $output->getErrorOutput() : $output;
$identifier = $input->getOption('identifier');
$port = $input->getOption('port');
if (null === $identifier || !is_numeric($port)) {
throw new ParallelisationException('Missing parallelisation options');
}
try {
$runner = $this->createRunner($input);
} catch (\Throwable $e) {
throw new ParallelisationException('Unable to create runner: '.$e->getMessage(), 0, $e);
}
$loop = new StreamSelectLoop();
$tcpConnector = new TcpConnector($loop);
$tcpConnector
->connect(\sprintf('127.0.0.1:%d', $port))
->then(
/** @codeCoverageIgnore */
function (ConnectionInterface $connection) use ($loop, $runner, $identifier): void {
$out = new Encoder($connection, \JSON_INVALID_UTF8_IGNORE);
$in = new Decoder($connection, true, 512, \JSON_INVALID_UTF8_IGNORE);
// [REACT] Initialise connection with the parallelisation operator
$out->write(['action' => ParallelAction::WORKER_HELLO, 'identifier' => $identifier]);
$handleError = static function (\Throwable $error) use ($out): void {
$out->write([
'action' => ParallelAction::WORKER_ERROR_REPORT,
'class' => \get_class($error),
'message' => $error->getMessage(),
'file' => $error->getFile(),
'line' => $error->getLine(),
'code' => $error->getCode(),
'trace' => $error->getTraceAsString(),
]);
};
$out->on('error', $handleError);
$in->on('error', $handleError);
// [REACT] Listen for messages from the parallelisation operator (analysis requests)
$in->on('data', function (array $json) use ($loop, $runner, $out): void {
$action = $json['action'] ?? null;
// Parallelisation operator does not have more to do, let's close the connection
if (ParallelAction::RUNNER_THANK_YOU === $action) {
$loop->stop();
return;
}
if (ParallelAction::RUNNER_REQUEST_ANALYSIS !== $action) {
// At this point we only expect analysis requests, if any other action happen, we need to fix the code.
throw new \LogicException(\sprintf('Unexpected action ParallelAction::%s.', $action));
}
/** @var iterable<int, string> $files */
$files = $json['files'];
foreach ($files as $path) {
// Reset events because we want to collect only those coming from analysed files chunk
$this->events = [];
$runner->setFileIterator(new \ArrayIterator([new \SplFileInfo($path)]));
$analysisResult = $runner->fix();
if (1 !== \count($this->events)) {
throw new ParallelisationException('Runner did not report a fixing event or reported too many.');
}
if (1 < \count($analysisResult)) {
throw new ParallelisationException('Runner returned more analysis results than expected.');
}
$out->write([
'action' => ParallelAction::WORKER_RESULT,
'file' => $path,
'fileHash' => $this->events[0]->getFileHash(),
'status' => $this->events[0]->getStatus(),
'fixInfo' => array_pop($analysisResult),
'errors' => $this->errorsManager->forPath($path),
]);
}
// Request another file chunk (if available, the parallelisation operator will request new "run" action)
$out->write(['action' => ParallelAction::WORKER_GET_FILE_CHUNK]);
});
},
static function (\Throwable $error) use ($errorOutput): void {
// @TODO Verify onRejected behaviour → https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/pull/7777#discussion_r1590399285
$errorOutput->writeln($error->getMessage());
},
)
;
$loop->run();
return Command::SUCCESS;
}
private function createRunner(InputInterface $input): Runner
{
$passedConfig = $input->getOption('config');
$passedRules = $input->getOption('rules');
if (null !== $passedConfig && ConfigurationResolver::IGNORE_CONFIG_FILE !== $passedConfig && null !== $passedRules) {
throw new \RuntimeException('Passing both `--config` and `--rules` options is not allowed');
}
// There's no one single source of truth when it comes to fixing single file, we need to collect statuses from events.
$this->eventDispatcher->addListener(FileProcessed::NAME, function (FileProcessed $event): void {
$this->events[] = $event;
});
$this->configurationResolver = new ConfigurationResolver(
new Config(),
[
'allow-risky' => $input->getOption('allow-risky'),
'config' => $passedConfig,
'dry-run' => $input->getOption('dry-run'),
'rules' => $passedRules,
'path' => [],
'path-mode' => ConfigurationResolver::PATH_MODE_OVERRIDE, // IMPORTANT! WorkerCommand is called with file that already passed filtering, so here we can rely on PATH_MODE_OVERRIDE.
'using-cache' => $input->getOption('using-cache'),
'cache-file' => $input->getOption('cache-file'),
'diff' => $input->getOption('diff'),
'stop-on-violation' => $input->getOption('stop-on-violation'),
],
getcwd(), // @phpstan-ignore argument.type
$this->toolInfo,
);
return new Runner(
null, // Paths are known when parallelisation server requests new chunk, not now
$this->configurationResolver->getFixers(),
$this->configurationResolver->getDiffer(),
$this->eventDispatcher,
$this->errorsManager,
$this->configurationResolver->getLinter(),
$this->configurationResolver->isDryRun(),
new NullCacheManager(), // IMPORTANT! We pass null cache, as cache is read&write in main process and we do not need to do it again.
$this->configurationResolver->getDirectory(),
$this->configurationResolver->shouldStopOnViolation(),
ParallelConfigFactory::sequential(), // IMPORTANT! Worker must run in sequential mode.
null,
$this->configurationResolver->getConfigFile(),
$this->configurationResolver->getRuleCustomisationPolicy(),
);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/CheckCommand.php | src/Console/Command/CheckCommand.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\Preg;
use PhpCsFixer\ToolInfoInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
/**
* @author Greg Korba <greg@codito.dev>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'check', description: 'Checks if configured files/directories comply with configured rules.')]
final class CheckCommand extends FixCommand
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'check'; // @phpstan-ignore property.parentPropertyFinalByPhpDoc
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Checks if configured files/directories comply with configured rules.'; // @phpstan-ignore property.parentPropertyFinalByPhpDoc
public function __construct(ToolInfoInterface $toolInfo)
{
parent::__construct($toolInfo);
}
public function getHelp(): string
{
return Preg::replace('@\v\V*<comment>--dry-run</comment>\V*\v@', '', parent::getHelp());
}
protected function configure(): void
{
parent::configure();
$this->setDefinition([
...array_values($this->getDefinition()->getArguments()),
...array_values(array_filter(
$this->getDefinition()->getOptions(),
static fn (InputOption $option): bool => 'dry-run' !== $option->getName(),
)),
]);
}
protected function isDryRun(InputInterface $input): bool
{
return true;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/FixCommand.php | 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\Parallel\ParallelConfigFactory;
use PhpCsFixer\Runner\Runner;
use PhpCsFixer\ToolInfoInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Formatter\OutputFormatter;
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) {
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',
));
/** @TODO v4 remove warnings related to parallel runner */
$availableMaxProcesses = ParallelConfigFactory::detect()->getMaxProcesses();
if ($isParallel || $availableMaxProcesses > 1) {
$usageDocs = 'https://cs.symfony.com/doc/usage.html';
$stdErr->writeln(\sprintf(
$stdErr->isDecorated() ? '<bg=yellow;fg=black;>%s</>' : '%s',
$isParallel
? 'Parallel runner is an experimental feature and may be unstable, use it at your own risk. Feedback highly appreciated!'
: \sprintf(
'You can enable parallel runner and speed up the analysis! Please see %s for more information.',
$stdErr->isDecorated()
? \sprintf('<href=%s;bg=yellow;fg=red;bold>usage docs</>', OutputFormatter::escape($usageDocs))
: $usageDocs,
),
));
}
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
$fixEvent->getMemory(),
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.)
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/DescribeNameNotFoundException.php | src/Console/Command/DescribeNameNotFoundException.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;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class DescribeNameNotFoundException extends \InvalidArgumentException
{
private string $name;
/**
* 'rule'|'set'.
*/
private string $type;
public function __construct(string $name, string $type)
{
$this->name = $name;
$this->type = $type;
parent::__construct();
}
public function getName(): string
{
return $this->name;
}
public function getType(): string
{
return $this->type;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/ListFilesCommand.php | src/Console/Command/ListFilesCommand.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\Console\ConfigurationResolver;
use PhpCsFixer\ToolInfoInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Filesystem\Path;
/**
* @author Markus Staab <markus.staab@redaxo.org>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'list-files', description: 'List all files being fixed by the given config.')]
final class ListFilesCommand extends Command
{
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'list-files';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'List all files being fixed by the given config.';
private ConfigInterface $defaultConfig;
private ToolInfoInterface $toolInfo;
public function __construct(ToolInfoInterface $toolInfo)
{
parent::__construct();
$this->defaultConfig = new Config();
$this->toolInfo = $toolInfo;
}
protected function configure(): void
{
$this->setDefinition(
[
new InputOption('config', '', InputOption::VALUE_REQUIRED, 'The path to a .php-cs-fixer.php file.'),
],
);
}
protected function execute(InputInterface $input, OutputInterface $output): int
{
$passedConfig = $input->getOption('config');
$cwd = getcwd();
\assert(false !== $cwd);
$resolver = new ConfigurationResolver(
$this->defaultConfig,
[
'config' => $passedConfig,
],
$cwd,
$this->toolInfo,
);
$finder = $resolver->getFinder();
foreach ($finder as $file) {
if ($file->isFile()) {
$relativePath = './'.Path::makeRelative($file->getRealPath(), $cwd);
// unify directory separators across operating system
$relativePath = str_replace('/', \DIRECTORY_SEPARATOR, $relativePath);
$output->writeln(escapeshellarg($relativePath));
}
}
return 0;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Console/Command/InitCommand.php | src/Console/Command/InitCommand.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\Console\Application;
use PhpCsFixer\RuleSet\RuleSetDefinitionInterface;
use PhpCsFixer\RuleSet\RuleSets;
use PhpCsFixer\RuleSet\Sets\AutoRiskySet;
use PhpCsFixer\RuleSet\Sets\AutoSet;
use PhpCsFixer\RuleSet\Sets\PhpCsFixerRiskySet;
use PhpCsFixer\RuleSet\Sets\PhpCsFixerSet;
use PhpCsFixer\RuleSet\Sets\SymfonyRiskySet;
use PhpCsFixer\RuleSet\Sets\SymfonySet;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use Symfony\Component\Filesystem\Exception\IOException;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
#[AsCommand(name: 'init', description: 'Create config file.')]
final class InitCommand extends Command
{
private const FIXER_FILENAME = '.php-cs-fixer.dist.php';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultName = 'init';
/** @TODO PHP 8.0 - remove the property */
protected static $defaultDescription = 'Create config file.';
protected function execute(InputInterface $input, OutputInterface $output): int
{
$stdErr = $output;
if ($output instanceof ConsoleOutputInterface) {
$stdErr = $output->getErrorOutput();
$stdErr->writeln(Application::getAboutWithRuntime(true));
}
$io = new SymfonyStyle($input, $stdErr);
$io->warning('This command is experimental');
if (file_exists(self::FIXER_FILENAME)) {
$io->error(\sprintf('Configuration file `%s` already exists.', self::FIXER_FILENAME));
return Command::FAILURE;
}
$io->note([
'While we start, we must tell you that we put our diligence to NOT change the meaning of your codebase.',
'Yet, some of the rules are explicitly _risky_ to apply. A rule is _risky_ if it could change code behaviour, e.g. transforming `==` into `===` or removal of trailing whitespaces within multiline strings.',
'Such rules are improving your codebase even further, yet you shall always review changes proposed by _risky_ rules carefully.',
]);
$isRiskyAllowed = 'yes' === $io->choice(
'Do you want to enable _risky_ rules?',
['yes', 'no'],
'no',
);
$setsByName = RuleSets::getBuiltInSetDefinitions();
$setAuto = new AutoSet();
$setAutoRisky = new AutoRiskySet();
$setAutoWithOptionalRiskySetNamesTextual = $isRiskyAllowed ? '`@auto`/`@auto:risky`' : '`@auto`';
$io->note("We recommend usage of {$setAutoWithOptionalRiskySetNamesTextual} rulesets. They take insights from your existing `composer.json` to configure project the best:");
$generateSetsBehindAutoSet = static function () use ($setAuto, $setAutoRisky, $isRiskyAllowed): array {
$sets = array_merge(
array_keys($setAuto->getRulesCandidates()),
$isRiskyAllowed ? array_keys($setAutoRisky->getRulesCandidates()) : [],
);
natcasesort($sets);
return $sets;
};
$setsBehindAutoSet = $generateSetsBehindAutoSet();
$io->listing(
array_map(
static fn (RuleSetDefinitionInterface $item): string => \sprintf(
'<fg=blue>`%s`</> - %s',
$item->getName(),
$item->getDescription(),
),
array_map(
static fn (string $name): RuleSetDefinitionInterface => $setsByName[$name], // @phpstan-ignore-line offsetAccess.notFound
$setsBehindAutoSet,
),
),
);
$rules = [];
$useAutoSet = 'yes' === $io->choice(
"Do you want to use <fg=blue>{$setAutoWithOptionalRiskySetNamesTextual}</> ruleset?",
['yes', 'no'],
'yes',
);
if ($useAutoSet) {
$rules[] = $setAuto->getName();
if ($isRiskyAllowed) {
$rules[] = $setAutoRisky->getName();
}
}
$generateExtraSets = static function () use ($isRiskyAllowed): array {
$setSymfony = new SymfonySet();
$setPhpCsFixer = new PhpCsFixerSet();
$extraSets = [
$setSymfony->getName(),
$setPhpCsFixer->getName(),
];
if ($isRiskyAllowed) {
$setSymfonyRisky = new SymfonyRiskySet();
$setPhpCsFixerRisky = new PhpCsFixerRiskySet();
$extraSets[] = $setSymfonyRisky->getName();
$extraSets[] = $setPhpCsFixerRisky->getName();
}
return $extraSets;
};
$extraSets = array_merge(
false === $useAutoSet ? $setsBehindAutoSet : [],
$generateExtraSets(),
);
natcasesort($extraSets);
$sets = $io->choice(
'Do you want to use any of other recommended ruleset? (multi-choice)',
array_combine(
$extraSets,
array_map(
static fn (string $item): string => $setsByName[$item]->getDescription(), // @phpstan-ignore-line offsetAccess.notFound
$extraSets,
),
) + ['none' => 'none'],
'none',
true,
);
// older Symfony version can return single string instead of array with single string, let's unify
if (!\is_array($sets)) {
$sets = [$sets];
}
$rules = array_merge(
$rules,
array_unique(array_filter($sets, static fn ($item) => 'none' !== $item)),
);
$readResult = @file_get_contents(__DIR__.'/../../../resources/.php-cs-fixer.dist.php.template');
if (false === $readResult) {
throw new IOException('Failed to read template file.');
}
$content = str_replace(
[
'/*{{ IS_RISKY_ALLOWED }}*/',
'/*{{ RULES }}*/',
],
[
$isRiskyAllowed ? 'true' : 'false',
"[\n".implode(
",\n",
array_map(
static fn ($item) => " '{$item}' => true",
$rules,
),
)."\n ]",
],
$readResult,
);
$writeResult = @file_put_contents(self::FIXER_FILENAME, $content);
if (false === $writeResult) {
throw new IOException(\sprintf('Failed to write file "%s".', self::FIXER_FILENAME));
}
$io->success(\sprintf('Configuration file created successfully as `%s`.', self::FIXER_FILENAME));
return Command::SUCCESS;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Config/NullRuleCustomisationPolicy.php | src/Config/NullRuleCustomisationPolicy.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\Config;
/**
* EXPERIMENTAL: This feature is experimental and does not fall under the backward compatibility promise.
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class NullRuleCustomisationPolicy implements RuleCustomisationPolicyInterface
{
/**
* @internal
*/
public const VERSION_FOR_CACHE = 'null-policy';
public function getPolicyVersionForCache(): string
{
return self::VERSION_FOR_CACHE;
}
public function getRuleCustomisers(): array
{
return [];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Config/RuleCustomisationPolicyInterface.php | src/Config/RuleCustomisationPolicyInterface.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\Config;
use PhpCsFixer\Fixer\FixerInterface;
/**
* EXPERIMENTAL: This feature is experimental and does not fall under the backward compatibility promise.
*
* @todo v3.999 replace \SplFileInfo with \Symfony\Component\Finder\SplFileInfo
*
* @phpstan-type _RuleCustomisationPolicyCallback \Closure(\SplFileInfo): (bool|FixerInterface)
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface RuleCustomisationPolicyInterface
{
/**
* Returns a string that changes when the policy implementation changes in a way that
* would affect the cache validity.
*
* @example you may use the following snippet if your policy does not depend on any code outside of the file
* `return hash_file(\PHP_VERSION_ID >= 8_01_00 ? 'xxh128' : 'md5', __FILE__);`
*
* @return non-empty-string
*/
public function getPolicyVersionForCache(): string;
/**
* Customise fixers for given files.
*
* Array keys are fixer names, values are closures that will be invoked before applying the fixer to a specific file.
* The closures receive the file as argument and must return:
* - true to apply the fixer as is to the file
* - false to skip applying the fixer to the file
* - a new fixer instance to apply a customised version of the fixer
*
* When PHP CS Fixer is about to start fixing files, it will check that the currently used fixers include at least
* all the fixers for which customisation rules are defined. If a customiser is defined for a fixer that is not currently applied,
* an exception will be thrown.
* This ensures that customisers are actually used for expected fixerswhich may be replaced by newer fixers in newer versions of PHP CS Fixer.
* Since fixer sets may change even in patch releases, this also means that your implementation of this interface may need to be updated accordingly, even in patch releases.
* So, we can't guarantee semver compatibility for Rule Customisation Policies.
*
* @example
* ```
* [
* 'array_syntax' => static function (\SplFileInfo $file) {
* if (str_ends_with($file->getPathname(), '/tests/foo.php')) {
* // Disable the fixer for the file tests/foo.php
* return false;
* }
* if (str_ends_with($file->getPathname(), '/bin/entrypoint')) {
* // For the file bin/entrypoint let's create a new fixer instance with a different configuration
* $fixer = new ArraySyntaxFixer();
* $fixer->configure(['syntax' => 'long']);
* return $fixer;
* }
* // Keep the default configuration for other files
* return true;
* },
* ]
* ```
*
* @return array<non-empty-string, _RuleCustomisationPolicyCallback>
*/
public function getRuleCustomisers(): array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Config/RuleCustomisationPolicyAwareConfigInterface.php | src/Config/RuleCustomisationPolicyAwareConfigInterface.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\Config;
use PhpCsFixer\ConfigInterface;
/**
* EXPERIMENTAL: This feature is experimental and does not fall under the backward compatibility promise.
*
* @TODO 4.0 Include support for this in main ConfigInterface
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface RuleCustomisationPolicyAwareConfigInterface extends ConfigInterface
{
/**
* EXPERIMENTAL: This feature is experimental and does not fall under the backward compatibility promise.
* Registers a filter to be applied to fixers right before running them.
*
* @todo v4 Introduce it in main ConfigInterface
*/
public function setRuleCustomisationPolicy(?RuleCustomisationPolicyInterface $ruleCustomisationPolicy): ConfigInterface;
/**
* EXPERIMENTAL: This feature is experimental and does not fall under the backward compatibility promise.
* Gets the filter to be applied to fixers right before running them.
*
* @todo v4 Introduce it in main ConfigInterface
*/
public function getRuleCustomisationPolicy(): ?RuleCustomisationPolicyInterface;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/VersionSpecificCodeSampleInterface.php | src/FixerDefinition/VersionSpecificCodeSampleInterface.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\FixerDefinition;
/**
* @author Andreas Moeller <am@localheinz.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface VersionSpecificCodeSampleInterface extends CodeSampleInterface
{
public function isSuitableFor(int $version): bool;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/CodeSample.php | src/FixerDefinition/CodeSample.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class CodeSample implements CodeSampleInterface
{
private string $code;
/**
* @var null|array<string, mixed>
*/
private ?array $configuration;
/**
* @param null|array<string, mixed> $configuration
*/
public function __construct(string $code, ?array $configuration = null)
{
$this->code = $code;
$this->configuration = $configuration;
}
public function getCode(): string
{
return $this->code;
}
public function getConfiguration(): ?array
{
return $this->configuration;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/VersionSpecificCodeSample.php | src/FixerDefinition/VersionSpecificCodeSample.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\FixerDefinition;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @readonly
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class VersionSpecificCodeSample implements VersionSpecificCodeSampleInterface
{
private CodeSampleInterface $codeSample;
private VersionSpecificationInterface $versionSpecification;
/**
* @param null|array<string, mixed> $configuration
*/
public function __construct(
string $code,
VersionSpecificationInterface $versionSpecification,
?array $configuration = null
) {
$this->codeSample = new CodeSample($code, $configuration);
$this->versionSpecification = $versionSpecification;
}
public function getCode(): string
{
return $this->codeSample->getCode();
}
public function getConfiguration(): ?array
{
return $this->codeSample->getConfiguration();
}
public function isSuitableFor(int $version): bool
{
return $this->versionSpecification->isSatisfiedBy($version);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/VersionSpecificationInterface.php | src/FixerDefinition/VersionSpecificationInterface.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\FixerDefinition;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface VersionSpecificationInterface
{
public function isSatisfiedBy(int $version): bool;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/FileSpecificCodeSampleInterface.php | src/FixerDefinition/FileSpecificCodeSampleInterface.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface FileSpecificCodeSampleInterface extends CodeSampleInterface
{
public function getSplFileInfo(): \SplFileInfo;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/VersionSpecification.php | src/FixerDefinition/VersionSpecification.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\FixerDefinition;
/**
* @author Andreas Möller <am@localheinz.com>
*
* @readonly
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class VersionSpecification implements VersionSpecificationInterface
{
/**
* @var null|int<1, max>
*/
private ?int $minimum;
/**
* @var null|int<1, max>
*/
private ?int $maximum;
/**
* @param null|int<1, max> $minimum
* @param null|int<1, max> $maximum
*
* @throws \InvalidArgumentException
*/
public function __construct(?int $minimum = null, ?int $maximum = null)
{
if (null === $minimum && null === $maximum) {
throw new \InvalidArgumentException('Minimum or maximum need to be specified.');
}
if (null !== $minimum && 1 > $minimum) {
throw new \InvalidArgumentException('Minimum needs to be either null or an integer greater than 0.');
}
if (null !== $maximum) {
if (1 > $maximum) {
throw new \InvalidArgumentException('Maximum needs to be either null or an integer greater than 0.');
}
if (null !== $minimum && $maximum < $minimum) {
throw new \InvalidArgumentException('Maximum should not be lower than the minimum.');
}
}
$this->minimum = $minimum;
$this->maximum = $maximum;
}
public function isSatisfiedBy(int $version): bool
{
if (null !== $this->minimum && $version < $this->minimum) {
return false;
}
if (null !== $this->maximum && $version > $this->maximum) {
return false;
}
return true;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/FileSpecificCodeSample.php | src/FixerDefinition/FileSpecificCodeSample.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FileSpecificCodeSample implements FileSpecificCodeSampleInterface
{
private CodeSampleInterface $codeSample;
private \SplFileInfo $splFileInfo;
/**
* @param null|array<string, mixed> $configuration
*/
public function __construct(
string $code,
\SplFileInfo $splFileInfo,
?array $configuration = null
) {
$this->codeSample = new CodeSample($code, $configuration);
$this->splFileInfo = $splFileInfo;
}
public function getCode(): string
{
return $this->codeSample->getCode();
}
public function getConfiguration(): ?array
{
return $this->codeSample->getConfiguration();
}
public function getSplFileInfo(): \SplFileInfo
{
return $this->splFileInfo;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/FixerDefinition.php | src/FixerDefinition/FixerDefinition.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FixerDefinition implements FixerDefinitionInterface
{
private string $summary;
/**
* @var list<CodeSampleInterface>
*/
private array $codeSamples;
/**
* Description of Fixer and benefit of using it.
*/
private ?string $description;
/**
* Description why Fixer is risky.
*/
private ?string $riskyDescription;
/**
* @param list<CodeSampleInterface> $codeSamples array of samples, where single sample is [code, configuration]
* @param null|string $riskyDescription null for non-risky fixer
*/
public function __construct(
string $summary,
array $codeSamples,
?string $description = null,
?string $riskyDescription = null
) {
$this->summary = $summary;
$this->codeSamples = $codeSamples;
$this->description = $description;
$this->riskyDescription = $riskyDescription;
}
public function getSummary(): string
{
return $this->summary;
}
public function getDescription(): ?string
{
return $this->description;
}
public function getRiskyDescription(): ?string
{
return $this->riskyDescription;
}
public function getCodeSamples(): array
{
return $this->codeSamples;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/CodeSampleInterface.php | src/FixerDefinition/CodeSampleInterface.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface CodeSampleInterface
{
public function getCode(): string;
/**
* @return null|array<string, mixed>
*/
public function getConfiguration(): ?array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/FixerDefinition/FixerDefinitionInterface.php | src/FixerDefinition/FixerDefinitionInterface.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\FixerDefinition;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface FixerDefinitionInterface
{
public function getSummary(): string;
public function getDescription(): ?string;
/**
* @return null|string null for non-risky fixer
*/
public function getRiskyDescription(): ?string;
/**
* Array of samples, where single sample is [code, configuration].
*
* @return list<CodeSampleInterface>
*/
public function getCodeSamples(): array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Differ/DifferInterface.php | src/Differ/DifferInterface.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\Differ;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface DifferInterface
{
/**
* Create diff.
*/
public function diff(string $old, string $new, ?\SplFileInfo $file = null): string;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Differ/DiffConsoleFormatter.php | src/Differ/DiffConsoleFormatter.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\Differ;
use PhpCsFixer\Preg;
use Symfony\Component\Console\Formatter\OutputFormatter;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class DiffConsoleFormatter
{
private bool $isDecoratedOutput;
private string $template;
public function __construct(bool $isDecoratedOutput, string $template = '%s')
{
$this->isDecoratedOutput = $isDecoratedOutput;
$this->template = $template;
}
public function format(string $diff, string $lineTemplate = '%s'): string
{
$isDecorated = $this->isDecoratedOutput;
$template = $isDecorated
? $this->template
: Preg::replace('/<[^<>]+>/', '', $this->template);
return \sprintf(
$template,
implode(
\PHP_EOL,
array_map(
static function (string $line) use ($isDecorated, $lineTemplate): string {
if ($isDecorated) {
$count = 0;
$line = Preg::replaceCallback(
'/^([+\-@].*)/',
static function (array $matches): string {
if ('+' === $matches[0][0]) {
$colour = 'green';
} elseif ('-' === $matches[0][0]) {
$colour = 'red';
} else {
$colour = 'cyan';
}
return \sprintf('<fg=%s>%s</fg=%s>', $colour, OutputFormatter::escape($matches[0]), $colour);
},
$line,
1,
$count,
);
if (0 === $count) {
$line = OutputFormatter::escape($line);
}
}
return \sprintf($lineTemplate, $line);
},
Preg::split('#\R#u', $diff),
),
),
);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Differ/FullDiffer.php | src/Differ/FullDiffer.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\Differ;
use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\StrictUnifiedDiffOutputBuilder;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class FullDiffer implements DifferInterface
{
private Differ $differ;
public function __construct()
{
$this->differ = new Differ(new StrictUnifiedDiffOutputBuilder([
'collapseRanges' => false,
'commonLineThreshold' => 100,
'contextLines' => 100,
'fromFile' => 'Original',
'toFile' => 'New',
]));
}
public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
{
return $this->differ->diff($old, $new);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Differ/UnifiedDiffer.php | src/Differ/UnifiedDiffer.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\Differ;
use PhpCsFixer\Preg;
use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\StrictUnifiedDiffOutputBuilder;
/**
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class UnifiedDiffer implements DifferInterface
{
public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
{
if (null === $file) {
$options = [
'fromFile' => 'Original',
'toFile' => 'New',
];
} else {
$filePath = $file->getRealPath();
if (Preg::match('/\s/', $filePath)) {
$filePath = '"'.$filePath.'"';
}
$options = [
'fromFile' => $filePath,
'toFile' => $filePath,
];
}
$differ = new Differ(new StrictUnifiedDiffOutputBuilder($options));
return $differ->diff($old, $new);
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/Differ/NullDiffer.php | src/Differ/NullDiffer.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\Differ;
/**
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class NullDiffer implements DifferInterface
{
public function diff(string $old, string $new, ?\SplFileInfo $file = null): string
{
return '';
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/DeprecatedRuleSetDescriptionInterface.php | src/RuleSet/DeprecatedRuleSetDescriptionInterface.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\RuleSet;
/*
* @deprecated
* @TODO v4 remove me @MARKER_deprecated_DeprecatedRuleSetDescriptionInterface
*/
class_alias(
DeprecatedRuleSetDefinitionInterface::class,
DeprecatedRuleSetDescriptionInterface::class, // @phpstan-ignore class.notFound
);
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/AutomaticRuleSetDefinitionInterface.php | src/RuleSet/AutomaticRuleSetDefinitionInterface.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\RuleSet;
/**
* Used to indicate that the ruleset can be automatically determined and will differ based on runtime conditions.
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface AutomaticRuleSetDefinitionInterface
{
public const WARNING_MESSAGE_DECORATED = '<comment>This rule is automatic</comment>: it\'s definition depends on your project, eg "composer.json" file.';
/**
* @return array<string, array<string, mixed>|bool>
*/
public function getRulesCandidates(): array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/AbstractMajorMinorDeprecationSetDefinition.php | src/RuleSet/AbstractMajorMinorDeprecationSetDefinition.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\RuleSet;
use PhpCsFixer\Preg;
/**
* @internal
*
* @TODO v4 remove me @MARKER_deprecated_migration_ruleset
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
abstract class AbstractMajorMinorDeprecationSetDefinition extends AbstractMigrationSetDefinition implements DeprecatedRuleSetDefinitionInterface
{
public function getRules(): array
{
$newName = Preg::replace('#(\d+)\.?(\d)#', '\1x\2', $this->getName());
return [
$newName => true,
];
}
public function getSuccessorsNames(): array
{
return array_keys($this->getRules());
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/AbstractMigrationSetDefinition.php | src/RuleSet/AbstractMigrationSetDefinition.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\RuleSet;
use PhpCsFixer\Preg;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
abstract class AbstractMigrationSetDefinition extends AbstractRuleSetDefinition
{
private string $entity;
/** @var array{'major': int, 'minor': int} */
private array $version;
public function __construct()
{
parent::__construct();
$this->parseRuleSetName();
}
/**
* @internal
*/
public function getEntity(): string
{
return $this->entity;
}
public function getVersionMajorMinor(): string
{
return \sprintf('%s.%s', $this->version['major'], $this->version['minor']);
}
public function getDescription(): string
{
$improvement = [
'PHPUnit' => 'tests code',
][$this->getEntity()] ?? 'code';
return \sprintf('Rules to improve %s for %s %s compatibility.', $improvement, $this->getEntity(), $this->getVersionMajorMinor());
}
private function parseRuleSetName(): void
{
$name = $this->getName();
// @TODO v4 - `x?` -> `x` @MARKER_deprecated_migration_name_pattern
if (Preg::match('#^@PHPUnit(\d+)x?(\d)Migration.*$#', $name, $matches)) {
$this->entity = 'PHPUnit';
$this->version = [
'major' => (int) $matches[1],
'minor' => (int) $matches[2],
];
return;
}
// @TODO v4 - `x?` -> `x` @MARKER_deprecated_migration_name_pattern
if (Preg::match('#^@PHP(\d)x?(\d)Migration.*$#', $name, $matches)) {
$this->entity = 'PHP';
$this->version = [
'major' => (int) $matches[1],
'minor' => (int) $matches[2],
];
return;
}
throw new \RuntimeException(\sprintf('Cannot generate name of "%s" / "%s".', static::class, $name));
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/RuleSets.php | src/RuleSet/RuleSets.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\RuleSet;
use PhpCsFixer\RuleSetNameValidator;
use Symfony\Component\Finder\Finder;
/**
* Set of rule sets to be used by fixer.
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class RuleSets
{
/**
* @var null|array<string, RuleSetDefinitionInterface>
*/
private static ?array $builtInSetDefinitions = null;
/**
* @var array<string, RuleSetDefinitionInterface>
*/
private static array $customRuleSetDefinitions = [];
/**
* @return array<string, RuleSetDefinitionInterface>
*/
public static function getSetDefinitions(): array
{
$allRuleSets = array_merge(
self::getBuiltInSetDefinitions(),
self::$customRuleSetDefinitions,
);
uksort($allRuleSets, static fn (string $x, string $y): int => strnatcmp($x, $y));
return $allRuleSets;
}
/**
* @return array<string, RuleSetDefinitionInterface>
*/
public static function getBuiltInSetDefinitions(): array
{
if (null === self::$builtInSetDefinitions) {
self::$builtInSetDefinitions = [];
$finder = Finder::create()
->files()
->in(__DIR__.'/Sets')
->exclude('Internal/')
;
foreach ($finder as $file) {
/** @var class-string<RuleSetDefinitionInterface> $class */
$class = 'PhpCsFixer\RuleSet\Sets\\'.$file->getBasename('.php');
/** @var RuleSetDefinitionInterface */
$set = new $class();
if (!RuleSetNameValidator::isValid($set->getName(), false)) {
throw new \InvalidArgumentException(\sprintf('Rule set name invalid: %s', $set->getName()));
}
self::$builtInSetDefinitions[$set->getName()] = $set;
}
uksort(self::$builtInSetDefinitions, static fn (string $x, string $y): int => strnatcmp($x, $y));
}
return self::$builtInSetDefinitions;
}
/**
* @return list<string>
*/
public static function getSetDefinitionNames(): array
{
return array_keys(self::getSetDefinitions());
}
public static function getSetDefinition(string $name): RuleSetDefinitionInterface
{
$definitions = self::getSetDefinitions();
if (!isset($definitions[$name])) {
throw new \InvalidArgumentException(\sprintf('Set "%s" does not exist.', $name));
}
return $definitions[$name];
}
public static function registerCustomRuleSet(RuleSetDefinitionInterface $ruleset): void
{
$name = $ruleset->getName();
if (!RuleSetNameValidator::isValid($name, true)) {
throw new \InvalidArgumentException('RuleSet name must begin with "@" and a letter (a-z, A-Z), and can contain only letters (a-z, A-Z), numbers, underscores, slashes, colons, dots and hyphens.');
}
if (\array_key_exists($name, self::getSetDefinitions())) {
throw new \InvalidArgumentException(\sprintf('Set "%s" is already defined.', $name));
}
self::$customRuleSetDefinitions[$name] = $ruleset;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/AutomaticMigrationSetTrait.php | src/RuleSet/AutomaticMigrationSetTrait.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\RuleSet;
use Composer\Semver\Semver;
use PhpCsFixer\ComposerJsonReader;
use PhpCsFixer\ConfigurationException\UnresolvableAutoRuleSetConfigurationException;
/**
* @internal
*
* @phpstan-require-implements AutomaticRuleSetDefinitionInterface
*
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
trait AutomaticMigrationSetTrait
{
private function calculateTargetSet(string $setName, string $entity, bool $isRisky): string
{
static $set = null;
if (null === $set) {
$actualVersion = self::calculateActualVersion($entity);
$candidates = self::calculateCandidateSets($entity, $isRisky);
$composerCandidates = Semver::rsort(array_keys($candidates));
foreach ($composerCandidates as $candidate) {
if (Semver::satisfies($actualVersion, '>='.$candidate)) {
$set = $candidates[$candidate]; // @phpstan-ignore offsetAccess.notFound
break;
}
}
if (null === $set) {
throw new UnresolvableAutoRuleSetConfigurationException(\sprintf('No migration set found feasible for %s (%s %s).', $setName, $entity, $actualVersion));
}
}
return $set;
}
/**
* @return list<AbstractMigrationSetDefinition>
*/
private static function getMigrationSets(): array
{
static $sets = null;
if (null === $sets) {
$sets = array_values(array_filter(
RuleSets::getSetDefinitions(),
static fn (RuleSetDefinitionInterface $set): bool => !($set instanceof DeprecatedRuleSetDefinitionInterface) && is_subclass_of($set, AbstractMigrationSetDefinition::class),
));
}
return $sets;
}
private static function calculateActualVersion(string $entity): string
{
$composerJsonReader = ComposerJsonReader::createSingleton();
if ('PHP' === $entity) {
$version = $composerJsonReader->getPhp();
} elseif ('PHPUnit' === $entity) {
$version = $composerJsonReader->getPhpUnit();
} else {
throw new \InvalidArgumentException(\sprintf('Entity "%s" is not supported.', $entity));
}
if (null === $version) {
throw new UnresolvableAutoRuleSetConfigurationException(\sprintf('Cannot detect %s version from "composer.json".', $entity));
}
return $version;
}
/**
* @return array<string, string> [ 'major.minor' => '@SetName', ... ]
*/
private static function calculateCandidateSets(string $entity, bool $isRisky): array
{
$candidates = [];
foreach (self::getMigrationSets() as $set) {
if ($set->getEntity() !== $entity) {
continue;
}
if ($set->isRisky() !== $isRisky) {
continue;
}
$candidates[$set->getVersionMajorMinor()] = $set->getName();
}
return $candidates;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/RuleSet.php | src/RuleSet/RuleSet.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\RuleSet;
use PhpCsFixer\ConfigurationException\InvalidFixerConfigurationException;
use PhpCsFixer\Future;
use PhpCsFixer\Utils;
/**
* Set of rules to be used by fixer.
*
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @readonly
*
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class RuleSet implements RuleSetInterface
{
/**
* Group of rules generated from input set.
*
* The key is name of rule, value is configuration array or true.
* The key must not point to any set.
*
* @var array<string, array<string, mixed>|true>
*/
private array $rules;
public function __construct(array $set = [])
{
foreach ($set as $name => $value) {
if ('' === $name) {
throw new \InvalidArgumentException('Rule/set name must not be empty.');
}
if (\is_int($name)) {
throw new \InvalidArgumentException(\sprintf('Missing value for "%s" rule/set.', $value));
}
if (!\is_bool($value) && !\is_array($value)) {
$message = str_starts_with($name, '@') ? 'Set must be enabled (true) or disabled (false). Other values are not allowed.' : 'Rule must be enabled (true), disabled (false) or configured (non-empty, assoc array). Other values are not allowed.';
if (null === $value) {
$message .= ' To disable the '.(str_starts_with($name, '@') ? 'set' : 'rule').', use "FALSE" instead of "NULL".';
}
throw new InvalidFixerConfigurationException($name, $message);
}
}
$this->rules = $this->resolveSet($set);
}
public function hasRule(string $rule): bool
{
return \array_key_exists($rule, $this->rules);
}
public function getRuleConfiguration(string $rule): ?array
{
if (!$this->hasRule($rule)) {
throw new \InvalidArgumentException(\sprintf('Rule "%s" is not in the set.', $rule));
}
if (true === $this->rules[$rule]) {
return null;
}
return $this->rules[$rule];
}
public function getRules(): array
{
return $this->rules;
}
/**
* Resolve input set into group of rules.
*
* @param array<string, array<string, mixed>|bool> $rules
*
* @return array<string, array<string, mixed>|true>
*/
private function resolveSet(array $rules): array
{
$resolvedRules = [];
// expand sets
foreach ($rules as $name => $value) {
if (str_starts_with($name, '@')) {
if (!\is_bool($value)) {
throw new \UnexpectedValueException(\sprintf('Nested rule set "%s" configuration must be a boolean.', $name));
}
$set = $this->resolveSubset($name, $value);
$resolvedRules = array_merge($resolvedRules, $set);
} else {
$resolvedRules[$name] = $value;
}
}
// filter out all resolvedRules that are off
$resolvedRules = array_filter(
$resolvedRules,
static fn ($value): bool => false !== $value,
);
return $resolvedRules;
}
/**
* Resolve set rules as part of another set.
*
* If set value is false then disable all fixers in set,
* if not then get value from set item.
*
* @return array<string, array<string, mixed>|bool>
*/
private function resolveSubset(string $setName, bool $setValue): array
{
$ruleSet = RuleSets::getSetDefinition($setName);
if ($ruleSet instanceof DeprecatedRuleSetDefinitionInterface) {
$messageEnd = [] === $ruleSet->getSuccessorsNames()
? 'No replacement available'
: \sprintf('Use %s instead', Utils::naturalLanguageJoin($ruleSet->getSuccessorsNames()));
Future::triggerDeprecation(new \RuntimeException("Rule set \"{$setName}\" is deprecated. {$messageEnd}."));
}
$rules = $ruleSet->getRules();
foreach ($rules as $name => $value) {
if (str_starts_with($name, '@')) {
$set = $this->resolveSubset($name, $setValue);
unset($rules[$name]);
$rules = array_merge($rules, $set);
} elseif (!$setValue) {
$rules[$name] = false;
} else {
$rules[$name] = $value;
}
}
return $rules;
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/InternalRuleSetDefinitionInterface.php | src/RuleSet/InternalRuleSetDefinitionInterface.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\RuleSet;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface InternalRuleSetDefinitionInterface {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/RuleSetInterface.php | src/RuleSet/RuleSetInterface.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\RuleSet;
/**
* Set of rules to be used by fixer.
*
* Example of set: ["@PSR2" => true, "@PSR1" => false, "strict" => true].
*
* @author Dariusz Rumiński <dariusz.ruminski@gmail.com>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface RuleSetInterface
{
/**
* @param array<string, array<string, mixed>|bool> $set
*/
public function __construct(array $set = []);
/**
* Get configuration for given rule.
*
* @return null|array<string, mixed>
*/
public function getRuleConfiguration(string $rule): ?array;
/**
* Get all rules from rules set.
*
* @return array<string, array<string, mixed>|true>
*/
public function getRules(): array;
/**
* Check given rule is in rules set.
*/
public function hasRule(string $rule): bool;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/DeprecatedRuleSetDefinitionInterface.php | src/RuleSet/DeprecatedRuleSetDefinitionInterface.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\RuleSet;
/**
* @author Greg Korba <greg@codito.dev>
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface DeprecatedRuleSetDefinitionInterface extends RuleSetDefinitionInterface
{
/**
* Returns names of rule sets to use instead, if any.
*
* @return list<string>
*/
public function getSuccessorsNames(): array;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/AbstractRuleSetDefinition.php | src/RuleSet/AbstractRuleSetDefinition.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\RuleSet;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
abstract class AbstractRuleSetDefinition implements RuleSetDefinitionInterface
{
public function __construct() {}
public function getName(): string
{
$name = substr(static::class, 1 + (int) strrpos(static::class, '\\'), -3);
return '@'.str_replace('Risky', ':risky', $name);
}
public function isRisky(): bool
{
return str_contains(static::class, 'Risky');
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/RuleSetDefinitionInterface.php | src/RuleSet/RuleSetDefinitionInterface.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\RuleSet;
/**
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
interface RuleSetDefinitionInterface
{
public function getDescription(): string;
public function getName(): string;
/**
* Get all rules from rules set.
*
* @return array<string, array<string, mixed>|bool>
*/
public function getRules(): array;
public function isRisky(): bool;
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PSR2Set.php | src/RuleSet/Sets/PSR2Set.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractRuleSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PSR2Set extends AbstractRuleSetDefinition
{
public function getRules(): array
{
return [
'@PSR1' => true,
'blank_line_after_namespace' => true,
'braces_position' => true,
'class_definition' => true,
'constant_case' => true,
'control_structure_braces' => true,
'control_structure_continuation_position' => true,
'elseif' => true,
'function_declaration' => [
'closure_fn_spacing' => 'one', // @TODO: default value of this option changed, consider to switch to new default
],
'indentation_type' => true,
'line_ending' => true,
'lowercase_keywords' => true,
'method_argument_space' => [
'after_heredoc' => false, // @TODO: default value of this option changed, consider to switch to new default
'attribute_placement' => 'ignore',
'on_multiline' => 'ensure_fully_multiline',
],
'modifier_keywords' => ['elements' => ['method', 'property']],
'no_break_comment' => true,
'no_closing_tag' => true,
'no_multiple_statements_per_line' => true,
'no_space_around_double_colon' => true,
'no_spaces_after_function_name' => true,
'no_trailing_whitespace' => true,
'no_trailing_whitespace_in_comment' => true,
'single_blank_line_at_eof' => true,
'single_class_element_per_statement' => [
'elements' => [
'property',
],
],
'single_import_per_statement' => true,
'single_line_after_imports' => true,
'single_space_around_construct' => [
'constructs_followed_by_a_single_space' => [
'abstract',
'as',
'case',
'catch',
'class',
'do',
'else',
'elseif',
'final',
'for',
'foreach',
'function',
'if',
'interface',
'namespace',
'private',
'protected',
'public',
'static',
'switch',
'trait',
'try',
'use_lambda',
'while',
],
'constructs_preceded_by_a_single_space' => [
'as',
'else',
'elseif',
'use_lambda',
],
],
'spaces_inside_parentheses' => true,
'statement_indentation' => true,
'switch_case_semicolon_to_colon' => true,
'switch_case_space' => true,
];
}
public function getDescription(): string
{
return 'Rules that follow `PSR-2 <https://www.php-fig.org/psr/psr-2/>`_ standard.';
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP7x4MigrationRiskySet.php | src/RuleSet/Sets/PHP7x4MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP7x4MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHP7x1Migration:risky' => true,
'implode_call' => true,
'no_alias_functions' => true,
'use_arrow_functions' => true,
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP7x3MigrationSet.php | src/RuleSet/Sets/PHP7x3MigrationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP7x3MigrationSet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHP7x1Migration' => true,
'heredoc_indentation' => true,
'method_argument_space' => ['after_heredoc' => true],
'no_whitespace_before_comma_in_array' => ['after_heredoc' => true],
'trailing_comma_in_multiline' => ['after_heredoc' => true],
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP71MigrationSet.php | src/RuleSet/Sets/PHP71MigrationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP71MigrationSet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PSR12Set.php | src/RuleSet/Sets/PSR12Set.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractRuleSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PSR12Set extends AbstractRuleSetDefinition
{
public function getRules(): array
{
return [
'@PSR2' => true,
'binary_operator_spaces' => [
'default' => 'at_least_single_space',
],
'blank_line_after_opening_tag' => true,
'blank_line_between_import_groups' => true,
'blank_lines_before_namespace' => true,
'braces_position' => [
'allow_single_line_empty_anonymous_classes' => true,
],
'class_definition' => [
'inline_constructor_arguments' => false, // handled by method_argument_space fixer
'space_before_parenthesis' => true, // defined in PSR12 ¶8. Anonymous Classes
],
'compact_nullable_type_declaration' => true,
'declare_equal_normalize' => true,
'lowercase_cast' => true,
'lowercase_static_reference' => true,
'modifier_keywords' => true,
'new_with_parentheses' => [
'anonymous_class' => true,
],
'no_blank_lines_after_class_opening' => true,
'no_extra_blank_lines' => [
'tokens' => [
'use', // defined in PSR12 ¶3. Declare Statements, Namespace, and Import Statements
],
],
'no_leading_import_slash' => true,
'no_whitespace_in_blank_line' => true,
'ordered_class_elements' => [
'order' => [
'use_trait',
],
],
'ordered_imports' => [
'imports_order' => [
'class',
'function',
'const',
],
'sort_algorithm' => 'none',
],
'return_type_declaration' => true,
'short_scalar_cast' => true,
'single_import_per_statement' => ['group_to_single_imports' => false],
'single_space_around_construct' => [
'constructs_followed_by_a_single_space' => [
'abstract',
'as',
'case',
'catch',
'class',
'const_import',
'do',
'else',
'elseif',
'final',
'finally',
'for',
'foreach',
'function',
'function_import',
'if',
'insteadof',
'interface',
'namespace',
'new',
'private',
'protected',
'public',
'static',
'switch',
'trait',
'try',
'use',
'use_lambda',
'while',
],
'constructs_preceded_by_a_single_space' => [
'as',
'else',
'elseif',
'use_lambda',
],
],
'single_trait_insert_per_statement' => true,
'ternary_operator_spaces' => true,
'unary_operator_spaces' => [
'only_dec_inc' => true,
],
];
}
public function getDescription(): string
{
return 'Rules that follow `PSR-12 <https://www.php-fig.org/psr/psr-12/>`_ standard.';
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP74MigrationSet.php | src/RuleSet/Sets/PHP74MigrationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP74MigrationSet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP8x4MigrationSet.php | src/RuleSet/Sets/PHP8x4MigrationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP8x4MigrationSet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHP8x3Migration' => true,
'new_expression_parentheses' => true,
'nullable_type_declaration_for_default_null_value' => true,
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP81MigrationSet.php | src/RuleSet/Sets/PHP81MigrationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP81MigrationSet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP70MigrationRiskySet.php | src/RuleSet/Sets/PHP70MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP70MigrationRiskySet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHPUnit3x0MigrationRiskySet.php | src/RuleSet/Sets/PHPUnit3x0MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\Fixer\PhpUnit\PhpUnitTargetVersion;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHPUnit3x0MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'php_unit_dedicate_assert' => [
'target' => PhpUnitTargetVersion::VERSION_3_0,
],
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHPUnit35MigrationRiskySet.php | src/RuleSet/Sets/PHPUnit35MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHPUnit35MigrationRiskySet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHPUnit3x5MigrationRiskySet.php | src/RuleSet/Sets/PHPUnit3x5MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\Fixer\PhpUnit\PhpUnitTargetVersion;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHPUnit3x5MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHPUnit3x2Migration:risky' => true,
'php_unit_dedicate_assert' => [
'target' => PhpUnitTargetVersion::VERSION_3_5,
],
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP8x3MigrationRiskySet.php | src/RuleSet/Sets/PHP8x3MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP8x3MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHP8x2Migration:risky' => true,
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHPUnit3x2MigrationRiskySet.php | src/RuleSet/Sets/PHPUnit3x2MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\Fixer\PhpUnit\PhpUnitTargetVersion;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHPUnit3x2MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHPUnit3x0Migration:risky' => true,
'php_unit_no_expectation_annotation' => [
'target' => PhpUnitTargetVersion::VERSION_3_2,
],
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHPUnit60MigrationRiskySet.php | src/RuleSet/Sets/PHPUnit60MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMajorMinorDeprecationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHPUnit60MigrationRiskySet extends AbstractMajorMinorDeprecationSetDefinition {}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/PHP8x2MigrationRiskySet.php | src/RuleSet/Sets/PHP8x2MigrationRiskySet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractMigrationSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class PHP8x2MigrationRiskySet extends AbstractMigrationSetDefinition
{
public function getRules(): array
{
return [
'@PHP8x1Migration:risky' => true,
'phpdoc_readonly_class_comment_to_keyword' => true,
];
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
PHP-CS-Fixer/PHP-CS-Fixer | https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/63b024eaaf8a48445494964bd21a6c38c788f40f/src/RuleSet/Sets/DoctrineAnnotationSet.php | src/RuleSet/Sets/DoctrineAnnotationSet.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\RuleSet\Sets;
use PhpCsFixer\RuleSet\AbstractRuleSetDefinition;
/**
* @internal
*
* @no-named-arguments Parameter names are not covered by the backward compatibility promise.
*/
final class DoctrineAnnotationSet extends AbstractRuleSetDefinition
{
public function getRules(): array
{
return [
'doctrine_annotation_array_assignment' => [
'operator' => ':',
],
'doctrine_annotation_braces' => true,
'doctrine_annotation_indentation' => true,
'doctrine_annotation_spaces' => [
'before_array_assignments_colon' => false,
],
];
}
public function getDescription(): string
{
return 'Rules covering ``Doctrine`` annotations with configuration based on examples found in `Doctrine Annotation documentation <https://www.doctrine-project.org/projects/doctrine-annotations/en/latest/annotations.html>`_ and `Symfony documentation <https://symfony.com/doc/master/bundles/SensioFrameworkExtraBundle/annotations/routing.html>`_.';
}
}
| php | MIT | 63b024eaaf8a48445494964bd21a6c38c788f40f | 2026-01-04T15:02:54.911792Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.