Custom CowStr type

Makefile

@@ -74,6 +74,7 @@ afl_quick:
 		cargo afl build --no-default-features --release --config profile.release.debug-assertions=true && \
 		AFL_NO_UI=1 AFL_BENCH_UNTIL_CRASH=1 \
 			cargo afl fuzz -i in -o out -V 60 target/release/${AFL_TARGET})
+	[ -z "$$(find tests/afl/out/default/crashes -type f -name 'id:*')" ]
 
 afl_crash:
 	set +e; \

README.md

@@ -26,7 +26,7 @@ Jotdown supports Rust edition 2021, i.e. Rust 1.56 and above.
 ## Usage
 
 Jotdown is primarily a parsing library but also has a minimal CLI
-implementation and a simple online demo version.
+implementation and a simple web demo version.
 
 ### Library
 
@@ -62,9 +62,12 @@ It will be placed in `~/.cargo/bin/jotdown`.
 
 ### Web demo
 
-A version of Jotdown compiled to WebAssembly and runnable in a web browser is
-available at <https://hllmn.net/projects/jotdown/demo>. It can also be run
-locally:
+The web demo is a version of Jotdown compiled to WebAssembly and runnable in a
+web browser. It is useful for experimenting with the djot syntax and exploring
+what events are emitted or what output is rendered.
+
+An online version is available at <https://hllmn.net/projects/jotdown/demo>. It
+can also be run locally:
 
 ```
 $ cd examples/jotdown_wasm

bench/criterion/main.rs

@@ -51,7 +51,9 @@ fn gen_html(c: &mut criterion::Criterion) {
                     || jotdown::Parser::new(input).collect::<Vec<_>>(),
                     |p| {
                         let mut s = String::new();
-                        jotdown::html::Renderer.push(p.into_iter(), &mut s).unwrap();
+                        jotdown::html::Renderer::default()
+                            .push(p.into_iter(), &mut s)
+                            .unwrap();
                         s
                     },
                     criterion::BatchSize::SmallInput,
@@ -62,6 +64,60 @@ fn gen_html(c: &mut criterion::Criterion) {
 }
 criterion_group!(html, gen_html);
 
+fn gen_html_borrow(c: &mut criterion::Criterion) {
+    let mut group = c.benchmark_group("html_borrow");
+    for (name, input) in bench_input::INPUTS {
+        group.throughput(criterion::Throughput::Elements(
+            jotdown::Parser::new(input).count() as u64,
+        ));
+        group.bench_with_input(
+            criterion::BenchmarkId::from_parameter(name),
+            input,
+            |b, &input| {
+                b.iter_batched(
+                    || jotdown::Parser::new(input).collect::<Vec<_>>(),
+                    |p| {
+                        let mut s = String::new();
+                        jotdown::html::Renderer::default()
+                            .push_borrowed(p.as_slice().iter(), &mut s)
+                            .unwrap();
+                        s
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+}
+criterion_group!(html_borrow, gen_html_borrow);
+
+fn gen_html_clone(c: &mut criterion::Criterion) {
+    let mut group = c.benchmark_group("html_clone");
+    for (name, input) in bench_input::INPUTS {
+        group.throughput(criterion::Throughput::Elements(
+            jotdown::Parser::new(input).count() as u64,
+        ));
+        group.bench_with_input(
+            criterion::BenchmarkId::from_parameter(name),
+            input,
+            |b, &input| {
+                b.iter_batched(
+                    || jotdown::Parser::new(input).collect::<Vec<_>>(),
+                    |p| {
+                        let mut s = String::new();
+                        jotdown::html::Renderer::default()
+                            .push(p.iter().cloned(), &mut s)
+                            .unwrap();
+                        s
+                    },
+                    criterion::BatchSize::SmallInput,
+                );
+            },
+        );
+    }
+}
+criterion_group!(html_clone, gen_html_clone);
+
 fn gen_full(c: &mut criterion::Criterion) {
     let mut group = c.benchmark_group("full");
     for (name, input) in bench_input::INPUTS {
@@ -72,7 +128,7 @@ fn gen_full(c: &mut criterion::Criterion) {
             |b, &input| {
                 b.iter_with_large_drop(|| {
                     let mut s = String::new();
-                    jotdown::html::Renderer
+                    jotdown::html::Renderer::default()
                         .push(jotdown::Parser::new(input), &mut s)
                         .unwrap();
                     s
@@ -83,4 +139,4 @@ fn gen_full(c: &mut criterion::Criterion) {
 }
 criterion_group!(full, gen_full);
 
-criterion_main!(block, inline, html, full);
+criterion_main!(block, inline, html, html_borrow, html_clone, full);

bench/iai/main.rs

@@ -12,7 +12,7 @@ fn block_inline() -> Option<jotdown::Event<'static>> {
 
 fn full() -> String {
     let mut s = String::new();
-    jotdown::html::Renderer
+    jotdown::html::Renderer::default()
         .push(jotdown::Parser::new(bench_input::ALL), &mut s)
         .unwrap();
     s

examples/jotdown_wasm/Makefile

@@ -7,9 +7,19 @@ ${WASM}: ${SRC}
 
 wasm: ${WASM}
 
-run: ${WASM}
+index.html: Makefile demo.html
+	echo '<!DOCTYPE html><html>' > $@
+	echo '<head>' >> $@
+	echo '<title>Jotdown Demo</title>' >> $@
+	echo '</head>' >> $@
+	echo '<body style="display:flex;flex-direction:column;height:100vh;margin:0">' >> $@
+	cat demo.html >> $@
+	echo '</body>' >> $@
+	echo '</html>' >> $@
+
+run: ${WASM} index.html
 	python -m http.server
 
 clean:
-	rm -rf pkg
+	rm -rf pkg index.html
 	cargo clean

examples/jotdown_wasm/demo.html

@@ -0,0 +1,50 @@
+<div id="jotdown" style="flex-grow:1;display:flex;flex-direction:column">
+  <script type="module">
+    import init, {
+        jotdown_render,
+        jotdown_parse,
+        jotdown_parse_indent,
+    } from './pkg/jotdown_wasm.js';
+    await init();
+
+    let output = document.getElementById("output");
+    let input = document.getElementById("input");
+    let fmt = document.getElementById("fmt");
+
+    function render() {
+        if (fmt.value == "html") {
+            output.classList.add("verbatim")
+            output.innerText = jotdown_render(input.innerText);
+        } else if (fmt.value == "events") {
+            output.classList.add("verbatim")
+            output.innerText = jotdown_parse(input.innerText);
+        } else if (fmt.value == "events_indent") {
+            output.classList.add("verbatim")
+            output.innerText = jotdown_parse_indent(input.innerText);
+        } else if (fmt.value == "preview") {
+            output.classList.remove("verbatim")
+            output.innerHTML = jotdown_render(input.innerText);
+        }
+    }
+
+    render()
+
+    input.onkeyup = render;
+    fmt.onchange = render;
+
+    // auto focus on input on load
+    setTimeout(() => { input.focus(); }, 0);
+  </script>
+  <div>
+    <select id="fmt">
+      <option value="preview">preview</option>
+      <option value="html">html</option>
+      <option value="events">events</option>
+      <option value="events_indent">events (indented)</option>
+    </select>
+  </div>
+  <div id="panes" style="display:flex;height:100%;gap:1rem">
+    <pre id="input" contenteditable="true" placeholder="Input djot here" style="width:50%;height:100%;overflow:scroll;resize:none;box-sizing:border-box;margin:0">*Hello world!*</pre>
+    <pre id="output" readonly style="width:50%;height:100%;overflow:scroll;box-sizing:border-box;margin:0"></pre>
+  </div>
+</div>

examples/jotdown_wasm/src/lib.rs

@@ -1,12 +1,64 @@
 use wasm_bindgen::prelude::*;
 
 use jotdown::Render;
+use std::fmt::Write;
 
 #[must_use]
 #[wasm_bindgen]
 pub fn jotdown_render(djot: &str) -> String {
     let events = jotdown::Parser::new(djot);
     let mut html = String::new();
-    jotdown::html::Renderer.push(events, &mut html).unwrap();
+    jotdown::html::Renderer::default()
+        .push(events, &mut html)
+        .unwrap();
     html
 }
+
+#[must_use]
+#[wasm_bindgen]
+pub fn jotdown_parse(djot: &str) -> String {
+    jotdown::Parser::new(djot)
+        .map(|e| format!("{:?}\n", e))
+        .collect()
+}
+
+#[must_use]
+#[wasm_bindgen]
+pub fn jotdown_parse_indent(djot: &str) -> String {
+    let mut level = 0;
+    let mut out = String::new();
+    for e in jotdown::Parser::new(djot) {
+        if !matches!(e, jotdown::Event::End(..)) {
+            // use non-breaking space for indent because normal spaces gets squeezed by browser
+            let nbsp = '\u{00a0}';
+            (0..4 * level).for_each(|_| out.push(nbsp));
+        }
+        match e {
+            jotdown::Event::Start(c, attrs) => {
+                level += 1;
+                if c.is_block() {
+                    out.push('[');
+                } else {
+                    out.push('(');
+                }
+                out.write_fmt(format_args!("{:?}", c)).unwrap();
+                if c.is_block() {
+                    out.push(']');
+                } else {
+                    out.push(')');
+                }
+                if !attrs.is_empty() {
+                    out.write_fmt(format_args!(" {:?}", attrs)).unwrap();
+                }
+                out.push('\n');
+            }
+            jotdown::Event::End(..) => {
+                level -= 1;
+            }
+            e => {
+                out.write_fmt(format_args!("{:?}\n", e)).unwrap();
+            }
+        };
+    }
+    out
+}