Generalize link markers and use for inline footnotes

The resulting implementation for the footnotes extension is much nicer.
It also cleans up LinkInfo and makes images less of a special case.

Additionally, this allow inline parsing of markers that are not
part of links - could have done this without this change but noticed
it here and decided to fix it.

Author: robinst

commonmark-ext-footnotes/src/main/java/org/commonmark/ext/footnotes/FootnotesExtension.java

@@ -60,8 +60,7 @@ public void extend(Parser.Builder parserBuilder) {
                 .customBlockParserFactory(new FootnoteBlockParser.Factory())
                 .linkProcessor(new FootnoteLinkProcessor());
         if (inlineFootnotes) {
-            parserBuilder.customInlineContentParserFactory(new InlineFootnoteMarkerParser.Factory())
-                    .postProcessor(new InlineFootnoteMarkerRemover());
+            parserBuilder.linkMarker('^');
         }
     }
 

commonmark-ext-footnotes/src/main/java/org/commonmark/ext/footnotes/internal/FootnoteLinkProcessor.java

@@ -19,10 +19,10 @@ public class FootnoteLinkProcessor implements LinkProcessor {
     @Override
     public LinkResult process(LinkInfo linkInfo, Scanner scanner, InlineParserContext context) {
 
-        var beforeBracket = linkInfo.openingBracket().getPrevious();
-        if (beforeBracket instanceof InlineFootnoteMarker) {
-            beforeBracket.unlink();
-            return LinkResult.wrapTextIn(new InlineFootnote(), linkInfo.afterTextBracket());
+        if (linkInfo.marker() != null && linkInfo.marker().getLiteral().equals("^")) {
+            // An inline footnote like ^[footnote text]. Note that we only get the marker here if the option is enabled
+            // on the extension.
+            return LinkResult.wrapTextIn(new InlineFootnote(), linkInfo.afterTextBracket()).includeMarker();
         }
 
         if (linkInfo.destination() != null) {
@@ -53,6 +53,6 @@ public LinkResult process(LinkInfo linkInfo, Scanner scanner, InlineParserContex
         // For footnotes, we only ever consume the text part of the link, not the label part (if any)
         var position = linkInfo.afterTextBracket();
         // If the marker is `![`, we don't want to include the `!`, so start from bracket
-        return LinkResult.replaceWith(new FootnoteReference(label), position).startFromBracket();
+        return LinkResult.replaceWith(new FootnoteReference(label), position);
     }
 }

commonmark-ext-footnotes/src/main/java/org/commonmark/ext/footnotes/internal/InlineFootnoteMarker.java

@@ -1,7 +1,6 @@
 package org.commonmark.ext.footnotes;
 
 import org.commonmark.Extension;
-import org.commonmark.ext.footnotes.internal.InlineFootnoteMarker;
 import org.commonmark.node.*;
 import org.commonmark.parser.IncludeSourceSpans;
 import org.commonmark.parser.Parser;
@@ -246,7 +245,6 @@ public void testInlineFootnote() {
             assertText("Test ", doc.getFirstChild().getFirstChild());
             var fn = find(doc, InlineFootnote.class);
             assertText("inline footnote", fn.getFirstChild());
-            assertNull(tryFind(doc, InlineFootnoteMarker.class));
         }
 
         {
@@ -257,12 +255,8 @@ public void testInlineFootnote() {
         {
             var doc = parser.parse("Test ^[not inline footnote");
             assertNull(tryFind(doc, InlineFootnote.class));
-            assertNull(tryFind(doc, InlineFootnoteMarker.class));
             var t = doc.getFirstChild().getFirstChild();
-            // This is not ideal; text nodes aren't merged after post-processing
-            assertText("Test ", t);
-            assertText("^", t.getNext());
-            assertText("[not inline footnote", t.getNext().getNext());
+            assertText("Test ^[not inline footnote", t);
         }
 
         {
@@ -277,6 +271,14 @@ public void testInlineFootnote() {
             var code = fn.getFirstChild().getNext();
             assertEquals("bla]", ((Code) code).getLiteral());
         }
+
+        {
+            var doc = parser.parse("^[with a [link](url)]");
+            var fn = find(doc, InlineFootnote.class);
+            assertText("with a ", fn.getFirstChild());
+            var link = fn.getFirstChild().getNext();
+            assertEquals("url", ((Link) link).getDestination());
+        }
     }
 
     @Test

commonmark-ext-footnotes/src/main/java/org/commonmark/ext/footnotes/internal/InlineFootnoteMarkerParser.java

@@ -4,19 +4,19 @@
 import org.commonmark.parser.beta.Position;
 
 /**
- * Opening bracket for links (<code>[</code>) or images (<code>![</code>).
+ * Opening bracket for links ({@code [}), images ({@code ![}), or links with other markers.
  */
 public class Bracket {
 
     /**
-     * The node of {@code !} if present, null otherwise.
+     * The node of a marker such as {@code !} if present, null otherwise.
      */
-    public final Text bangNode;
+    public final Text markerNode;
 
     /**
-     * The position of {@code !} if present, null otherwise.
+     * The position of the marker if present, null otherwise.
      */
-    public final Position bangPosition;
+    public final Position markerPosition;
 
     /**
      * The node of {@code [}.
@@ -33,11 +33,6 @@ public class Bracket {
      */
     public final Position contentPosition;
 
-    /**
-     * Whether this is an image or link.
-     */
-    public final boolean image;
-
     /**
      * Previous bracket.
      */
@@ -59,20 +54,19 @@ public class Bracket {
     public boolean bracketAfter = false;
 
     static public Bracket link(Text bracketNode, Position bracketPosition, Position contentPosition, Bracket previous, Delimiter previousDelimiter) {
-        return new Bracket(null, null, bracketNode, bracketPosition, contentPosition, previous, previousDelimiter, false);
+        return new Bracket(null, null, bracketNode, bracketPosition, contentPosition, previous, previousDelimiter);
     }
 
-    static public Bracket image(Text bangNode, Position bangPosition, Text bracketNode, Position bracketPosition, Position contentPosition, Bracket previous, Delimiter previousDelimiter) {
-        return new Bracket(bangNode, bangPosition, bracketNode, bracketPosition, contentPosition, previous, previousDelimiter, true);
+    static public Bracket withMarker(Text markerNode, Position markerPosition, Text bracketNode, Position bracketPosition, Position contentPosition, Bracket previous, Delimiter previousDelimiter) {
+        return new Bracket(markerNode, markerPosition, bracketNode, bracketPosition, contentPosition, previous, previousDelimiter);
     }
 
-    private Bracket(Text bangNode, Position bangPosition, Text bracketNode, Position bracketPosition, Position contentPosition, Bracket previous, Delimiter previousDelimiter, boolean image) {
-        this.bangNode = bangNode;
-        this.bangPosition = bangPosition;
+    private Bracket(Text markerNode, Position markerPosition, Text bracketNode, Position bracketPosition, Position contentPosition, Bracket previous, Delimiter previousDelimiter) {
+        this.markerNode = markerNode;
+        this.markerPosition = markerPosition;
         this.bracketNode = bracketNode;
         this.bracketPosition = bracketPosition;
         this.contentPosition = contentPosition;
-        this.image = image;
         this.previous = previous;
         this.previousDelimiter = previousDelimiter;
     }

commonmark-ext-footnotes/src/main/java/org/commonmark/ext/footnotes/internal/InlineFootnoteMarkerRemover.java

@@ -74,6 +74,7 @@ public class DocumentParser implements ParserState {
     private final List<InlineContentParserFactory> inlineContentParserFactories;
     private final List<DelimiterProcessor> delimiterProcessors;
     private final List<LinkProcessor> linkProcessors;
+    private final Set<Character> linkMarkers;
     private final IncludeSourceSpans includeSourceSpans;
     private final DocumentBlockParser documentBlockParser;
     private final Definitions definitions = new Definitions();
@@ -83,12 +84,13 @@ public class DocumentParser implements ParserState {
 
     public DocumentParser(List<BlockParserFactory> blockParserFactories, InlineParserFactory inlineParserFactory,
                           List<InlineContentParserFactory> inlineContentParserFactories, List<DelimiterProcessor> delimiterProcessors,
-                          List<LinkProcessor> linkProcessors, IncludeSourceSpans includeSourceSpans) {
+                          List<LinkProcessor> linkProcessors, Set<Character> linkMarkers, IncludeSourceSpans includeSourceSpans) {
         this.blockParserFactories = blockParserFactories;
         this.inlineParserFactory = inlineParserFactory;
         this.inlineContentParserFactories = inlineContentParserFactories;
         this.delimiterProcessors = delimiterProcessors;
         this.linkProcessors = linkProcessors;
+        this.linkMarkers = linkMarkers;
         this.includeSourceSpans = includeSourceSpans;
 
         this.documentBlockParser = new DocumentBlockParser();
@@ -466,7 +468,7 @@ private BlockStartImpl findBlockStart(BlockParser blockParser) {
      * Walk through a block & children recursively, parsing string content into inline content where appropriate.
      */
     private void processInlines() {
-        var context = new InlineParserContextImpl(inlineContentParserFactories, delimiterProcessors, linkProcessors, definitions);
+        var context = new InlineParserContextImpl(inlineContentParserFactories, delimiterProcessors, linkProcessors, linkMarkers, definitions);
         var inlineParser = inlineParserFactory.create(context);
 
         for (var blockParser : allBlockParsers) {

commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnotesTest.java

@@ -7,21 +7,25 @@
 import org.commonmark.parser.delimiter.DelimiterProcessor;
 
 import java.util.List;
+import java.util.Set;
 
 public class InlineParserContextImpl implements InlineParserContext {
 
     private final List<InlineContentParserFactory> inlineContentParserFactories;
     private final List<DelimiterProcessor> delimiterProcessors;
     private final List<LinkProcessor> linkProcessors;
+    private final Set<Character> linkMarkers;
     private final Definitions definitions;
 
     public InlineParserContextImpl(List<InlineContentParserFactory> inlineContentParserFactories,
                                    List<DelimiterProcessor> delimiterProcessors,
                                    List<LinkProcessor> linkProcessors,
+                                   Set<Character> linkMarkers,
                                    Definitions definitions) {
         this.inlineContentParserFactories = inlineContentParserFactories;
         this.delimiterProcessors = delimiterProcessors;
         this.linkProcessors = linkProcessors;
+        this.linkMarkers = linkMarkers;
         this.definitions = definitions;
     }
 
@@ -40,6 +44,11 @@ public List<LinkProcessor> getCustomLinkProcessors() {
         return linkProcessors;
     }
 
+    @Override
+    public Set<Character> getCustomLinkMarkers() {
+        return linkMarkers;
+    }
+
     @Override
     public LinkReferenceDefinition getLinkReferenceDefinition(String label) {
         return definitions.getDefinition(LinkReferenceDefinition.class, label);