FEATURE: Fusion/AFX preserve dots in escaped paths

fixes neos#3112 - Fusion parser: dont split paths at dots, who are inside quotes. - AFX: allow quoted attribute identifier. Example: AFX: ```html <div '@foo.bar'='baz'></div> ``` Fusion: ```ts Neos.Fusion:Tag { attributes.'@foo.bar' = 'baz' } ``` Fusion ast (excerpt): ```php 'attributes' => [ '@foo.bar' => 'baz' ] ``` Before this, AFX doesnt allow quoted attribute identifier, and the Fusion Parser split at dots in quotes too, making those paths nested.
davidspiola · Sep 26, 2021 · 0602d6d · 0602d6d
1 parent 494c065
commit 0602d6d
Show file tree

Hide file tree

Showing 6 changed files with 183 additions and 10 deletions.
diff --git a/Neos.Fusion.Afx/Classes/Parser/Expression/Identifier.php b/Neos.Fusion.Afx/Classes/Parser/Expression/Identifier.php
@@ -39,6 +39,10 @@ public static function parse(Lexer $lexer): string
                 case $lexer->isMinus():
                 case $lexer->isUnderscore():
                 case $lexer->isAt():
+                case $lexer->isDoubleQuote():
+                case $lexer->isSingleQuote():
+                case $lexer->isBackSlash() && $lexer->peek(2) === '\"':
+                case $lexer->isBackSlash() && $lexer->peek(2) === '\\\'':
                     $identifier .= $lexer->consume();
                     break;
                 case $lexer->isEqualSign():

diff --git a/Neos.Fusion.Afx/Tests/Functional/ParserTest.php b/Neos.Fusion.Afx/Tests/Functional/ParserTest.php
@@ -219,6 +219,38 @@ public function shouldParseSingleSelfClosingTagWithSingleAttribute(): void
         );
     }
 
+    /**
+     * @test
+     */
+    public function shouldParseSingleSelfClosingTagWithEmptyAttribute(): void
+    {
+        $parser = new Parser('<div prop/>');
+
+        $this->assertEquals(
+            [
+                [
+                    'type' => 'node',
+                    'payload' => [
+                        'identifier' => 'div',
+                        'attributes' => [
+                            [
+                                'type' => 'prop',
+                                'payload' => [
+                                    'type' => 'boolean',
+                                    'payload' => true,
+                                    'identifier' => 'prop'
+                                ]
+                            ]
+                        ],
+                        'children' => [],
+                        'selfClosing' => true
+                    ]
+                ]
+            ],
+            $parser->parse()
+        );
+    }
+
     /**
      * @test
      */
@@ -299,6 +331,86 @@ public function shouldParseSingleSelfClosingTagWithMultipleAttributesWrappedByMu
         );
     }
 
+    /**
+     * @test
+     */
+    public function shouldParseTagWithSingleOrDoubleQuoteEscapedAttributeIdentifier(): void
+    {
+        $parser = new Parser('<div "@click.blah.blih.blub"="value" \'@click.blah.blih.blub\'="value"/>');
+
+        $this->assertEquals(
+            [
+                [
+                    'type' => 'node',
+                    'payload' => [
+                        'identifier' => 'div',
+                        'attributes' => [
+                            [
+                                'type' => 'prop',
+                                'payload' => [
+                                    'type' => 'string',
+                                    'payload' => 'value',
+                                    'identifier' => '"@click.blah.blih.blub"'
+                                ]
+                            ],
+                            [
+                                'type' => 'prop',
+                                'payload' => [
+                                    'type' => 'string',
+                                    'payload' => 'value',
+                                    'identifier' => '\'@click.blah.blih.blub\''
+                                ]
+                            ]
+                        ],
+                        'children' => [],
+                        'selfClosing' => true
+                    ]
+                ]
+            ],
+            $parser->parse()
+        );
+    }
+
+    /**
+     * @test
+     */
+    public function shouldParseTagWithEscapedAttributeIdentifierWithQuoteEscapesInside(): void
+    {
+        $parser = new Parser('<div "@click.escaped\"escaped"="value" \'escaped\\\'escaped\' />');
+
+        $this->assertEquals(
+            [
+                [
+                    'type' => 'node',
+                    'payload' => [
+                        'identifier' => 'div',
+                        'attributes' => [
+                            [
+                                'type' => 'prop',
+                                'payload' => [
+                                    'type' => 'string',
+                                    'payload' => 'value',
+                                    'identifier' => '"@click.escaped\"escaped"'
+                                ]
+                            ],
+                            [
+                                'type' => 'prop',
+                                'payload' => [
+                                    'type' => 'boolean',
+                                    'payload' => true,
+                                    'identifier' => '\'escaped\\\'escaped\''
+                                ]
+                            ]
+                        ],
+                        'children' => [],
+                        'selfClosing' => true
+                    ]
+                ]
+            ],
+            $parser->parse()
+        );
+    }
+
     /**
      * @test
      */

diff --git a/Neos.Fusion/Classes/Core/Parser.php b/Neos.Fusion/Classes/Core/Parser.php
@@ -96,15 +96,17 @@ class Parser implements ParserInterface
 	/x';
 
     /**
-     * Split an object path like "foo.bar.baz.quux" or "foo.prototype(Neos.Fusion:Something).bar.baz"
-     * at the dots (but not the dots inside the prototype definition prototype(...))
+     * Split an object path like "foo.bar.baz.quux", "foo.'bar.baz.quux'" or "foo.prototype(Neos.Fusion:Something).bar.baz"
+     * at the dots (but not the dots inside the prototype definition prototype(...) or dots inside quotes)
      */
     const SPLIT_PATTERN_OBJECTPATH = '/
-		\.                         # we split at dot characters...
-		(?!                        # which are not inside prototype(...). Thus, the dot does NOT match IF it is followed by:
-			[^(]*                  # - any character except (
-			\)                     # - the character )
-		)
+        (                       # Matches area if:
+            prototype\(.*?\)        # inside prototype(...),
+            |"(?:\\\"|[^"])+"       # inside double quotes - respect escape,
+            |\'(?:\\\\\'|[^\'])+\'  # inside single quotes - respect escape
+        )
+        (*SKIP)(*FAIL)          # skip, when the preceding matches and fail (dont include them in the match)
+        |\.                     # for what was not matched, we split at dot characters...
 	/x';
 
     /**

diff --git a/Neos.Fusion/Tests/Unit/Core/Fixtures/ParserTestFusionFixture25.fusion b/Neos.Fusion/Tests/Unit/Core/Fixtures/ParserTestFusionFixture25.fusion
@@ -0,0 +1,9 @@
+
+//
+// Fusion Fixture 25
+//
+// Checks if quoted paths will escape the @ char
+// and if dots inside the quotes will not be interpreted as nested.
+
+attributes."@notAMeta" = "value"
+attributes."@notAMeta.notNested.reallyNotNested.string" = "value"
diff --git a/Neos.Fusion/Tests/Unit/Core/Parser/PatternTest.php b/Neos.Fusion/Tests/Unit/Core/Parser/PatternTest.php
@@ -134,6 +134,25 @@ public function testSPLIT_PATTERN_OBJECTPATH()
         ];
         self::assertSame($expected, preg_split($pattern, 'foo.bar'));
 
+        $expected = [
+            0 => 'attributes',
+            1 => '"dots.inside.double.quotes"'
+        ];
+        self::assertSame($expected, preg_split($pattern, 'attributes."dots.inside.double.quotes"'));
+
+        $expected = [
+            0 => 'attributes',
+            1 => '\'dots.inside.single.quotes\''
+        ];
+        self::assertSame($expected, preg_split($pattern, 'attributes.\'dots.inside.single.quotes\''));
+
+        $expected = [
+            0 => '"quo\"tes.mix\'ed"',
+            1 => 'bla',
+            2 => '\'he\\\'.llo\''
+        ];
+        self::assertSame($expected, preg_split($pattern, '"quo\"tes.mix\'ed".bla.\'he\\\'.llo\''));
+
         $expected = [
             0 => 'prototype(Neos.Foo)',
             1 => 'bar'
@@ -148,28 +167,35 @@ public function testSPLIT_PATTERN_OBJECTPATH()
         self::assertSame($expected, preg_split($pattern, 'asdf.prototype(Neos.Foo).bar'));
 
         $expected = [
-            0 =>  'blah',
+            0 => 'blah',
             1 => 'asdf',
             2 => 'prototype(Neos.Foo)',
             3 => 'bar'
         ];
         self::assertSame($expected, preg_split($pattern, 'blah.asdf.prototype(Neos.Foo).bar'));
 
         $expected = [
-            0 =>  'b-lah',
+            0 => 'b-lah',
             1 => 'asdf',
             2 => 'prototype(Neos.Foo)',
             3 => 'b-ar'
         ];
         self::assertSame($expected, preg_split($pattern, 'b-lah.asdf.prototype(Neos.Foo).b-ar'));
 
         $expected = [
-            0 =>  'b:lah',
+            0 => 'b:lah',
             1 => 'asdf',
             2 => 'prototype(Neos.Foo)',
             3 => 'b:ar'
         ];
         self::assertSame($expected, preg_split($pattern, 'b:lah.asdf.prototype(Neos.Foo).b:ar'));
+
+        $expected = [
+            0 => 'asdf',
+            1 => 'prototype(Neos.Foo)',
+            2 => '"@click.blah.blub"'
+        ];
+        self::assertSame($expected, preg_split($pattern, 'asdf.prototype(Neos.Foo)."@click.blah.blub"'));
     }
 
     /**

diff --git a/Neos.Fusion/Tests/Unit/Core/ParserTest.php b/Neos.Fusion/Tests/Unit/Core/ParserTest.php
@@ -920,6 +920,26 @@ public function parserCorrectlyParsesFixture21()
         self::assertSame($expectedParseTree, $actualParseTree, 'The parse tree was not as expected after parsing fixture 23.');
     }
 
+    /**
+     * Checks if identifiers starting with digits are parsed correctly
+     *
+     * @test
+     */
+    public function parserCorrectlyParsesFixture25()
+    {
+        $sourceCode = $this->readFusionFixture('ParserTestFusionFixture25');
+
+        $expectedParseTree = [
+            'attributes' => [
+                '@notAMeta' => 'value',
+                '@notAMeta.notNested.reallyNotNested.string' => 'value'
+            ]
+        ];
+
+        $actualParseTree = $this->parser->parse($sourceCode);
+        self::assertSame($expectedParseTree, $actualParseTree, 'The parse tree was not as expected after parsing fixture 23.');
+    }
+
     /**
      * Checks if really long strings are parsed correctly
      *