implemented iterative shortcode processing, added tests

Author: thunderer

src/Processor.php

@@ -11,6 +11,7 @@ final class Processor implements ProcessorInterface
     private $parser;
     private $defaultHandler;
     private $recursionDepth = null;
+    private $maxIterations = 1;
 
     public function __construct(ExtractorInterface $extractor, ParserInterface $parser)
         {
@@ -74,17 +75,42 @@ public function setDefaultHandler(callable $handler)
         $this->defaultHandler = $handler;
         }
 
+    /**
+     * Entry point for shortcode processing. Implements iterative algorithm for
+     * both limited and unlimited number of iterations.
+     *
+     * @param string $text Text to process
+     *
+     * @return string
+     */
+    public function process($text)
+        {
+        $iterations = $this->maxIterations === null ? 1 : $this->maxIterations;
+        while($iterations--)
+            {
+            $newText = $this->processIteration($text, 0);
+            if($newText === $text)
+                {
+                break;
+                }
+            $text = $newText;
+            $iterations += $this->maxIterations === null ? 1 : 0;
+            }
+
+        return $text;
+        }
+
     /**
      * Expects matches sorted by position returned from Extractor. Matches are
      * processed from the last to the first to avoid replace position errors.
      * Edge cases are described in README.
      *
-     * @param string $text
-     * @param int $level
+     * @param string $text Current text state
+     * @param int $level Current recursion depth level
      *
      * @return string
      */
-    public function process($text, $level = 0)
+    private function processIteration($text, $level)
         {
         if(null !== $this->recursionDepth && $level > $this->recursionDepth)
             {
@@ -93,12 +119,11 @@ public function process($text, $level = 0)
 
         /** @var $matches Match[] */
         $matches = array_reverse($this->extractor->extract($text));
-
         foreach($matches as $match)
             {
             $shortcode = $this->parser->parse($match->getString());
             $content = $shortcode->hasContent()
-                ? $this->process($shortcode->getContent(), $level + 1)
+                ? $this->processIteration($shortcode->getContent(), $level + 1)
                 : $shortcode->getContent();
             $shortcode = new Shortcode($shortcode->getName(), $shortcode->getParameters(), $content);
             $handler = $this->getHandler($shortcode->getName());
@@ -133,6 +158,27 @@ public function setRecursionDepth($depth)
         return $this;
         }
 
+    /**
+     * Maximum number of iterations, null means infinite, any integer greater
+     * than or equal to zero sets value.
+     *
+     * @param int|null $iterations
+     *
+     * @return self
+     */
+    public function setMaxIterations($iterations)
+        {
+        if(null !== $iterations && !(is_int($iterations) && $iterations >= 0))
+            {
+            $msg = 'Maximum number of iterations must be null (infinite) or integer >= 0!';
+            throw new \InvalidArgumentException($msg);
+            }
+
+        $this->maxIterations = $iterations;
+
+        return $this;
+        }
+
     /**
      * @deprecated Use self::setRecursionDepth() instead
      *

tests/ProcessorTest.php

@@ -63,6 +63,23 @@ public function testProcessorWithoutRecursion()
         $this->assertSame('x a-[name][/name]-b y', $result);
         }
 
+    public function testProcessorIterative()
+        {
+        $processor = $this
+            ->getProcessor()
+            ->addHandlerAlias('d', 'c')
+            ->addHandlerAlias('e', 'c')
+            ->setRecursion(false);
+
+        $processor->setMaxIterations(2);
+        $this->assertSame('x a y', $processor->process('x [c]a[/c] y'));
+        $this->assertSame('x abc y', $processor->process('x [c]a[d]b[/d]c[/c] y'));
+        $this->assertSame('x ab[e]c[/e]de y', $processor->process('x [c]a[d]b[e]c[/e]d[/d]e[/c] y'));
+
+        $processor->setMaxIterations(null);
+        $this->assertSame('x abcde y', $processor->process('x [c]a[d]b[e]c[/e]d[/d]e[/c] y'));
+        }
+
     public function testExceptionOnInvalidHandler()
         {
         $processor = $this->getProcessor();
@@ -91,4 +108,18 @@ public function testExceptionOnInvalidRecursionDepth()
         $this->setExpectedException('InvalidArgumentException');
         $processor->setRecursionDepth(new \stdClass());
         }
+
+    public function testPreventInfiniteLoop()
+        {
+        $processor = $this
+            ->getProcessor()
+            ->addHandler('self', function(Shortcode $s) { return '[self]'; })
+            ->addHandler('other', function(Shortcode $s) { return '[self]'; })
+            ->addHandler('random', function(Shortcode $s) { return '[various]'; })
+            ->setMaxIterations(null);
+
+        $processor->process('[self]');
+        $processor->process('[other]');
+        $processor->process('[random]');
+        }
     }