refactor(view): implement custom html parser (#1115)

Author: brendt

.gitignore

@@ -16,3 +16,4 @@ tests/Unit/Log
 log/
 node_modules
 dist
+profile/

composer.json

@@ -42,6 +42,7 @@
         "carthage-software/mago": "0.22.2",
         "guzzlehttp/psr7": "^2.6.1",
         "illuminate/view": "~11.7.0",
+        "masterminds/html5": "^2.9",
         "mikey179/vfsstream": "^2.0@dev",
         "nesbot/carbon": "^3.8",
         "nyholm/psr7": "^1.8",

phpstan.neon.dist

@@ -29,8 +29,6 @@ parameters:
 		    message: '#.*uninitialized readonly property \$composer*#'
 		-
 		    message: '#.*uninitialized readonly property \$stubFileGenerator*#'
-		-
-		    message: '#.*undefined property Dom*#'
 		-
 		    message: '#.*undefined method Dom*#'
 

src/Tempest/View/src/Attributes/AttributeFactory.php

@@ -5,19 +5,17 @@
 namespace Tempest\View\Attributes;
 
 use Tempest\View\Attribute;
-use Tempest\View\Element;
 
 final readonly class AttributeFactory
 {
-    public function make(Element $element, string $attributeName): Attribute
+    public function make(string $attributeName): Attribute
     {
         return match (true) {
             $attributeName === ':if' => new IfAttribute(),
             $attributeName === ':elseif' => new ElseIfAttribute(),
             $attributeName === ':else' => new ElseAttribute(),
             $attributeName === ':foreach' => new ForeachAttribute(),
             $attributeName === ':forelse' => new ForelseAttribute(),
-            BooleanAttribute::matches($element, $attributeName) => new BooleanAttribute($attributeName),
             str_starts_with($attributeName, ':') => new ExpressionAttribute($attributeName),
             default => new DataAttribute($attributeName),
         };

src/Tempest/View/src/Attributes/BooleanAttribute.php

@@ -10,7 +10,7 @@
 use Tempest\View\Elements\TextElement;
 use Tempest\View\Elements\ViewComponentElement;
 use Tempest\View\Exceptions\InvalidDataAttribute;
-use Tempest\View\Renderers\TempestViewCompiler;
+use Tempest\View\Parser\TempestViewCompiler;
 
 use function Tempest\Support\str;
 
@@ -35,7 +35,7 @@ public function apply(Element $element): Element
 
         $value = $element->getAttribute($this->name);
 
-        if (str($value)->startsWith(TempestViewCompiler::TOKEN_MAPPING)) {
+        if (str($value)->startsWith(TempestViewCompiler::PHP_TOKENS)) {
             throw new InvalidDataAttribute($this->name, $value);
         }
 

src/Tempest/View/src/Attributes/DataAttribute.php

@@ -10,7 +10,7 @@
 use Tempest\View\Element;
 use Tempest\View\Elements\PhpDataElement;
 use Tempest\View\Exceptions\InvalidExpressionAttribute;
-use Tempest\View\Renderers\TempestViewCompiler;
+use Tempest\View\Parser\TempestViewCompiler;
 
 use function Tempest\Support\str;
 
@@ -24,7 +24,7 @@ public function apply(Element $element): Element
     {
         $value = str($element->getAttribute($this->name));
 
-        if ($value->startsWith(['{{', '{!!', ...TempestViewCompiler::TOKEN_MAPPING])) {
+        if ($value->startsWith(['{{', '{!!', ...TempestViewCompiler::PHP_TOKENS])) {
             throw new InvalidExpressionAttribute($value);
         }
 

src/Tempest/View/src/Attributes/ExpressionAttribute.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Tempest\View\Attributes;
+
+use Tempest\View\Attribute;
+use Tempest\View\Element;
+
+/*
+ * This class is used whenever PHP code occurs within element tags, it will make sure this code is left untouched
+ * <div <?= 'hi' ?> class="foo">
+ * The most common use case for this happening is when conditional attributes are rendered within a view component
+ */
+final readonly class PhpAttribute implements Attribute
+{
+    public function __construct(
+        private string $index,
+        private string $content,
+    ) {}
+
+    public function apply(Element $element): Element
+    {
+        $element
+            ->addRawAttribute($this->content)
+            ->unsetAttribute($this->index);
+
+        return $element;
+    }
+}

src/Tempest/View/src/Attributes/PhpAttribute.php

@@ -16,6 +16,8 @@ public function getAttribute(string $name): ?string;
 
     public function setAttribute(string $name, string $value): self;
 
+    public function addRawAttribute(string $attribute): self;
+
     public function consumeAttribute(string $name): ?string;
 
     public function unsetAttribute(string $name): self;

src/Tempest/View/src/Element.php

@@ -4,15 +4,13 @@
 
 namespace Tempest\View\Elements;
 
-use Dom\Comment;
-use Dom\DocumentType;
-use Dom\Element as DomElement;
-use Dom\Node;
-use Dom\Text;
 use Tempest\Container\Container;
 use Tempest\Core\AppConfig;
+use Tempest\View\Attributes\PhpAttribute;
 use Tempest\View\Element;
-use Tempest\View\Renderers\TempestViewCompiler;
+use Tempest\View\Parser\TempestViewCompiler;
+use Tempest\View\Parser\Token;
+use Tempest\View\Parser\TokenType;
 use Tempest\View\ViewComponent;
 use Tempest\View\ViewConfig;
 
@@ -35,64 +33,69 @@ public function setViewCompiler(TempestViewCompiler $compiler): self
         return $this;
     }
 
-    public function make(Node $node): ?Element
+    public function make(Token $token): ?Element
     {
         return $this->makeElement(
-            node: $node,
+            token: $token,
             parent: null,
         );
     }
 
-    private function makeElement(Node $node, ?Element $parent): ?Element
+    private function makeElement(Token $token, ?Element $parent): ?Element
     {
-        if ($node instanceof DocumentType) {
-            $content = $node->ownerDocument->saveHTML($node);
-
-            return new RawElement(tag: null, content: $content);
+        if (
+            $token->type === TokenType::OPEN_TAG_END ||
+                $token->type === TokenType::ATTRIBUTE_NAME ||
+                $token->type === TokenType::ATTRIBUTE_VALUE ||
+                $token->type === TokenType::SELF_CLOSING_TAG_END
+        ) {
+            return null;
         }
 
-        if ($node instanceof Text) {
-            if (trim($node->textContent) === '') {
+        if ($token->type === TokenType::CONTENT) {
+            $text = $token->compile();
+
+            if (trim($text) === '') {
                 return null;
             }
 
-            return new TextElement(
-                text: $node->textContent,
-            );
+            return new TextElement(text: $text);
         }
 
-        if ($node instanceof Comment) {
-            return new CommentElement(
-                content: $node->textContent,
-            );
+        if (! $token->tag || $token->type === TokenType::COMMENT || $token->type === TokenType::PHP) {
+            return new RawElement(tag: null, content: $token->compile());
         }
 
-        $tagName = strtolower($node->tagName);
-
         $attributes = [];
 
-        /** @var \Dom\Attr $attribute */
-        foreach ($node->attributes ?? [] as $attribute) {
-            $name = str($attribute->name)->camel()->toString();
+        foreach ($token->htmlAttributes as $name => $value) {
+            $name = str($name)
+                ->trim()
+                ->before('=')
+                ->camel()
+                ->toString();
 
-            $attributes[$name] = $attribute->value;
-        }
+            $value = str($value)
+                ->afterFirst('"')
+                ->beforeLast('"')
+                ->toString();
 
-        if (! ($node instanceof DomElement) || $tagName === 'pre' || $tagName === 'code') {
-            $content = '';
+            $attributes[$name] = $value;
+        }
 
-            foreach ($node->childNodes as $child) {
-                $content .= $node->ownerDocument->saveHTML($child);
-            }
+        foreach ($token->phpAttributes as $index => $content) {
+            $attributes[] = new PhpAttribute((string) $index, $content);
+        }
 
+        if ($token->tag === 'code' || $token->tag === 'pre') {
             return new RawElement(
-                tag: $tagName,
-                content: $content,
+                tag: $token->tag,
+                content: $token->compileChildren(),
                 attributes: $attributes,
             );
         }
 
-        if ($viewComponentClass = $this->viewConfig->viewComponents[$tagName] ?? null) {
+        if ($viewComponentClass = $this->viewConfig->viewComponents[$token->tag] ?? null) {
             if (! ($viewComponentClass instanceof ViewComponent)) {
                 $viewComponentClass = $this->container->get($viewComponentClass);
             }
@@ -103,27 +106,27 @@ private function makeElement(Node $node, ?Element $parent): ?Element
                 viewComponent: $viewComponentClass,
                 attributes: $attributes,
             );
-        } elseif ($tagName === 'x-template') {
+        } elseif ($token->tag === 'x-template') {
             $element = new TemplateElement(
                 attributes: $attributes,
             );
-        } elseif ($tagName === 'x-slot') {
+        } elseif ($token->tag === 'x-slot') {
             $element = new SlotElement(
-                name: $node->getAttribute('name') ?: 'slot',
+                name: $token->getAttribute('name') ?? 'slot',
                 attributes: $attributes,
             );
         } else {
             $element = new GenericElement(
-                tag: $tagName,
+                tag: $token->tag,
                 attributes: $attributes,
             );
         }
 
         $children = [];
 
-        foreach ($node->childNodes as $child) {
+        foreach ($token->children as $child) {
             $childElement = $this->clone()->makeElement(
-                node: $child,
+                token: $child,
                 parent: $parent,
             );