[composer-based] Register each rule only once, add --composer-based process filter

A rule registered by multiple sets was tagged repeatedly, so the same singleton
was handed out N times: run N times per node, and listed N times in reports.

Also adds the --composer-based process option and the composer-bound rule
configuration report.

Author: TomasVotruba

src/Config/RectorConfig.php

@@ -25,6 +25,7 @@
 use Rector\ValueObject\Configuration\LevelOverflow;
 use Rector\ValueObject\PhpVersion;
 use Rector\ValueObject\PolyfillPackage;
+use Rector\VersionBonding\ValueObject\ComposerBoundRuleConfiguration;
 use Symfony\Component\Console\Command\Command;
 use Webmozart\Assert\Assert;
 
@@ -39,6 +40,16 @@ final class RectorConfig extends Container
      */
     private array $ruleConfigurations = [];
 
+    /**
+     * @var array<class-string<RectorInterface>, true>
+     */
+    private array $registeredRectorClasses = [];
+
+    /**
+     * @var array<string, true>
+     */
+    private array $registeredComposerBoundRuleConfigurations = [];
+
     /**
      * @var string[]
      */
@@ -194,9 +205,6 @@ public function ruleWithConfiguration(string $rectorClass, array $configuration)
             $ruleConfiguration = $this->ruleConfigurations[$rectorClass];
             $configurableRector->configure($ruleConfiguration);
         });
-
-        // for cache invalidation in case of sets change
-        SimpleParameterProvider::addParameter(Option::REGISTERED_RECTOR_RULES, $rectorClass);
     }
 
     /**
@@ -214,11 +222,29 @@ public function ruleWithConfigurationComposerVersionBound(
         string $versionConstraint
     ): void {
         $packageVersion = $this->resolveInstalledPackageVersion($packageName);
-        if ($packageVersion === null) {
-            return;
+        $isActive = $packageVersion !== null && Semver::satisfies($packageVersion, $versionConstraint);
+
+        // the same rule configuration can be registered by multiple sets, report it only once
+        $configurationKey = $rectorClass . '|' . $packageName . '|' . $versionConstraint . '|' . serialize(
+            $configuration
+        );
+
+        if (! isset($this->registeredComposerBoundRuleConfigurations[$configurationKey])) {
+            $this->registeredComposerBoundRuleConfigurations[$configurationKey] = true;
+
+            // reported by the "composer-based" command, the inactive ones as well
+            SimpleParameterProvider::addParameter(Option::COMPOSER_BOUND_RULE_CONFIGURATIONS, [
+                new ComposerBoundRuleConfiguration(
+                    $rectorClass,
+                    $packageName,
+                    $versionConstraint,
+                    $configuration,
+                    $isActive
+                ),
+            ]);
         }
 
-        if (! Semver::satisfies($packageVersion, $versionConstraint)) {
+        if (! $isActive) {
             return;
         }
 
@@ -234,10 +260,17 @@ public function rule(string $rectorClass): void
         Assert::isAOf($rectorClass, RectorInterface::class);
 
         $this->singleton($rectorClass);
-        $this->tag($rectorClass, RectorInterface::class);
 
-        // for cache invalidation in case of change
-        SimpleParameterProvider::addParameter(Option::REGISTERED_RECTOR_RULES, $rectorClass);
+        // the same rule can be registered by multiple sets, tag it only once,
+        // otherwise it is run twice on every node and listed twice in the reports
+        if (! isset($this->registeredRectorClasses[$rectorClass])) {
+            $this->registeredRectorClasses[$rectorClass] = true;
+
+            $this->tag($rectorClass, RectorInterface::class);
+
+            // for cache invalidation in case of change
+            SimpleParameterProvider::addParameter(Option::REGISTERED_RECTOR_RULES, $rectorClass);
+        }
 
         if (is_a($rectorClass, RelatedConfigInterface::class, true)) {
             $configFile = $rectorClass::getConfigFile();
@@ -432,6 +465,8 @@ public function indent(string $character, int $count): void
     public function resetRuleConfigurations(): void
     {
         $this->ruleConfigurations = [];
+        $this->registeredRectorClasses = [];
+        $this->registeredComposerBoundRuleConfigurations = [];
     }
 
     /**

src/Configuration/ConfigurationFactory.php

@@ -95,6 +95,13 @@ public function createFromInput(InputInterface $input): Configuration
 
         $showRulesSummary = (bool) $input->getOption(Option::RULES_SUMMARY);
 
+        $isComposerBased = (bool) $input->getOption(Option::COMPOSER_BASED);
+
+        // "--composer-based" narrows the run the same way "--only" does
+        if ($isComposerBased) {
+            SimpleParameterProvider::setParameter(Option::IS_RUN_NARROWED, true);
+        }
+
         return new Configuration(
             $isDryRun,
             $showProgressBar,
@@ -113,6 +120,7 @@ public function createFromInput(InputInterface $input): Configuration
             $onlySuffix,
             $levelOverflows,
             $showRulesSummary,
+            $isComposerBased,
         );
     }
 

src/Configuration/ConfigurationRuleFilter.php

@@ -4,8 +4,11 @@
 
 namespace Rector\Configuration;
 
+use Rector\Configuration\Parameter\SimpleParameterProvider;
 use Rector\Contract\Rector\RectorInterface;
 use Rector\ValueObject\Configuration;
+use Rector\VersionBonding\Contract\ComposerPackageConstraintInterface;
+use Rector\VersionBonding\ValueObject\ComposerBoundRuleConfiguration;
 
 /**
  * Modify available rector rules based on the configuration options
@@ -34,6 +37,10 @@ public function filter(array $rectors): array
             return $this->filterOnlyRule($rectors, $onlyRule);
         }
 
+        if ($this->configuration->isComposerBased()) {
+            return $this->filterComposerBased($rectors);
+        }
+
         return $rectors;
     }
 
@@ -52,4 +59,55 @@ public function filterOnlyRule(array $rectors, string $onlyRule): array
 
         return $activeRectors;
     }
+
+    /**
+     * Keeps rules that declare a composer package constraint themselves, and rules whose configuration
+     * was registered with a composer package constraint.
+     *
+     * @param list<RectorInterface> $rectors
+     * @return list<RectorInterface>
+     */
+    private function filterComposerBased(array $rectors): array
+    {
+        $composerBoundRectorClasses = $this->resolveComposerBoundRectorClasses();
+
+        $activeRectors = [];
+        foreach ($rectors as $rector) {
+            if ($rector instanceof ComposerPackageConstraintInterface) {
+                $activeRectors[] = $rector;
+                continue;
+            }
+
+            if (in_array($rector::class, $composerBoundRectorClasses, true)) {
+                $activeRectors[] = $rector;
+            }
+        }
+
+        return $activeRectors;
+    }
+
+    /**
+     * @return string[]
+     */
+    private function resolveComposerBoundRectorClasses(): array
+    {
+        $composerBoundRuleConfigurations = SimpleParameterProvider::provideArrayParameter(
+            Option::COMPOSER_BOUND_RULE_CONFIGURATIONS
+        );
+
+        $rectorClasses = [];
+        foreach ($composerBoundRuleConfigurations as $composerBoundRuleConfiguration) {
+            if (! $composerBoundRuleConfiguration instanceof ComposerBoundRuleConfiguration) {
+                continue;
+            }
+
+            if (! $composerBoundRuleConfiguration->isActive()) {
+                continue;
+            }
+
+            $rectorClasses[] = $composerBoundRuleConfiguration->getRectorClass();
+        }
+
+        return $rectorClasses;
+    }
 }

src/Configuration/Option.php

@@ -261,6 +261,17 @@ final class Option
      */
     public const string COMPOSER_BASED_SETS = 'composer_based_sets';
 
+    /**
+     * @internal To report rule configuration bound to an installed package version
+     * @see \Rector\Config\RectorConfig::ruleWithConfigurationComposerVersionBound()
+     */
+    public const string COMPOSER_BOUND_RULE_CONFIGURATIONS = 'composer_bound_rule_configurations';
+
+    /**
+     * Run only rules bound to an installed composer package version
+     */
+    public const string COMPOSER_BASED = 'composer-based';
+
     /**
      * @internal To filter files by specific suffix
      */

src/Console/Command/ComposerBasedCommand.php

@@ -5,9 +5,14 @@
 namespace Rector\Console\Command;
 
 use Composer\Semver\Semver;
+use Nette\Utils\Strings;
 use Rector\Composer\InstalledPackageResolver;
+use Rector\Configuration\Option;
+use Rector\Configuration\Parameter\SimpleParameterProvider;
 use Rector\Contract\Rector\RectorInterface;
 use Rector\VersionBonding\Contract\ComposerPackageConstraintInterface;
+use Rector\VersionBonding\ValueObject\ComposerBoundRuleConfiguration;
+use ReflectionObject;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -38,20 +43,32 @@ protected function configure(): void
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
         $tableRows = $this->createTableRows();
+        $configurationTableRows = $this->createConfigurationTableRows();
 
-        if ($tableRows === []) {
+        if ($tableRows === [] && $configurationTableRows === []) {
             $this->symfonyStyle->warning('No composer package bound rule is loaded');
 
             return Command::SUCCESS;
         }
 
-        $this->symfonyStyle->title('Composer package bound rules');
-        $this->symfonyStyle->table(['Rule', 'Package', 'Requires', 'Installed', 'Active'], $tableRows);
+        if ($tableRows !== []) {
+            $this->symfonyStyle->title('Composer package bound rules');
+            $this->symfonyStyle->table(['Rule', 'Package', 'Requires', 'Installed', 'Active'], $tableRows);
+        }
+
+        if ($configurationTableRows !== []) {
+            $this->symfonyStyle->title('Composer package bound rule configuration');
+            $this->symfonyStyle->table(
+                ['Rule', 'Package', 'Requires', 'Installed', 'Active', 'Configuration'],
+                $configurationTableRows
+            );
+        }
 
-        $activeCount = count(array_filter($tableRows, static fn (array $tableRow): bool => $tableRow[4] === 'yes'));
+        $allTableRows = [...$tableRows, ...$configurationTableRows];
+        $activeCount = count(array_filter($allTableRows, static fn (array $tableRow): bool => $tableRow[4] === 'yes'));
 
         $this->symfonyStyle->note(
-            sprintf('%d of %d composer package bound rules are active', $activeCount, count($tableRows))
+            sprintf('%d of %d composer package bound items are active', $activeCount, count($allTableRows))
         );
 
         return Command::SUCCESS;
@@ -77,7 +94,7 @@ private function createTableRows(): array
             $isActive = $installedVersion !== null && Semver::satisfies($installedVersion, $constraint);
 
             $tableRows[] = [
-                $rector::class,
+                $this->printShortClassName($rector::class),
                 $packageName,
                 $constraint,
                 $installedVersion ?? '-',
@@ -93,4 +110,86 @@ private function createTableRows(): array
 
         return $tableRows;
     }
+
+    /**
+     * @return array<array{string, string, string, string, string, string}>
+     */
+    private function createConfigurationTableRows(): array
+    {
+        $composerBoundRuleConfigurations = SimpleParameterProvider::provideArrayParameter(
+            Option::COMPOSER_BOUND_RULE_CONFIGURATIONS
+        );
+
+        $tableRows = [];
+
+        foreach ($composerBoundRuleConfigurations as $composerBoundRuleConfiguration) {
+            if (! $composerBoundRuleConfiguration instanceof ComposerBoundRuleConfiguration) {
+                continue;
+            }
+
+            $packageName = $composerBoundRuleConfiguration->getPackageName();
+            $installedVersion = $this->installedPackageResolver->resolvePackageVersion($packageName);
+
+            $tableRows[] = [
+                $this->printShortClassName($composerBoundRuleConfiguration->getRectorClass()),
+                $packageName,
+                $composerBoundRuleConfiguration->getVersionConstraint(),
+                $installedVersion ?? '-',
+                $composerBoundRuleConfiguration->isActive() ? 'yes' : 'no',
+                $this->printConfiguration($composerBoundRuleConfiguration->getConfiguration()),
+            ];
+        }
+
+        return $tableRows;
+    }
+
+    /**
+     * @param mixed[] $configuration
+     */
+    private function printConfiguration(array $configuration): string
+    {
+        $printedItems = [];
+
+        foreach ($configuration as $key => $value) {
+            $printedValue = $this->printConfigurationValue($value);
+
+            $printedItems[] = is_string($key) ? $key . ': ' . $printedValue : $printedValue;
+        }
+
+        return implode(PHP_EOL, $printedItems);
+    }
+
+    private function printConfigurationValue(mixed $value): string
+    {
+        if (is_object($value)) {
+            $printedPropertyValues = [];
+
+            $reflectionObject = new ReflectionObject($value);
+            foreach ($reflectionObject->getProperties() as $reflectionProperty) {
+                $printedPropertyValues[] = $this->printConfigurationValue($reflectionProperty->getValue($value));
+            }
+
+            return $this->printShortClassName($value::class) . '(' . implode(', ', $printedPropertyValues) . ')';
+        }
+
+        if (is_array($value)) {
+            $printedItems = array_map(
+                $this->printConfigurationValue(...),
+                $value
+            );
+
+            return '[' . implode(', ', $printedItems) . ']';
+        }
+
+        if (is_bool($value)) {
+            return $value ? 'true' : 'false';
+        }
+
+        return (string) $value;
+    }
+
+    private function printShortClassName(string $className): string
+    {
+        return Strings::after($className, '\\', -1) ?? $className;
+    }
 }

src/Console/ProcessConfigureDecorator.php

@@ -59,6 +59,13 @@ public static function decorate(Command $command): void
         // filter by rule and path
         $command->addOption(Option::ONLY, null, InputOption::VALUE_REQUIRED, 'Fully qualified rule class name');
 
+        $command->addOption(
+            Option::COMPOSER_BASED,
+            null,
+            InputOption::VALUE_NONE,
+            'Run only rules bound to an installed composer package version'
+        );
+
         $command->addOption(
             Option::ONLY_SUFFIX,
             null,

src/Parallel/Command/WorkerCommandLineFactory.php

@@ -123,6 +123,10 @@ public function create(
             }
         }
 
+        if ((bool) $input->getOption(Option::COMPOSER_BASED)) {
+            $workerCommandArray[] = self::OPTION_DASHES . Option::COMPOSER_BASED;
+        }
+
         if ($input->getOption(Option::ONLY) !== null) {
             $workerCommandArray[] = self::OPTION_DASHES . Option::ONLY;
             $workerCommandArray[] = escapeshellarg((string) $input->getOption(Option::ONLY));