Merge pull request #456 from tballison/markdown-writer-bulk-spans

MarkdownWriter: append unescaped spans in bulk

Author: robinst

commonmark/src/main/java/org/commonmark/renderer/markdown/MarkdownWriter.java

@@ -158,9 +158,7 @@ private void write(String s, CharMatcher escape) {
                 // Normal fast path
                 buffer.append(s);
             } else {
-                for (int i = 0; i < s.length(); i++) {
-                    append(s.charAt(i), escape);
-                }
+                append(s, escape);
             }
         } catch (IOException e) {
             throw new RuntimeException(e);
@@ -219,16 +217,40 @@ private void flushBlockSeparator() {
         }
     }
 
+    private void append(String s, CharMatcher escape) throws IOException {
+        // Append unescaped spans in bulk; per-char appends are slow for most Appendables
+        // (e.g. Writer, where each char is a synchronized call).
+        int end = s.length();
+        int start = 0;
+        for (int i = 0; i < end; i++) {
+            char c = s.charAt(i);
+            if (needsEscaping(c, escape)) {
+                if (start < i) {
+                    buffer.append(s, start, i);
+                }
+                appendEscaped(c);
+                start = i + 1;
+            }
+        }
+        if (start < end) {
+            buffer.append(s, start, end);
+        }
+    }
+
     private void append(char c, CharMatcher escape) throws IOException {
         if (needsEscaping(c, escape)) {
-            if (c == '\n') {
-                // Can't escape this with \, use numeric character reference
-                buffer.append("&#10;");
-            } else {
-                buffer.append('\\');
-                buffer.append(c);
-            }
+            appendEscaped(c);
+        } else {
+            buffer.append(c);
+        }
+    }
+
+    private void appendEscaped(char c) throws IOException {
+        if (c == '\n') {
+            // Can't escape this with \, use numeric character reference
+            buffer.append("&#10;");
         } else {
+            buffer.append('\\');
             buffer.append(c);
         }
     }

commonmark/src/test/java/org/commonmark/renderer/markdown/MarkdownWriterTest.java

@@ -0,0 +1,59 @@
+package org.commonmark.renderer.markdown;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.commonmark.text.CharMatcher;
+import org.junit.jupiter.api.Test;
+
+public class MarkdownWriterTest {
+
+    private static final CharMatcher STAR = c -> c == '*';
+    private static final CharMatcher NEWLINE = c -> c == '\n';
+    private static final CharMatcher PIPE = c -> c == '|';
+
+    @Test
+    public void testTextEscaping() {
+        assertThat(text("abc", STAR)).isEqualTo("abc");
+        assertThat(text("*abc", STAR)).isEqualTo("\\*abc");
+        assertThat(text("abc*", STAR)).isEqualTo("abc\\*");
+        assertThat(text("a*b*c", STAR)).isEqualTo("a\\*b\\*c");
+        assertThat(text("a**b", STAR)).isEqualTo("a\\*\\*b");
+        assertThat(text("***", STAR)).isEqualTo("\\*\\*\\*");
+        assertThat(text("*", STAR)).isEqualTo("\\*");
+    }
+
+    @Test
+    public void testTextEscapingNewline() {
+        assertThat(text("a\nb\nc", NEWLINE)).isEqualTo("a
b
c");
+        assertThat(text("\n", NEWLINE)).isEqualTo("
");
+    }
+
+    @Test
+    public void testRawEscaping() {
+        StringBuilder sb = new StringBuilder();
+        MarkdownWriter writer = new MarkdownWriter(sb);
+        writer.pushRawEscape(PIPE);
+        writer.raw("a|b|c");
+        writer.popRawEscape();
+        writer.raw("d|e");
+        assertThat(sb.toString()).isEqualTo("a\\|b\\|cd|e");
+    }
+
+    @Test
+    public void testLastCharAndLineStart() {
+        StringBuilder sb = new StringBuilder();
+        MarkdownWriter writer = new MarkdownWriter(sb);
+        writer.text("a*", STAR);
+        assertThat(writer.getLastChar()).isEqualTo('*');
+        assertThat(writer.isAtLineStart()).isFalse();
+        writer.line();
+        assertThat(writer.isAtLineStart()).isTrue();
+    }
+
+    private static String text(String s, CharMatcher escape) {
+        StringBuilder sb = new StringBuilder();
+        MarkdownWriter writer = new MarkdownWriter(sb);
+        writer.text(s, escape);
+        return sb.toString();
+    }
+}

commonmark/src/test/java/org/commonmark/test/SpecBenchmark.java

@@ -1,9 +1,11 @@
 package org.commonmark.test;
 
+import java.io.StringWriter;
 import java.util.List;
 import org.commonmark.node.Node;
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.html.HtmlRenderer;
+import org.commonmark.renderer.markdown.MarkdownRenderer;
 import org.commonmark.testutil.TestResources;
 import org.commonmark.testutil.example.ExampleReader;
 import org.openjdk.jmh.annotations.*;
@@ -23,6 +25,7 @@ public class SpecBenchmark {
             ExampleReader.readExampleSources(TestResources.getSpec());
     private static final Parser PARSER = Parser.builder().build();
     private static final HtmlRenderer RENDERER = HtmlRenderer.builder().build();
+    private static final MarkdownRenderer MARKDOWN_RENDERER = MarkdownRenderer.builder().build();
 
     private static final Node SPEC_NODE = PARSER.parse(SPEC);
 
@@ -60,6 +63,18 @@ public long renderWholeSpec() {
         return RENDERER.render(SPEC_NODE).length();
     }
 
+    @Benchmark
+    public long renderMarkdownWholeSpec() {
+        return MARKDOWN_RENDERER.render(SPEC_NODE).length();
+    }
+
+    @Benchmark
+    public long renderMarkdownWholeSpecToWriter() {
+        StringWriter writer = new StringWriter();
+        MARKDOWN_RENDERER.render(SPEC_NODE, writer);
+        return writer.getBuffer().length();
+    }
+
     private static long parseAndRender(List<String> examples) {
         long length = 0;
         for (String example : examples) {