Implemented REWRITE_REPLACEMENTS event

src/Event/RewriteReplacementsEvent.php

@@ -0,0 +1,48 @@
+<?php
+namespace Thunder\Shortcode\Event;
+
+use Thunder\Shortcode\Shortcode\ReplacedShortcode;
+use Thunder\Shortcode\Shortcode\ShortcodeInterface;
+
+/**
+ * This event is called after gathering shortcode handlers results and just
+ * before the REPLACE_SHORTCODES event to allow modification of replacements
+ * before applying them in the source text.
+ *
+ * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ */
+final class RewriteReplacementsEvent
+{
+    /** @var ReplacedShortcode[] */
+    private $replacements;
+    /** @var ReplacedShortcode[] */
+    private $rewritten = array();
+    /** @var bool */
+    private $called = false;
+
+    /** @param ReplacedShortcode[] $replacements */
+    public function __construct(array $replacements)
+    {
+        $this->replacements = $replacements;
+    }
+
+    /** @return ReplacedShortcode[] */
+    public function getReplacements()
+    {
+        $this->called = true;
+
+        return $this->replacements;
+    }
+
+    /** @return void */
+    public function addRewritten(ReplacedShortcode $replacement)
+    {
+        $this->rewritten[] = $replacement;
+    }
+
+    /** @return ReplacedShortcode[] */
+    public function getRewritten()
+    {
+        return $this->called ? $this->rewritten : $this->replacements;
+    }
+}

src/EventHandler/RewriteWrapEventHandler.php

@@ -0,0 +1,32 @@
+<?php
+namespace Thunder\Shortcode\EventHandler;
+
+use Thunder\Shortcode\Event\RewriteReplacementsEvent;
+
+/**
+ * @author Tomasz Kowalczyk <tomasz@kowalczyk.cc>
+ */
+final class RewriteWrapEventHandler
+{
+    /** @var string */
+    private $prefix;
+    /** @var string */
+    private $suffix;
+
+    /**
+     * @param string $prefix
+     * @param string $suffix
+     */
+    public function __construct($prefix, $suffix)
+    {
+        $this->prefix = $prefix;
+        $this->suffix = $suffix;
+    }
+
+    public function __invoke(RewriteReplacementsEvent $event)
+    {
+        foreach($event->getReplacements() as $replacement) {
+            $event->addRewritten($replacement->withReplacement($this->prefix.$replacement->getReplacement().$this->suffix));
+        }
+    }
+}

src/Events.php

@@ -8,10 +8,11 @@ final class Events
 {
     const FILTER_SHORTCODES = 'event.filter-shortcodes';
     const REPLACE_SHORTCODES = 'event.replace-shortcodes';
+    const REWRITE_REPLACEMENTS = 'event.rewrite-replacements';
 
     /** @return string[] */
     public static function getEvents()
     {
-        return array(static::FILTER_SHORTCODES, static::REPLACE_SHORTCODES);
+        return array(static::FILTER_SHORTCODES, static::REPLACE_SHORTCODES, static::REWRITE_REPLACEMENTS);
     }
 }

src/Processor/Processor.php

@@ -3,6 +3,7 @@
 
 use Thunder\Shortcode\Event\ReplaceShortcodesEvent;
 use Thunder\Shortcode\Event\FilterShortcodesEvent;
+use Thunder\Shortcode\Event\RewriteReplacementsEvent;
 use Thunder\Shortcode\EventContainer\EventContainerInterface;
 use Thunder\Shortcode\Events;
 use Thunder\Shortcode\HandlerContainer\HandlerContainerInterface as Handlers;
@@ -122,6 +123,9 @@ private function processIteration($text, ProcessorContext $context, ProcessedSho
             $replaces[] = new ReplacedShortcode($shortcode, $replace);
         }
 
+        $rewriteEvent = new RewriteReplacementsEvent($replaces);
+        $this->dispatchEvent(Events::REWRITE_REPLACEMENTS, $rewriteEvent);
+        $replaces = $rewriteEvent->getRewritten();
         $applyEvent = new ReplaceShortcodesEvent($text, $replaces, $parent);
         $this->dispatchEvent(Events::REPLACE_SHORTCODES, $applyEvent);
 

src/Shortcode/ReplacedShortcode.php

@@ -26,6 +26,19 @@ public function __construct(ParsedShortcodeInterface $shortcode, $replacement)
         $this->replacement = $replacement;
     }
 
+    /**
+     * @param string $replacement
+     *
+     * @return self
+     */
+    public function withReplacement($replacement)
+    {
+        $base = new Shortcode($this->name, $this->parameters, $this->content, $this->bbCode);
+        $parsed = new ParsedShortcode($base, $this->text, $this->offset);
+
+        return new self($parsed, $replacement);
+    }
+
     /** @return string */
     public function getReplacement()
     {

tests/EventsTest.php

@@ -5,6 +5,7 @@
 use Thunder\Shortcode\EventContainer\EventContainer;
 use Thunder\Shortcode\EventHandler\FilterRawEventHandler;
 use Thunder\Shortcode\EventHandler\ReplaceJoinEventHandler;
+use Thunder\Shortcode\EventHandler\RewriteWrapEventHandler;
 use Thunder\Shortcode\Events;
 use Thunder\Shortcode\HandlerContainer\HandlerContainer;
 use Thunder\Shortcode\Parser\RegularParser;
@@ -76,6 +77,22 @@ public function testDefaultApplier()
         $this->assertSame('a root[x name c name  y] b', $processor->process('a [root]x [name] c[content] [name /] [/content] y[/root] b'));
     }
 
+    public function testRewriteReplacements()
+    {
+        $handlers = new HandlerContainer();
+        $handlers->add('name', function(ShortcodeInterface $s) { return $s->getName(); });
+        $handlers->add('content', function(ShortcodeInterface $s) { return $s->getContent(); });
+        $handlers->add('root', function(ProcessedShortcode $s) { return 'root['.$s->getContent().']'; });
+
+        $events = new EventContainer();
+        $events->addListener(Events::REWRITE_REPLACEMENTS, new RewriteWrapEventHandler('>', '<'));
+
+        $processor = new Processor(new RegularParser(), $handlers);
+        $processor = $processor->withEventContainer($events);
+
+        $this->assertSame('a >root[x >name< c> >name< < y]< b', $processor->process('a [root]x [name] c[content] [name /] [/content] y[/root] b'));
+    }
+
     public function testExceptionOnHandlerForUnknownEvent()
     {
         $events = new EventContainer();