[Console] Add --all option to list-rules to list all existing rules in core and rector-* packages

src/Console/Command/ListRulesCommand.php

@@ -7,6 +7,7 @@
 use Nette\Utils\Json;
 use Rector\ChangesReporting\Output\ConsoleOutputFormatter;
 use Rector\Configuration\Option;
+use Rector\Console\Rule\AllRectorRulesProvider;
 use Rector\Contract\Rector\RectorInterface;
 use Rector\PostRector\Contract\Rector\PostRectorInterface;
 use Rector\Skipper\Skipper\Skipper;
@@ -24,6 +25,7 @@ final class ListRulesCommand extends Command
     public function __construct(
         private readonly SymfonyStyle $symfonyStyle,
         private readonly Skipper $skipper,
+        private readonly AllRectorRulesProvider $allRectorRulesProvider,
         private readonly array $rectors
     ) {
         parent::__construct();
@@ -45,11 +47,20 @@ protected function configure(): void
         );
 
         $this->addOption(Option::ONLY, null, InputOption::VALUE_REQUIRED, 'Fully qualified rule class name');
+
+        $this->addOption(
+            'all',
+            null,
+            InputOption::VALUE_NONE,
+            'List all existing rules in core and rector-* packages, not only the loaded ones'
+        );
     }
 
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
-        $rectorClasses = $this->resolveRectorClasses();
+        $rectorClasses = $input->getOption('all')
+            ? $this->allRectorRulesProvider->provide()
+            : $this->resolveRectorClasses();
 
         $skippedClasses = $this->getSkippedRectorClasses();
 

src/Console/Rule/AllRectorRulesProvider.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Console\Rule;
+
+use Composer\Autoload\ClassLoader;
+use Rector\Contract\Rector\RectorInterface;
+use Rector\PostRector\Contract\Rector\PostRectorInterface;
+use ReflectionClass;
+use SplFileInfo;
+use Symfony\Component\Finder\Finder;
+
+/**
+ * Discovers all Rector rule classes available on disk - in core and rector-* packages -
+ * regardless of the current config, by scanning the registered PSR-4 prefixes.
+ *
+ * @see \Rector\Tests\Console\Rule\AllRectorRulesProviderTest
+ */
+final class AllRectorRulesProvider
+{
+    /**
+     * @return array<class-string<RectorInterface>>
+     */
+    public function provide(): array
+    {
+        $rectorClasses = [];
+
+        foreach ($this->resolvePsr4Prefixes() as $namespacePrefix => $directories) {
+            if (! str_starts_with($namespacePrefix, 'Rector\\')) {
+                continue;
+            }
+
+            foreach ($directories as $directory) {
+                if (! is_dir($directory)) {
+                    continue;
+                }
+
+                foreach ($this->findRectorFiles($directory) as $fileInfo) {
+                    $className = $this->resolveClassName($namespacePrefix, $directory, $fileInfo);
+                    if ($this->isConcreteRectorRule($className)) {
+                        $rectorClasses[] = $className;
+                    }
+                }
+            }
+        }
+
+        $rectorClasses = array_unique($rectorClasses);
+        sort($rectorClasses);
+
+        return $rectorClasses;
+    }
+
+    /**
+     * @return array<string, string[]>
+     */
+    private function resolvePsr4Prefixes(): array
+    {
+        $psr4Prefixes = [];
+
+        // there can be multiple registered class loaders; merge their prefixes
+        foreach (spl_autoload_functions() as $autoloadFunction) {
+            if (! is_array($autoloadFunction) || ! $autoloadFunction[0] instanceof ClassLoader) {
+                continue;
+            }
+
+            foreach ($autoloadFunction[0]->getPrefixesPsr4() as $namespacePrefix => $directories) {
+                $psr4Prefixes[$namespacePrefix] = array_merge($psr4Prefixes[$namespacePrefix] ?? [], $directories);
+            }
+        }
+
+        return $psr4Prefixes;
+    }
+
+    /**
+     * @return iterable<SplFileInfo>
+     */
+    private function findRectorFiles(string $directory): iterable
+    {
+        return Finder::create()
+            ->files()
+            ->name('*Rector.php')
+            ->in($directory);
+    }
+
+    private function resolveClassName(string $namespacePrefix, string $directory, SplFileInfo $fileInfo): string
+    {
+        $relativePath = substr($fileInfo->getPathname(), strlen($directory) + 1, -strlen('.php'));
+
+        return $namespacePrefix . str_replace('/', '\\', $relativePath);
+    }
+
+    /**
+     * @phpstan-assert-if-true class-string<RectorInterface> $className
+     */
+    private function isConcreteRectorRule(string $className): bool
+    {
+        // is_a() autoloads the class and returns false when it does not exist
+        if (! is_a($className, RectorInterface::class, true)) {
+            return false;
+        }
+
+        if (is_a($className, PostRectorInterface::class, true)) {
+            return false;
+        }
+
+        $reflectionClass = new ReflectionClass($className);
+
+        return ! $reflectionClass->isAbstract();
+    }
+}

src/DependencyInjection/LazyContainerFactory.php

@@ -40,6 +40,7 @@
 use Rector\Console\Command\ValidateConfigCommand;
 use Rector\Console\Command\WorkerCommand;
 use Rector\Console\ConsoleApplication;
+use Rector\Console\Rule\AllRectorRulesProvider;
 use Rector\Console\Style\SymfonyStyleFactory;
 use Rector\Contract\PhpParser\DecoratingNodeVisitorInterface;
 use Rector\NodeNameResolver\NodeNameResolver;
@@ -158,6 +159,7 @@ private function registerConsole(RectorConfig $rectorConfig): void
         $rectorConfig->singleton(WorkerCommand::class);
         $rectorConfig->singleton(ValidateConfigCommand::class);
         $rectorConfig->singleton(SetupCICommand::class);
+        $rectorConfig->singleton(AllRectorRulesProvider::class);
         $rectorConfig->singleton(ListRulesCommand::class);
         $rectorConfig->singleton(CustomRuleCommand::class);
         $rectorConfig->singleton(ComposerBasedCommand::class);

tests/Console/Rule/AllRectorRulesProviderTest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Console\Rule;
+
+use PHPUnit\Framework\TestCase;
+use Rector\Console\Rule\AllRectorRulesProvider;
+use Rector\DeadCode\Rector\Assign\RemoveDoubleAssignRector;
+use Rector\PostRector\Rector\UnusedImportRemovingPostRector;
+
+final class AllRectorRulesProviderTest extends TestCase
+{
+    private AllRectorRulesProvider $allRectorRulesProvider;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->allRectorRulesProvider = new AllRectorRulesProvider();
+    }
+
+    public function testProvidesCoreRule(): void
+    {
+        $rectorClasses = $this->allRectorRulesProvider->provide();
+
+        $this->assertContains(RemoveDoubleAssignRector::class, $rectorClasses);
+    }
+
+    public function testSkipsPostRectors(): void
+    {
+        $rectorClasses = $this->allRectorRulesProvider->provide();
+
+        $this->assertNotContains(UnusedImportRemovingPostRector::class, $rectorClasses);
+    }
+
+    public function testListIsSortedAndUnique(): void
+    {
+        $rectorClasses = $this->allRectorRulesProvider->provide();
+
+        $sortedClasses = $rectorClasses;
+        sort($sortedClasses);
+
+        $this->assertSame($sortedClasses, $rectorClasses);
+        $this->assertSame(array_unique($rectorClasses), $rectorClasses);
+    }
+}