Merge pull request #97 from yoeunes/dev

Adds strict ranges option to regex optimizer

Author: yoeunes

README.md

@@ -499,6 +499,7 @@ parameters:
         optimizationConfig:
             digits: true
             word: true
+            strictRanges: true
 ```
 
 * Options mirror the PHPStan bridge:
@@ -509,6 +510,7 @@ parameters:
   * `suggestOptimizations` — surface shorter equivalent patterns when found (default: `false`).
   * `optimizationConfig.digits` — enable `[0-9]` → `\d` optimization suggestions (default: `true`).
   * `optimizationConfig.word` — enable `[a-zA-Z0-9_]` → `\w` optimization suggestions (default: `true`).
+  * `optimizationConfig.strictRanges` — prevent merging characters from different categories (digits, letters, symbols) into single ranges for better readability (default: `true`).
 
 ### Psalm
 

TODO.md

@@ -11,7 +11,8 @@ parametersSchema:
         # Configuration for specific optimizations
         optimizationConfig: structure([
             digits: bool(),
-            word: bool()
+            word: bool(),
+            strictRanges: bool()
         ])
     ])
 
@@ -34,6 +35,7 @@ parameters:
         optimizationConfig:
             digits: true
             word: true
+            strictRanges: true
 
 services:
     # Main regex validation rule for PHPStan

extension.neon

@@ -85,17 +85,17 @@ final class PregValidationRule implements Rule
     private ?ReDoSAnalyzer $redosAnalyzer = null;
 
     /**
-     * @param bool                            $ignoreParseErrors  Ignore parse errors for partial regex strings
-     * @param bool                            $reportRedos        Report ReDoS vulnerability analysis
-     * @param string                          $redosThreshold     Minimum ReDoS severity level to report
-     * @param array{digits: bool, word: bool} $optimizationConfig
+     * @param bool                                                $ignoreParseErrors  Ignore parse errors for partial regex strings
+     * @param bool                                                $reportRedos        Report ReDoS vulnerability analysis
+     * @param string                                              $redosThreshold     Minimum ReDoS severity level to report
+     * @param array{digits: bool, word: bool, strictRanges: bool} $optimizationConfig
      */
     public function __construct(
         private readonly bool $ignoreParseErrors = true,
         private readonly bool $reportRedos = true,
         private readonly string $redosThreshold = 'high',
         private readonly bool $suggestOptimizations = false,
-        private readonly array $optimizationConfig = ['digits' => true, 'word' => true],
+        private readonly array $optimizationConfig = ['digits' => true, 'word' => true, 'strictRanges' => true],
     ) {}
 
     public function getNodeType(): string
@@ -268,6 +268,7 @@ private function validatePattern(string $pattern, int $lineNumber): array
                 $optimizer = new \RegexParser\NodeVisitor\OptimizerNodeVisitor(
                     optimizeDigits: (bool) ($this->optimizationConfig['digits'] ?? true),
                     optimizeWord: (bool) ($this->optimizationConfig['word'] ?? true),
+                    strictRanges: (bool) ($this->optimizationConfig['strictRanges'] ?? true),
                 );
                 $optimizedAst = $ast->accept($optimizer);
                 // Use compiler to get string back

src/Bridge/PHPStan/PregValidationRule.php

@@ -34,7 +34,8 @@ final class OptimizerNodeVisitor extends AbstractNodeVisitor
 
     public function __construct(
         private readonly bool $optimizeDigits = true,
-        private readonly bool $optimizeWord = true
+        private readonly bool $optimizeWord = true,
+        private readonly bool $strictRanges = true
     ) {
         $this->charSetAnalyzer = new CharSetAnalyzer();
     }
@@ -573,6 +574,28 @@ private function isFullWordClass(array $parts): bool
         return !\in_array(false, $partsFound, true);
     }
 
+    /**
+     * Classify a character by its ASCII category for range merging.
+     *
+     * @param int $ord the ASCII ordinal of the character
+     *
+     * @return int category: 0=other, 1=digits, 2=uppercase, 3=lowercase
+     */
+    private function getCharCategory(int $ord): int
+    {
+        if ($ord >= 48 && $ord <= 57) { // 0-9
+            return 1;
+        }
+        if ($ord >= 65 && $ord <= 90) { // A-Z
+            return 2;
+        }
+        if ($ord >= 97 && $ord <= 122) { // a-z
+            return 3;
+        }
+
+        return 0; // other
+    }
+
     /**
      * @param array<Node\NodeInterface> $parts
      *
@@ -654,7 +677,7 @@ private function normalizeCharClassParts(array $parts): array
                 continue;
             }
 
-            if ($ord === $rangeEnd + 1) {
+            if ($ord === $rangeEnd + 1 && (!$this->strictRanges || $this->getCharCategory($ord) === $this->getCharCategory($rangeEnd))) {
                 $rangeEnd = $ord;
                 $rangeEndPos = max($rangeEndPos, $posEnd);
 

src/NodeVisitor/OptimizerNodeVisitor.php

@@ -533,4 +533,26 @@ public function test_optimizations_can_be_disabled(): void
         $resultWordEnabled = $optimizedWordEnabled->accept($compiler);
         $this->assertSame('/\w/', $resultWordEnabled, 'Word optimization should work when enabled');
     }
+
+    public function test_strict_ranges_option(): void
+    {
+        $regex = Regex::create();
+        $compiler = new CompilerNodeVisitor();
+
+        // Test strict ranges (default): prevent merging different categories
+        $ast = $regex->parse('/[0-9:]/');
+        $optimizerStrict = new OptimizerNodeVisitor(strictRanges: true);
+        $optimizedStrict = $ast->accept($optimizerStrict);
+        $resultStrict = $optimizedStrict->accept($compiler);
+        // Should remain [0-9:] or equivalent, not [0-: ]
+        $this->assertStringStartsWith('/[', $resultStrict);
+        $this->assertStringEndsWith(']/', $resultStrict);
+        $this->assertNotSame('/[0-:]/', $resultStrict, 'Strict ranges should not merge digits and symbols');
+
+        // Test loose ranges: allow merging different categories
+        $optimizerLoose = new OptimizerNodeVisitor(strictRanges: false);
+        $optimizedLoose = $ast->accept($optimizerLoose);
+        $resultLoose = $optimizedLoose->accept($compiler);
+        $this->assertSame('/[0-:]/', $resultLoose, 'Loose ranges should merge digits and symbols');
+    }
 }