Move new emphasis rule into DelimiterProcessor (extension api break)

The "multiple of 3" rule was breaking the strikethrough extension logic.

By passing more information into getDelimiterUse and allowing the
implementation to return 0, we can move the "multiple of 3" rule into
the delimiter processor.

For the strikethrough delimiter processor, we can have different rules
and simplify the implementation. It's now also closer to GFM.

Also clean up the other method names a bit while we are breaking the
API:

* getOpeningDelimiterChar -> getOpeningCharacter
* getClosingDelimiterChar -> getClosingCharacter
* getMinDelimiterCount -> getMinLength

Author: robinst

commonmark-ext-gfm-strikethrough/src/main/java/org/commonmark/ext/gfm/strikethrough/internal/StrikethroughDelimiterProcessor.java

@@ -3,47 +3,39 @@
 import org.commonmark.ext.gfm.strikethrough.Strikethrough;
 import org.commonmark.node.Node;
 import org.commonmark.node.Text;
-import org.commonmark.parser.DelimiterProcessor;
+import org.commonmark.parser.delimiter.DelimiterProcessor;
+import org.commonmark.parser.delimiter.DelimiterRun;
 
 public class StrikethroughDelimiterProcessor implements DelimiterProcessor {
 
     @Override
-    public char getOpeningDelimiterChar() {
+    public char getOpeningCharacter() {
         return '~';
     }
 
     @Override
-    public char getClosingDelimiterChar() {
+    public char getClosingCharacter() {
         return '~';
     }
 
     @Override
-    public int getMinDelimiterCount() {
+    public int getMinLength() {
         return 2;
     }
 
     @Override
-    public int getDelimiterUse(int openerCount, int closerCount) {
-        if (openerCount >= 2 && closerCount >= 2) {
+    public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
+        if (opener.length() >= 2 && closer.length() >= 2) {
+            // Use exactly two delimiters even if we have more, and don't care about internal openers/closers.
             return 2;
         } else {
-            // Can happen if a run had 3 delimiters before, and we removed 2 of them in an earlier processing step.
-            // So just use 1 of them, see corresponding handling in process method.
-            return 1;
+            return 0;
         }
     }
 
     @Override
     public void process(Text opener, Text closer, int delimiterCount) {
-        // Can happen if a run had 3 or more delimiters, so 1 is left over. Don't turn that into strikethrough, but
-        // preserve original character.
-        if (delimiterCount == 1) {
-            opener.insertAfter(new Text("~"));
-            closer.insertBefore(new Text("~"));
-            return;
-        }
-
-        // Normal case, wrap nodes between delimiters in strikethrough.
+        // Wrap nodes between delimiters in strikethrough.
         Node strikethrough = new Strikethrough();
 
         Node tmp = opener.getNext();

commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughTest.java

@@ -50,8 +50,14 @@ public void twoInnerThree() {
     }
 
     @Test
-    public void twoStrikethroughsWithoutSpacing() {
+    public void tildesInside() {
+        assertRendering("~~foo~bar~~", "<p><del>foo~bar</del></p>\n");
+        assertRendering("~~foo~~bar~~", "<p><del>foo</del>bar~~</p>\n");
+        assertRendering("~~foo~~~bar~~", "<p><del>foo</del>~bar~~</p>\n");
         assertRendering("~~foo~~~~bar~~", "<p><del>foo</del><del>bar</del></p>\n");
+        assertRendering("~~foo~~~~~bar~~", "<p><del>foo</del>~<del>bar</del></p>\n");
+        assertRendering("~~foo~~~~~~bar~~", "<p><del>foo</del>~~<del>bar</del></p>\n");
+        assertRendering("~~foo~~~~~~~bar~~", "<p><del>foo</del>~~~<del>bar</del></p>\n");
     }
 
     @Test

commonmark/src/main/java/org/commonmark/internal/Delimiter.java

@@ -1,11 +1,12 @@
 package org.commonmark.internal;
 
 import org.commonmark.node.Text;
+import org.commonmark.parser.delimiter.DelimiterRun;
 
 /**
  * Delimiter (emphasis, strong emphasis or custom emphasis).
  */
-class Delimiter {
+class Delimiter implements DelimiterRun {
 
     final Text node;
     final char delimiterChar;
@@ -32,4 +33,19 @@ class Delimiter {
         this.canClose = canClose;
         this.previous = previous;
     }
+
+    @Override
+    public boolean canOpen() {
+        return canOpen;
+    }
+
+    @Override
+    public boolean canClose() {
+        return canClose;
+    }
+
+    @Override
+    public int length() {
+        return numDelims;
+    }
 }

commonmark/src/main/java/org/commonmark/internal/DelimiterRun.java

@@ -6,7 +6,7 @@
 import org.commonmark.internal.util.Html5Entities;
 import org.commonmark.internal.util.Parsing;
 import org.commonmark.node.*;
-import org.commonmark.parser.DelimiterProcessor;
+import org.commonmark.parser.delimiter.DelimiterProcessor;
 import org.commonmark.parser.InlineParser;
 
 import java.util.*;
@@ -134,9 +134,9 @@ public static Map<Character, DelimiterProcessor> calculateDelimiterProcessors(Li
 
     private static void addDelimiterProcessors(Iterable<DelimiterProcessor> delimiterProcessors, Map<Character, DelimiterProcessor> map) {
         for (DelimiterProcessor delimiterProcessor : delimiterProcessors) {
-            char opening = delimiterProcessor.getOpeningDelimiterChar();
+            char opening = delimiterProcessor.getOpeningCharacter();
             addDelimiterProcessorForChar(opening, delimiterProcessor, map);
-            char closing = delimiterProcessor.getClosingDelimiterChar();
+            char closing = delimiterProcessor.getClosingCharacter();
             if (opening != closing) {
                 addDelimiterProcessorForChar(closing, delimiterProcessor, map);
             }
@@ -430,7 +430,7 @@ private boolean parseBackticks() {
      * Attempt to parse delimiters like emphasis, strong emphasis or custom delimiters.
      */
     private boolean parseDelimiters(DelimiterProcessor delimiterProcessor, char delimiterChar) {
-        DelimiterRun res = scanDelimiters(delimiterProcessor, delimiterChar);
+        DelimiterData res = scanDelimiters(delimiterProcessor, delimiterChar);
         if (res == null) {
             return false;
         }
@@ -727,7 +727,7 @@ private boolean parseString() {
      *
      * @return information about delimiter run, or {@code null}
      */
-    private DelimiterRun scanDelimiters(DelimiterProcessor delimiterProcessor, char delimiterChar) {
+    private DelimiterData scanDelimiters(DelimiterProcessor delimiterProcessor, char delimiterChar) {
         int startIndex = index;
 
         int delimiterCount = 0;
@@ -736,7 +736,7 @@ private DelimiterRun scanDelimiters(DelimiterProcessor delimiterProcessor, char
             index++;
         }
 
-        if (delimiterCount < delimiterProcessor.getMinDelimiterCount()) {
+        if (delimiterCount < delimiterProcessor.getMinLength()) {
             index = startIndex;
             return null;
         }
@@ -764,12 +764,12 @@ private DelimiterRun scanDelimiters(DelimiterProcessor delimiterProcessor, char
             canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
             canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
         } else {
-            canOpen = leftFlanking && delimiterChar == delimiterProcessor.getOpeningDelimiterChar();
-            canClose = rightFlanking && delimiterChar == delimiterProcessor.getClosingDelimiterChar();
+            canOpen = leftFlanking && delimiterChar == delimiterProcessor.getOpeningCharacter();
+            canClose = rightFlanking && delimiterChar == delimiterProcessor.getClosingCharacter();
         }
 
         index = startIndex;
-        return new DelimiterRun(delimiterCount, canOpen, canClose);
+        return new DelimiterData(delimiterCount, canOpen, canClose);
     }
 
     private void processDelimiters(Delimiter stackBottom) {
@@ -791,17 +791,18 @@ private void processDelimiters(Delimiter stackBottom) {
                 continue;
             }
 
-            char openingDelimiterChar = delimiterProcessor.getOpeningDelimiterChar();
+            char openingDelimiterChar = delimiterProcessor.getOpeningCharacter();
 
             // Found delimiter closer. Now look back for first matching opener.
+            int useDelims = 0;
             boolean openerFound = false;
-            boolean oddMatch = false;
+            boolean potentialOpenerFound = false;
             Delimiter opener = closer.previous;
             while (opener != null && opener != stackBottom && opener != openersBottom.get(delimiterChar)) {
-                if (opener.delimiterChar == openingDelimiterChar) {
-                    oddMatch = (closer.canOpen || opener.canClose) &&
-                            (opener.numDelims + closer.numDelims) % 3 == 0;
-                    if (opener.canOpen && !oddMatch) {
+                if (opener.canOpen && opener.delimiterChar == openingDelimiterChar) {
+                    potentialOpenerFound = true;
+                    useDelims = delimiterProcessor.getDelimiterUse(opener, closer);
+                    if (useDelims > 0) {
                         openerFound = true;
                         break;
                     }
@@ -810,12 +811,14 @@ private void processDelimiters(Delimiter stackBottom) {
             }
 
             if (!openerFound) {
-                if (!oddMatch) {
+                if (!potentialOpenerFound) {
                     // Set lower bound for future searches for openers.
-                    // We don't do this with odd matches because a **
-                    // that doesn't match an earlier * might turn into
-                    // an opener, and the * might be matched by something
-                    // else.
+                    // Only do this when we didn't even have a potential
+                    // opener (one that matches the character and can open).
+                    // If an opener was rejected because of the number of
+                    // delimiters (e.g. because of the "multiple of 3" rule),
+                    // we want to consider it next time because the number
+                    // of delimiters can change as we continue processing.
                     openersBottom.put(delimiterChar, closer.previous);
                     if (!closer.canOpen) {
                         // We can remove a closer that can't be an opener,
@@ -827,16 +830,10 @@ private void processDelimiters(Delimiter stackBottom) {
                 continue;
             }
 
-            int useDelims = delimiterProcessor.getDelimiterUse(opener.numDelims, closer.numDelims);
-            if (useDelims <= 0) {
-                // nope
-                useDelims = 1;
-            }
-
             Text openerNode = opener.node;
             Text closerNode = closer.node;
 
-            // remove used delimiters from stack elts and inlines
+            // Remove number of used delimiters from stack and inline nodes.
             opener.numDelims -= useDelims;
             closer.numDelims -= useDelims;
             openerNode.setLiteral(
@@ -952,4 +949,17 @@ private void mergeIfNeeded(Text first, Text last, int textLength) {
             first.setLiteral(literal);
         }
     }
+
+    private static class DelimiterData {
+
+        final int count;
+        final boolean canClose;
+        final boolean canOpen;
+
+        DelimiterData(int count, boolean canOpen, boolean canClose) {
+            this.count = count;
+            this.canOpen = canOpen;
+            this.canClose = canClose;
+        }
+    }
 }

commonmark/src/main/java/org/commonmark/internal/InlineParserImpl.java

@@ -4,7 +4,8 @@
 import org.commonmark.node.Node;
 import org.commonmark.node.StrongEmphasis;
 import org.commonmark.node.Text;
-import org.commonmark.parser.DelimiterProcessor;
+import org.commonmark.parser.delimiter.DelimiterProcessor;
+import org.commonmark.parser.delimiter.DelimiterRun;
 
 public abstract class EmphasisDelimiterProcessor implements DelimiterProcessor {
 
@@ -15,34 +16,38 @@ protected EmphasisDelimiterProcessor(char delimiterChar) {
     }
 
     @Override
-    public char getOpeningDelimiterChar() {
+    public char getOpeningCharacter() {
         return delimiterChar;
     }
 
     @Override
-    public char getClosingDelimiterChar() {
+    public char getClosingCharacter() {
         return delimiterChar;
     }
 
     @Override
-    public int getMinDelimiterCount() {
+    public int getMinLength() {
         return 1;
     }
 
     @Override
-    public int getDelimiterUse(int openerCount, int closerCount) {
+    public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {
+        // "multiple of 3" rule for internal delimiter runs
+        if ((opener.canClose() || closer.canOpen()) && (opener.length() + closer.length()) % 3 == 0) {
+            return 0;
+        }
         // calculate actual number of delimiters used from this closer
-        if (closerCount < 3 || openerCount < 3) {
-            return closerCount <= openerCount ?
-                    closerCount : openerCount;
+        if (opener.length() < 3 || closer.length() < 3) {
+            return closer.length() <= opener.length() ?
+                    closer.length() : opener.length();
         } else {
-            return closerCount % 2 == 0 ? 2 : 1;
+            return closer.length() % 2 == 0 ? 2 : 1;
         }
     }
 
     @Override
     public void process(Text opener, Text closer, int delimiterUse) {
-        String singleDelimiter = String.valueOf(getOpeningDelimiterChar());
+        String singleDelimiter = String.valueOf(getOpeningCharacter());
         Node emphasis = delimiterUse == 1
                 ? new Emphasis(singleDelimiter)
                 : new StrongEmphasis(singleDelimiter + singleDelimiter);

commonmark/src/main/java/org/commonmark/internal/inline/EmphasisDelimiterProcessor.java

@@ -7,6 +7,7 @@
 import org.commonmark.internal.InlineParserImpl;
 import org.commonmark.node.Node;
 import org.commonmark.parser.block.BlockParserFactory;
+import org.commonmark.parser.delimiter.DelimiterProcessor;
 
 import java.util.ArrayList;
 import java.util.BitSet;

commonmark/src/main/java/org/commonmark/parser/Parser.java

@@ -1,4 +1,4 @@
-package org.commonmark.parser;
+package org.commonmark.parser.delimiter;
 
 import org.commonmark.node.Text;
 
@@ -13,28 +13,30 @@ public interface DelimiterProcessor {
      * @return the character that marks the beginning of a delimited node, must not clash with any built-in special
      * characters
      */
-    char getOpeningDelimiterChar();
+    char getOpeningCharacter();
 
     /**
      * @return the character that marks the the ending of a delimited node, must not clash with any built-in special
      * characters. Note that for a symmetric delimiter such as "*", this is the same as the opening.
      */
-    char getClosingDelimiterChar();
+    char getClosingCharacter();
 
     /**
      * Minimum number of delimiter characters that are needed to activate this. Must be at least 1.
      */
-    int getMinDelimiterCount();
+    int getMinLength();
 
     /**
-     * Determine how many of the delimiters should be used. Useful in case the same character with a different count
-     * should have a different meaning (e.g. with "*" for emphasis and "**" for strong emphasis).
+     * Determine how many (if any) of the delimiter characters should be used.
+     * <p>
+     * This allows implementations to decide how many characters to use based on the properties of the delimiter runs.
+     * An implementation can also return 0 when it doesn't want to allow this particular combination of delimiter runs.
      *
-     * @param openerCount the delimiter count of the opening delimiter, at least 1
-     * @param closerCount the delimiter count of the closing delimiter, at least 1
-     * @return how many delimiters should be used; cannot be 0; must not be greater than either openerCount or closerCount
+     * @param opener the opening delimiter run
+     * @param closer the closing delimiter run
+     * @return how many delimiters should be used; must not be greater than length of either opener or closer
      */
-    int getDelimiterUse(int openerCount, int closerCount);
+    int getDelimiterUse(DelimiterRun opener, DelimiterRun closer);
 
     /**
      * Process the matched delimiters, e.g. by wrapping the nodes between opener and closer in a new node, or appending