Merge pull request #25 from BackEndTea/feat/named-back-reference

Support named back references
BackEndTea · Jan 28, 2021 · 4f63341 · 4f63341
2 parents 7c27ed1 + c0f267f
commit 4f63341
Show file tree

Hide file tree

Showing 11 changed files with 243 additions and 6 deletions.
diff --git a/composer.json b/composer.json
@@ -24,10 +24,10 @@
         }
     },
     "require-dev": {
-        "phpstan/phpstan": "^0.12.64",
+        "phpstan/phpstan": "^0.12.70",
         "phpunit/phpunit": "^9.5",
-        "vimeo/psalm": "^4.3",
-        "infection/infection": "^0.20.2",
+        "vimeo/psalm": "^4.4",
+        "infection/infection": "^0.21",
         "doctrine/coding-standard": "^8.2"
     }
 }
diff --git a/phpstan_baseline.neon b/phpstan_baseline.neon
@@ -2,5 +2,5 @@ parameters:
 	ignoreErrors:
 		-
 			message: "#^Parameter \\#1 \\$char of static method BackEndTea\\\\Regexer\\\\Token\\\\Exception\\\\MissingEnd\\:\\:fromDelimiter\\(\\) expects string, string\\|null given\\.$#"
-			count: 1
+			count: 2
 			path: src/Lexer/Lexer.php
diff --git a/psalm_baseline.xml b/psalm_baseline.xml
@@ -7,7 +7,7 @@
     <MixedArgument occurrences="1">
       <code>$this-&gt;delimiter</code>
     </MixedArgument>
-    <PossiblyNullArgument occurrences="2">
+    <PossiblyNullArgument occurrences="3">
       <code>$this-&gt;delimiter</code>
       <code>$input-&gt;next()</code>
     </PossiblyNullArgument>

diff --git a/src/Lexer/Lexer.php b/src/Lexer/Lexer.php
@@ -11,6 +11,7 @@
 use BackEndTea\Regexer\Token\Dot;
 use BackEndTea\Regexer\Token\Escaped;
 use BackEndTea\Regexer\Token\Exception\InvalidDelimiter;
+use BackEndTea\Regexer\Token\Exception\InvalidReference;
 use BackEndTea\Regexer\Token\Exception\MissingEnd;
 use BackEndTea\Regexer\Token\Exception\MissingStart;
 use BackEndTea\Regexer\Token\Exception\UnclosedBracketList;
@@ -111,6 +112,20 @@ public function regexToTokenStream(Stream $input): iterable
                         $token = Token\Anchor\End::create();
                         break;
                     case '(':
+                        if ($input->getBetween($input->currentIndex(), $input->currentIndex() + 3) === '(?P=') {
+                            $referenceTo = '';
+                            while ($input->next() !== null) {
+                                $current      = $input->current();
+                                $referenceTo .= $current;
+                                if ($current === ')') {
+                                    break;
+                                }
+                            }
+
+                            $token = SubPattern\Reference::forPNotation($referenceTo);
+                            break;
+                        }
+
                         ++$this->subPatternCount;
                         $token        = SubPattern\Start::create();
                         $currentIndex = $input->currentIndex();
@@ -375,6 +390,38 @@ private function createEscapeSequence(Stream $input): Token
             return Escaped\EscapedCharacter::fromCharacter('-');
         }
 
+        if ($current === 'k') {
+            $next = $input->next();
+            switch ($next) {
+                case '{':
+                    $closing = '}';
+                    break;
+                case '\'':
+                    $closing = '\'';
+                    break;
+                case '<':
+                    $closing = '>';
+                    break;
+                case null:
+                    throw MissingEnd::fromDelimiter($this->delimiter);
+
+                default:
+                    throw InvalidReference::fromKNotation($next);
+            }
+
+            $start       = 'k' . $next;
+            $referenceTo = '';
+            while ($input->next() !== null) {
+                $current      = $input->current();
+                $referenceTo .= $current;
+                if ($current === $closing) {
+                    break;
+                }
+            }
+
+            return SubPattern\Reference::create($start . $referenceTo);
+        }
+
         if ($current === 'g' && $input->at($input->currentIndex() + 1) === '{') {
             $current = 'g{';
             $input->next();

diff --git a/src/Node/SubPattern/Reference.php b/src/Node/SubPattern/Reference.php
@@ -17,6 +17,10 @@ final class Reference extends Node
         '\\' => '',
         '\g' => '',
         '\g{' => '}',
+        '\k{' => '}',
+        '\k<' => '>',
+        '\k\'' => '\'',
+        '(?P=' => ')',
     ];
 
     private string $referenceTo;

diff --git a/src/Parser/TokenParser.php b/src/Parser/TokenParser.php
@@ -209,7 +209,11 @@ private function parseFromToken(Node\NodeWithChildren $parent, array $tokens, in
         if ($token instanceof Token\SubPattern\Reference) {
             $tokenString = $token->asString();
 
-            if ($tokenString[1] !== 'g') {
+            if ($tokenString[1] === 'k') {
+                $node = new Node\SubPattern\Reference('\\k' . $tokenString[2], substr($token->asString(), 3, -1));
+            } elseif ($tokenString[0] === '(') {
+                $node = new Node\SubPattern\Reference('(?P=', substr($token->asString(), 4, -1));
+            } elseif ($tokenString[1] !== 'g') {
                 $node = new Node\SubPattern\Reference('\\', substr($token->asString(), 1));
             } elseif ($tokenString[2] === '{') {
                 $node = new Node\SubPattern\Reference('\\g{', substr($token->asString(), 3, -1));

diff --git a/src/Token/Exception/InvalidReference.php b/src/Token/Exception/InvalidReference.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BackEndTea\Regexer\Token\Exception;
+
+use function sprintf;
+
+final class InvalidReference extends SyntaxException
+{
+    public static function fromKNotation(string $character): self
+    {
+        return new self(sprintf(
+            'Only \',{ or < are allowed after \k, got "%s"',
+            $character
+        ));
+    }
+}
diff --git a/src/Token/SubPattern/Reference.php b/src/Token/SubPattern/Reference.php
@@ -6,10 +6,20 @@
 
 use BackEndTea\Regexer\Token;
 
+use function sprintf;
+
 final class Reference extends Token
 {
     public static function create(string $characters): self
     {
         return new self('\\' . $characters);
     }
+
+    public static function forPNotation(string $name): self
+    {
+        return new self(sprintf(
+            '(%s',
+            $name
+        ));
+    }
 }
diff --git a/tests/E2E/ParserLexer/NamedSubPatternTest.php b/tests/E2E/ParserLexer/NamedSubPatternTest.php
@@ -51,5 +51,135 @@ public function provideTestCases(): Generator
             ],
             new Node\RootNode('/', [new Node\SubPattern([new Node\LiteralCharacters('ab')], true, new Node\SubPattern\Name('?P<', 'foo'))], ''),
         ];
+
+        yield 'Named back reference with \g{ notation' => [
+            '/(?P<foo>ab)=\g{foo}/',
+            [
+                Token\Delimiter::create('/'),
+                Token\SubPattern\Start::create(),
+                Token\SubPattern\Named::fromName('?P<foo>'),
+                Token\LiteralCharacters::create('ab'),
+                Token\SubPattern\End::create(),
+                Token\LiteralCharacters::create('='),
+                Token\SubPattern\Reference::create('g{foo}'),
+                Token\Delimiter::create('/'),
+            ],
+            new Node\RootNode('/', [
+                new Node\SubPattern(
+                    [
+                        new Node\LiteralCharacters('ab'),
+                    ],
+                    true,
+                    new Node\SubPattern\Name('?P<', 'foo')
+                ),
+                new Node\LiteralCharacters('='),
+                new Node\SubPattern\Reference('\g{', 'foo'),
+            ], ''),
+            ['ab=ab'],
+        ];
+
+        yield 'Named back reference with \k{ notation' => [
+            '/(?P<foo>ab)=\k{foo}/',
+            [
+                Token\Delimiter::create('/'),
+                Token\SubPattern\Start::create(),
+                Token\SubPattern\Named::fromName('?P<foo>'),
+                Token\LiteralCharacters::create('ab'),
+                Token\SubPattern\End::create(),
+                Token\LiteralCharacters::create('='),
+                Token\SubPattern\Reference::create('k{foo}'),
+                Token\Delimiter::create('/'),
+            ],
+            new Node\RootNode('/', [
+                new Node\SubPattern(
+                    [
+                        new Node\LiteralCharacters('ab'),
+                    ],
+                    true,
+                    new Node\SubPattern\Name('?P<', 'foo')
+                ),
+                new Node\LiteralCharacters('='),
+                new Node\SubPattern\Reference('\k{', 'foo'),
+            ], ''),
+            ['ab=ab'],
+        ];
+
+        yield 'Named back reference with \k\' notation' => [
+            '/(?P<foo>ab)=\k\'foo\'/',
+            [
+                Token\Delimiter::create('/'),
+                Token\SubPattern\Start::create(),
+                Token\SubPattern\Named::fromName('?P<foo>'),
+                Token\LiteralCharacters::create('ab'),
+                Token\SubPattern\End::create(),
+                Token\LiteralCharacters::create('='),
+                Token\SubPattern\Reference::create('k\'foo\''),
+                Token\Delimiter::create('/'),
+            ],
+            new Node\RootNode('/', [
+                new Node\SubPattern(
+                    [
+                        new Node\LiteralCharacters('ab'),
+                    ],
+                    true,
+                    new Node\SubPattern\Name('?P<', 'foo')
+                ),
+                new Node\LiteralCharacters('='),
+                new Node\SubPattern\Reference('\k\'', 'foo'),
+            ], ''),
+            ['ab=ab'],
+        ];
+
+        yield 'Named back reference with \k< notation' => [
+            '/(?P<foo>ab)=\k<foo>/',
+            [
+                Token\Delimiter::create('/'),
+                Token\SubPattern\Start::create(),
+                Token\SubPattern\Named::fromName('?P<foo>'),
+                Token\LiteralCharacters::create('ab'),
+                Token\SubPattern\End::create(),
+                Token\LiteralCharacters::create('='),
+                Token\SubPattern\Reference::create('k<foo>'),
+                Token\Delimiter::create('/'),
+            ],
+            new Node\RootNode('/', [
+                new Node\SubPattern(
+                    [
+                        new Node\LiteralCharacters('ab'),
+                    ],
+                    true,
+                    new Node\SubPattern\Name('?P<', 'foo')
+                ),
+                new Node\LiteralCharacters('='),
+                new Node\SubPattern\Reference('\k<', 'foo'),
+            ], ''),
+            ['ab=ab'],
+        ];
+
+        yield 'Named back reference with (?P=) notation' => [
+            '/(?P<foo>ab)=(?P=foo)/',
+            [
+                Token\Delimiter::create('/'),
+                Token\SubPattern\Start::create(),
+                Token\SubPattern\Named::fromName('?P<foo>'),
+                Token\LiteralCharacters::create('ab'),
+                Token\SubPattern\End::create(),
+                Token\LiteralCharacters::create('='),
+                Token\SubPattern\Reference::forPNotation('?P=foo)'),
+                Token\Delimiter::create('/'),
+            ],
+            new Node\RootNode('/', [
+                new Node\SubPattern(
+                    [
+                        new Node\LiteralCharacters('ab'),
+                    ],
+                    true,
+                    new Node\SubPattern\Name('?P<', 'foo')
+                ),
+                new Node\LiteralCharacters('='),
+                new Node\SubPattern\Reference('(?P=', 'foo'),
+            ], ''),
+            ['ab=ab'],
+        ];
     }
 }
diff --git a/tests/Lexer/LexerFailureTest.php b/tests/Lexer/LexerFailureTest.php
@@ -6,6 +6,7 @@
 
 use BackEndTea\Regexer\StringStream;
 use BackEndTea\Regexer\Token\Exception\InvalidDelimiter;
+use BackEndTea\Regexer\Token\Exception\InvalidReference;
 use BackEndTea\Regexer\Token\Exception\InvalidSubPattern;
 use BackEndTea\Regexer\Token\Exception\MissingEnd;
 use BackEndTea\Regexer\Token\Exception\MissingStart;
@@ -111,4 +112,20 @@ public function testCantEndOnBackslash(): void
         $this->expectException(MissingEnd::class);
         Util::iterableToArray($lexer->regexToTokenStream(new StringStream('/foo\\')));
     }
+
+    public function testInvalidKReference(): void
+    {
+        $lexer = new Lexer();
+
+        $this->expectException(InvalidReference::class);
+        Util::iterableToArray($lexer->regexToTokenStream(new StringStream('/\kfoo/')));
+    }
+
+    public function testCantEndOnUnescapedK(): void
+    {
+        $lexer = new Lexer();
+
+        $this->expectException(MissingEnd::class);
+        Util::iterableToArray($lexer->regexToTokenStream(new StringStream('/\k')));
+    }
 }
diff --git a/tests/StringStreamTest.php b/tests/StringStreamTest.php
@@ -28,4 +28,11 @@ public function testCanGetBetween(): void
 
         $this->assertSame('{123}', $stream->getBetween(3, 7));
     }
+
+    public function testAtWillReturnNullIfOutOfBounds(): void
+    {
+        $stream = new StringStream('0123');
+
+        $this->assertNull($stream->at(4));
+    }
 }