Optimize parser and renderer performance (~25-30% faster) (#47)

dereuromark · web-flow · commit 3aaed6decc5d · 2025-12-12T17:00:05.000+01:00
* Optimize parser and renderer performance (~25-30% faster)
diff --git a/src/Parser/BlockParser.php b/src/Parser/BlockParser.php
@@ -1910,31 +1910,31 @@ protected function tryParseDjotDefinitionList(Node $parent, array $lines, int $s
                 $def = new DefinitionDescription();
                 $defAttributes = [];
                 if ($defLines !== []) {
-                    // Remove leading blank lines
-                    while ($defLines !== [] && $defLines[0] === '') {
-                        array_shift($defLines);
+                    // Skip leading blank lines using index (avoid O(n) array_shift)
+                    $defStart = 0;
+                    $defLineCount = count($defLines);
+                    while ($defStart < $defLineCount && $defLines[$defStart] === '') {
+                        $defStart++;
                     }
                     // Remove trailing blank lines (but preserve potential attribute line)
-                    $defLineCount = count($defLines);
-                    while ($defLineCount > 1 && $defLines[$defLineCount - 1] === '') {
-                        array_pop($defLines);
-                        $defLineCount--;
+                    $defEnd = $defLineCount;
+                    while ($defEnd > $defStart + 1 && $defLines[$defEnd - 1] === '') {
+                        $defEnd--;
                     }
 
                     // Check if last line is a standalone attribute block for the dd
-                    $defLineCount = count($defLines);
-                    if ($defLineCount > 0 && preg_match('/^\{([^{}]+)\}\s*$/', $defLines[$defLineCount - 1], $attrMatch)) {
+                    if ($defEnd > $defStart && preg_match('/^\{([^{}]+)\}\s*$/', $defLines[$defEnd - 1], $attrMatch)) {
                         $defAttributes = AttributeParser::parse($attrMatch[1]);
-                        array_pop($defLines);
+                        $defEnd--;
                         // Remove any trailing blank lines before the attribute
-                        $defLineCount = count($defLines);
-                        while ($defLineCount > 0 && $defLines[$defLineCount - 1] === '') {
-                            array_pop($defLines);
-                            $defLineCount--;
+                        while ($defEnd > $defStart && $defLines[$defEnd - 1] === '') {
+                            $defEnd--;
                         }
                     }
 
-                    $this->parseBlocks($def, $defLines, 0);
+                    if ($defEnd > $defStart) {
+                        $this->parseBlocks($def, array_slice($defLines, $defStart, $defEnd - $defStart), 0);
+                    }
                 }
                 // Apply definition attributes
                 if ($defAttributes !== []) {
@@ -1971,12 +1971,15 @@ protected function splitByBlankLines(array $lines): array
         $blocks = [];
         $current = [];
 
-        // Remove leading blank lines
-        while ($lines !== [] && $lines[0] === '') {
-            array_shift($lines);
+        // Skip leading blank lines using index (avoid O(n) array_shift)
+        $start = 0;
+        $count = count($lines);
+        while ($start < $count && $lines[$start] === '') {
+            $start++;
         }
 
-        foreach ($lines as $line) {
+        for ($i = $start; $i < $count; $i++) {
+            $line = $lines[$i];
             if ($line === '') {
                 if ($current !== []) {
                     $blocks[] = $current;
diff --git a/src/Parser/InlineParser.php b/src/Parser/InlineParser.php
@@ -52,6 +52,18 @@ class InlineParser
      */
     protected array $customPatterns = [];
 
+    /**
+     * Cached abbreviation regex pattern (built once per document)
+     */
+    protected ?string $abbreviationPattern = null;
+
+    /**
+     * Cached abbreviation keys for the current pattern
+     *
+     * @var array<string, string>|null
+     */
+    protected ?array $cachedAbbreviations = null;
+
     public function __construct(protected BlockParser $blockParser)
     {
     }
@@ -449,16 +461,23 @@ protected function flushText(Node $parent, string $text): void
      */
     protected function flushTextWithAbbreviations(Node $parent, string $text, array $abbreviations): void
     {
-        // Sort abbreviations by length (longest first) to match longer abbreviations first
-        $abbrKeys = array_keys($abbreviations);
-        usort($abbrKeys, fn ($a, $b) => strlen($b) - strlen($a));
+        // Cache the regex pattern for abbreviations (built once per document)
+        if ($this->cachedAbbreviations !== $abbreviations) {
+            // Sort abbreviations by length (longest first) to match longer abbreviations first
+            $abbrKeys = array_keys($abbreviations);
+            usort($abbrKeys, fn ($a, $b) => strlen($b) - strlen($a));
 
-        // Build a regex pattern that matches any abbreviation at word boundaries
-        // We need to escape special regex characters in abbreviation keys
-        $escapedKeys = array_map(fn ($key) => preg_quote($key, '/'), $abbrKeys);
-        $pattern = '/\b(' . implode('|', $escapedKeys) . ')\b/u';
+            // Build a regex pattern that matches any abbreviation at word boundaries
+            // We need to escape special regex characters in abbreviation keys
+            $escapedKeys = array_map(fn ($key) => preg_quote($key, '/'), $abbrKeys);
+            $this->abbreviationPattern = '/\b(' . implode('|', $escapedKeys) . ')\b/u';
+            $this->cachedAbbreviations = $abbreviations;
+        }
 
         // Split text by abbreviation matches, keeping the delimiters
+        // Pattern is guaranteed to be set at this point
+        /** @var string $pattern */
+        $pattern = $this->abbreviationPattern;
         $parts = preg_split($pattern, $text, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
 
         if ($parts === false) {
diff --git a/src/Renderer/HtmlRenderer.php b/src/Renderer/HtmlRenderer.php
@@ -101,8 +101,67 @@ class HtmlRenderer implements RendererInterface
      */
     protected array $collectedFootnotes = [];
 
+    /**
+     * Dispatch table mapping node class names to render method names
+     *
+     * @var array<class-string<\Djot\Node\Node>, string>
+     */
+    protected array $nodeRenderers = [];
+
     public function __construct(protected bool $xhtml = false)
     {
+        $this->initNodeRenderers();
+    }
+
+    /**
+     * Initialize the node renderer dispatch table
+     *
+     * Maps node class names to render method names for O(1) lookup.
+     */
+    protected function initNodeRenderers(): void
+    {
+        $this->nodeRenderers = [
+            Document::class => 'renderChildren',
+            Paragraph::class => 'renderParagraph',
+            Heading::class => 'renderHeading',
+            CodeBlock::class => 'renderCodeBlock',
+            Comment::class => '',
+            RawBlock::class => 'renderRawBlock',
+            BlockQuote::class => 'renderBlockQuote',
+            DefinitionList::class => 'renderDefinitionList',
+            DefinitionTerm::class => 'renderDefinitionTerm',
+            DefinitionDescription::class => 'renderDefinitionDescription',
+            ListBlock::class => 'renderList',
+            ListItem::class => 'renderListItem',
+            ThematicBreak::class => 'renderThematicBreak',
+            Div::class => 'renderDiv',
+            Figure::class => 'renderFigure',
+            Caption::class => 'renderCaption',
+            Table::class => 'renderTable',
+            TableRow::class => 'renderTableRow',
+            TableCell::class => 'renderTableCell',
+            LineBlock::class => 'renderLineBlock',
+            Footnote::class => 'renderFootnote',
+            Text::class => 'renderText',
+            Emphasis::class => 'renderEmphasis',
+            Strong::class => 'renderStrong',
+            Link::class => 'renderLink',
+            Image::class => 'renderImage',
+            Code::class => 'renderCode',
+            RawInline::class => 'renderRawInline',
+            Math::class => 'renderMath',
+            Symbol::class => 'renderSymbol',
+            FootnoteRef::class => 'renderFootnoteRef',
+            SoftBreak::class => 'renderSoftBreak',
+            HardBreak::class => 'renderHardBreak',
+            Span::class => 'renderSpan',
+            Highlight::class => 'renderHighlight',
+            Superscript::class => 'renderSuperscript',
+            Subscript::class => 'renderSubscript',
+            Insert::class => 'renderInsert',
+            Delete::class => 'renderDelete',
+            Abbreviation::class => 'renderAbbreviation',
+        ];
     }
 
     /**
@@ -362,64 +421,36 @@ protected function renderAttributesExcluding(Node $node, array $exclude): string
 
     protected function renderNode(Node $node): string
     {
-        // Dispatch render event
-        $eventName = 'render.' . $node->getType();
-        $event = new RenderEvent($node);
+        // Only dispatch events if listeners are registered (avoid object allocation)
+        if ($this->hasAnyListeners()) {
+            $eventName = 'render.' . $node->getType();
+            $event = new RenderEvent($node);
 
-        // Call specific listeners
-        $this->dispatchEvent($eventName, $event);
+            // Call specific listeners
+            $this->dispatchEvent($eventName, $event);
 
-        // Call wildcard listeners
-        $this->dispatchEvent('render.*', $event);
+            // Call wildcard listeners
+            $this->dispatchEvent('render.*', $event);
 
-        // If listener provided custom HTML, use it
-        if ($event->isDefaultPrevented()) {
-            return $event->getHtml() ?? '';
+            // If listener provided custom HTML, use it
+            if ($event->isDefaultPrevented()) {
+                return $event->getHtml() ?? '';
+            }
         }
 
-        return match (true) {
-            $node instanceof Document => $this->renderChildren($node),
-            $node instanceof Paragraph => $this->renderParagraph($node),
-            $node instanceof Heading => $this->renderHeading($node),
-            $node instanceof CodeBlock => $this->renderCodeBlock($node),
-            $node instanceof Comment => '', // Comments are stripped from output
-            $node instanceof RawBlock => $this->renderRawBlock($node),
-            $node instanceof BlockQuote => $this->renderBlockQuote($node),
-            $node instanceof DefinitionList => $this->renderDefinitionList($node),
-            $node instanceof DefinitionTerm => $this->renderDefinitionTerm($node),
-            $node instanceof DefinitionDescription => $this->renderDefinitionDescription($node),
-            $node instanceof ListBlock => $this->renderList($node),
-            $node instanceof ListItem => $this->renderListItem($node),
-            $node instanceof ThematicBreak => $this->renderThematicBreak($node),
-            $node instanceof Div => $this->renderDiv($node),
-            $node instanceof Figure => $this->renderFigure($node),
-            $node instanceof Caption => $this->renderCaption($node),
-            $node instanceof Table => $this->renderTable($node),
-            $node instanceof TableRow => $this->renderTableRow($node),
-            $node instanceof TableCell => $this->renderTableCell($node),
-            $node instanceof LineBlock => $this->renderLineBlock($node),
-            $node instanceof Footnote => $this->renderFootnote($node),
-            $node instanceof Text => $this->renderText($node),
-            $node instanceof Emphasis => $this->renderEmphasis($node),
-            $node instanceof Strong => $this->renderStrong($node),
-            $node instanceof Link => $this->renderLink($node),
-            $node instanceof Image => $this->renderImage($node),
-            $node instanceof Code => $this->renderCode($node),
-            $node instanceof RawInline => $this->renderRawInline($node),
-            $node instanceof Math => $this->renderMath($node),
-            $node instanceof Symbol => $this->renderSymbol($node),
-            $node instanceof FootnoteRef => $this->renderFootnoteRef($node),
-            $node instanceof SoftBreak => $this->renderSoftBreak(),
-            $node instanceof HardBreak => $this->renderHardBreak(),
-            $node instanceof Span => $this->renderSpan($node),
-            $node instanceof Highlight => $this->renderHighlight($node),
-            $node instanceof Superscript => $this->renderSuperscript($node),
-            $node instanceof Subscript => $this->renderSubscript($node),
-            $node instanceof Insert => $this->renderInsert($node),
-            $node instanceof Delete => $this->renderDelete($node),
-            $node instanceof Abbreviation => $this->renderAbbreviation($node),
-            default => $this->renderChildren($node),
-        };
+        // Use dispatch table for O(1) lookup instead of instanceof chain
+        $class = $node::class;
+        if (isset($this->nodeRenderers[$class])) {
+            $method = $this->nodeRenderers[$class];
+            if ($method === '') {
+                return ''; // Comment nodes
+            }
+
+            /** @var string */
+            return $this->$method($node);
+        }
+
+        return $this->renderChildren($node);
     }
 
     protected function renderChildren(Node $node): string
diff --git a/src/Renderer/Utility/EventDispatcherTrait.php b/src/Renderer/Utility/EventDispatcherTrait.php
@@ -51,6 +51,14 @@ public function off(?string $event = null): void
         }
     }
 
+    /**
+     * Check if there are any listeners registered for any render event
+     */
+    protected function hasAnyListeners(): bool
+    {
+        return $this->listeners !== [];
+    }
+
     /**
      * Dispatch an event to all registered listeners
      *

Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,14 @@ public function off(?string $event = null): void`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
	`54`	`+ /**`
	`55`	`+ * Check if there are any listeners registered for any render event`
	`56`	`+ */`
	`57`	`+ protected function hasAnyListeners(): bool`
	`58`	`+ {`
	`59`	`+ return $this->listeners !== [];`
	`60`	`+ }`
	`61`	`+`
`54`	`62`	`/**`
`55`	`63`	`* Dispatch an event to all registered listeners`
`56`	`64`	`*`