Optimize parsers: O(n^2) -> O(n) offset calculation, plus micro-opts

RegexParser and WordpressParser recomputed each match's character offset
with mb_strlen(substr($text, 0, $match[1])), rescanning the whole prefix
for every match, which is O(n^2) in the number of shortcodes. Accumulate
the character offset incrementally instead, measuring only the new segment
since the previous match. Matches come back in ascending offset order, so
the running total stays exact.

On a 504 KB document with 1,500 shortcodes:

  RegexParser      223.5 ms -> 3.4 ms   (66x)
  WordpressParser  221.7 ms -> 1.0 ms   (222x)

Also:
- replace the hand-rolled per-character backslash escaping with preg_quote()
  in RegularParser and RegexBuilderUtility,
- drop a no-op array_filter() in RegexParser::parse() (parseSingle() never
  returns null),
- iterate replacements with a reverse for-loop instead of allocating an
  array_reverse() copy in Processor,
- short-circuit the Shortcode parameter-type check on the first invalid
  value instead of array_filter over all of them.

No behavior change: the full test suite passes (288 tests, 2256 assertions).

Author: rhukster

src/Parser/RegexParser.php

@@ -20,6 +20,12 @@ final class RegexParser implements ParserInterface
     private $singleShortcodeRegex;
     /** @var non-empty-string */
     private $parametersRegex;
+    /** @var non-empty-string */
+    private $parameterValueSeparator;
+    /** @var non-empty-string */
+    private $parameterValueDelimiter;
+    /** @var int */
+    private $parameterValueDelimiterLength;
 
     /** @param SyntaxInterface|null $syntax */
     public function __construct($syntax = null)
@@ -32,6 +38,9 @@ public function __construct($syntax = null)
         $this->shortcodeRegex = RegexBuilderUtility::buildShortcodeRegex($this->syntax);
         $this->singleShortcodeRegex = RegexBuilderUtility::buildSingleShortcodeRegex($this->syntax);
         $this->parametersRegex = RegexBuilderUtility::buildParametersRegex($this->syntax);
+        $this->parameterValueSeparator = $this->syntax->getParameterValueSeparator();
+        $this->parameterValueDelimiter = $this->syntax->getParameterValueDelimiter();
+        $this->parameterValueDelimiterLength = strlen($this->parameterValueDelimiter);
     }
 
     /**
@@ -45,13 +54,19 @@ public function parse($text)
 
         // loop instead of array_map to pass the arguments explicitly
         $shortcodes = array();
+        $lastByteOffset = 0;
+        $lastCharacterOffset = 0;
         foreach($matches[0] as $match) {
             /** @psalm-suppress PossiblyFalseArgument */
-            $offset = mb_strlen(substr($text, 0, $match[1]), 'utf-8');
+            if($match[1] > $lastByteOffset) {
+                $lastCharacterOffset += mb_strlen(substr($text, $lastByteOffset, $match[1] - $lastByteOffset), 'utf-8');
+                $lastByteOffset = $match[1];
+            }
+            $offset = $lastCharacterOffset;
             $shortcodes[] = $this->parseSingle($match[0], $offset);
         }
 
-        return array_filter($shortcodes);
+        return $shortcodes;
     }
 
     /**
@@ -88,7 +103,7 @@ private function parseParameters($text)
         $return = array();
         foreach ($argsMatches[1] as $item) {
             /** @psalm-var array{0:string,1:string} $parts */
-            $parts = explode($this->syntax->getParameterValueSeparator(), $item, 2);
+            $parts = explode($this->parameterValueSeparator, $item, 2);
             $return[trim($parts[0])] = $this->parseValue(isset($parts[1]) ? $parts[1] : null);
         }
 
@@ -113,10 +128,8 @@ private function parseValue($value)
      */
     private function extractValue($value)
     {
-        $length = strlen($this->syntax->getParameterValueDelimiter());
-
         /** @psalm-suppress FalsableReturnStatement */
-        return $this->isDelimitedValue($value) ? substr($value, $length, -1 * $length) : $value;
+        return $this->isDelimitedValue($value) ? substr($value, $this->parameterValueDelimiterLength, -1 * $this->parameterValueDelimiterLength) : $value;
     }
 
     /**
@@ -126,7 +139,8 @@ private function extractValue($value)
      */
     private function isDelimitedValue($value)
     {
-        return preg_match('/^'.$this->syntax->getParameterValueDelimiter().'/us', $value)
-            && preg_match('/'.$this->syntax->getParameterValueDelimiter().'$/us', $value);
+        return strlen($value) >= 2 * $this->parameterValueDelimiterLength
+            && 0 === strncmp($value, $this->parameterValueDelimiter, $this->parameterValueDelimiterLength)
+            && substr($value, -1 * $this->parameterValueDelimiterLength) === $this->parameterValueDelimiter;
     }
 }

src/Parser/RegularParser.php

@@ -386,11 +386,11 @@ private function prepareLexer(SyntaxInterface $syntax)
         // FIXME: for some reason Psalm does not understand the `@psalm-var callable() $var` annotation
         /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType,PossiblyNullOperand */
         $group = function($text, $group) {
-            return '(?<'.(string)$group.'>'.preg_replace('/(.)/us', '\\\\$0', (string)$text).')';
+            return '(?<'.(string)$group.'>'.preg_quote((string)$text, '~').')';
         };
         /** @psalm-suppress MissingClosureParamType,MissingClosureReturnType */
         $quote = function($text) {
-            return preg_replace('/(.)/us', '\\\\$0', (string)$text);
+            return preg_quote((string)$text, '~');
         };
 
         $rules = array(

src/Parser/WordpressParser.php

@@ -83,12 +83,19 @@ public function parse($text)
 
         $shortcodes = array();
         $count = count($matches[0]);
+        $lastByteOffset = 0;
+        $lastCharacterOffset = 0;
         for($i = 0; $i < $count; $i++) {
             $name = $matches[2][$i][0];
             $parameters = static::parseParameters($matches[3][$i][0]);
             $content = $matches[5][$i][1] !== -1 ? $matches[5][$i][0] : null;
             $match = $matches[0][$i][0];
-            $offset = mb_strlen(substr($text, 0, $matches[0][$i][1]), 'utf-8');
+            $byteOffset = $matches[0][$i][1];
+            if($byteOffset > $lastByteOffset) {
+                $lastCharacterOffset += mb_strlen(substr($text, $lastByteOffset, $byteOffset - $lastByteOffset), 'utf-8');
+                $lastByteOffset = $byteOffset;
+            }
+            $offset = $lastCharacterOffset;
 
             $shortcode = new Shortcode($name, $parameters, $content, null);
             $shortcodes[] = new ParsedShortcode($shortcode, $match, $offset);

src/Processor/Processor.php

@@ -140,7 +140,8 @@ private function processIteration($text, ProcessorContext $context, $parent = nu
      */
     private function applyReplaces($text, array $replaces)
     {
-        foreach(array_reverse($replaces) as $s) {
+        for($i = count($replaces) - 1; $i >= 0; $i--) {
+            $s = $replaces[$i];
             $offset = $s->getOffset();
             $length = mb_strlen($s->getText(), 'utf-8');
             $textLength = mb_strlen($text, 'utf-8');
@@ -170,7 +171,9 @@ private function processHandler(ParsedShortcodeInterface $parsed, ProcessorConte
         $length = (int)mb_strlen($processed->getTextContent(), 'utf-8');
         $offset = (int)mb_strrpos($state, $processed->getTextContent(), 0, 'utf-8');
 
-        return mb_substr($state, 0, $offset, 'utf-8').(string)$processed->getContent().mb_substr($state, $offset + $length, mb_strlen($state, 'utf-8'), 'utf-8');
+        $stateLength = mb_strlen($state, 'utf-8');
+
+        return mb_substr($state, 0, $offset, 'utf-8').(string)$processed->getContent().mb_substr($state, $offset + $length, $stateLength, 'utf-8');
     }
 
     /** @return string|null */

src/Shortcode/Shortcode.php

@@ -20,10 +20,11 @@ public function __construct($name, array $parameters, $content, $bbCode = null)
             throw new \InvalidArgumentException('Shortcode name must be a non-empty string!');
         }
 
-        /** @psalm-suppress MissingClosureParamType, MissingClosureReturnType */
-        $isStringOrNull = function($value) { return is_string($value) || null === $value; };
-        if(count(array_filter($parameters, $isStringOrNull)) !== count($parameters)) {
-            throw new \InvalidArgumentException('Parameter values must be either string or empty (null)!');
+        foreach($parameters as $value) {
+            /** @psalm-suppress DocblockTypeContradiction, RedundantConditionGivenDocblockType */
+            if(false === is_string($value) && null !== $value) {
+                throw new \InvalidArgumentException('Parameter values must be either string or empty (null)!');
+            }
         }
 
         $this->name = $name;

src/Utility/RegexBuilderUtility.php

@@ -91,7 +91,7 @@ private static function createShortcodeRegexContent(SyntaxInterface $syntax)
     private static function quote($text)
     {
         /** @var non-empty-string $quoted */
-        $quoted = preg_replace('/(.)/us', '\\\\$0', $text);
+        $quoted = preg_quote($text, '~');
 
         return $quoted;
     }