Add mdx expression (flow, text)

3 files changed, 512 insertions, 5 deletions

diff --git a/tests/mdx_expression_flow.rs b/tests/mdx_expression_flow.rs
new file mode 100644
index 0000000..2a66a9d
--- /dev/null
+++ b/tests/mdx_expression_flow.rs
@@ -0,0 +1,234 @@
+extern crate micromark;
+use micromark::{micromark_with_options, Constructs, Options};
+use pretty_assertions::assert_eq;
+
+#[test]
+fn mdx_expression_flow_agnostic() -> Result<(), String> {
+    let mdx = Options {
+        constructs: Constructs::mdx(),
+        ..Options::default()
+    };
+
+    assert_eq!(
+        micromark_with_options("{a}", &mdx)?,
+        "",
+        "should support an expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("{}", &mdx)?,
+        "",
+        "should support an empty expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("{a", &mdx).err().unwrap(),
+        "1:3: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        "should crash if no closing brace is found (1)"
+    );
+
+    assert_eq!(
+        micromark_with_options("{b { c }", &mdx).err().unwrap(),
+        "1:9: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        "should crash if no closing brace is found (2)"
+    );
+
+    assert_eq!(
+        micromark_with_options("{\n}\na", &mdx)?,
+        "<p>a</p>",
+        "should support a line ending in an expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("{ a } \t\nb", &mdx)?,
+        "<p>b</p>",
+        "should support expressions followed by spaces"
+    );
+
+    assert_eq!(
+        micromark_with_options("  { a }\nb", &mdx)?,
+        "<p>b</p>",
+        "should support expressions preceded by spaces"
+    );
+
+    assert_eq!(
+        micromark_with_options("> {a\nb}", &mdx)
+            .err()
+            .unwrap(),
+        "2:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "should not support lazyness (1)"
+    );
+
+    assert_eq!(
+        micromark_with_options("> a\n{b}", &mdx)?,
+        "<blockquote>\n<p>a</p>\n</blockquote>\n",
+        "should not support lazyness (2)"
+    );
+
+    assert_eq!(
+        micromark_with_options("> {a}\nb", &mdx)?,
+        "<blockquote>\n</blockquote>\n<p>b</p>",
+        "should not support lazyness (3)"
+    );
+
+    assert_eq!(
+        micromark_with_options("> {\n> a\nb}", &mdx)
+            .err()
+            .unwrap(),
+        "3:1: Unexpected lazy line in expression in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "should not support lazyness (4)"
+    );
+
+    Ok(())
+}
+
+// To do: swc.
+// #[test]
+// fn mdx_expression_flow_gnostic() -> Result<(), String> {
+//     assert_eq!(
+//         micromark_with_options("{a}", &swc),
+//         "",
+//         "should support an expression"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("{}", &swc)?,
+//         "",
+//         "should support an empty expression"
+//     );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("{a", &swc);
+//     //     },
+//     //     /Unexpected end of file in expression, expected a corresponding closing brace for `{`/,
+//     //     "should crash if no closing brace is found (1)"
+//     // );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("{b { c }", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected content after expression/,
+//     //     "should crash if no closing brace is found (2)"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("{\n}\na", &swc)?,
+//         "<p>a</p>",
+//         "should support a line ending in an expression"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("{ a } \t\nb", &swc)?,
+//         "<p>b</p>",
+//         "should support expressions followed by spaces"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("  { a }\nb", &swc)?,
+//         "<p>b</p>",
+//         "should support expressions preceded by spaces"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("  {`\n    a\n  `}", &swc)?,
+//         "",
+//         "should support indented expressions"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a{(b)}c", &swc)?,
+//         "<p>ac</p>",
+//         "should support expressions padded w/ parens"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a{/* b */ ( (c) /* d */ + (e) )}f", &swc)?,
+//         "<p>af</p>",
+//         "should support expressions padded w/ parens and comments"
+//     );
+
+//     Ok(())
+// }
+
+// To do: move to JSX, actually test spread in expressions?
+// To do: swc.
+// #[test]
+// fn mdx_expression_spread() -> Result<(), String> {
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {b} c", &swc);
+//     //     },
+//     //     /Unexpected `Property` in code: only spread elements are supported/,
+//     //     "should crash if not a spread"
+//     // );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {...?} c", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on an incorrect spread"
+//     // );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {...b,c} d", &swc);
+//     //     },
+//     //     /Unexpected extra content in spread: only a single spread is supported/,
+//     //     "should crash if a spread and other things"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("a {} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an empty spread"
+//     );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {} b", &swc);
+//     //     },
+//     //     /Unexpected empty expression/,
+//     //     "should crash on an empty spread w/ `allowEmpty: false`"
+//     // );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("{a=b}", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Shorthand property assignments are valid only in destructuring patterns/,
+//     //     "should crash if not a spread w/ `allowEmpty`"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("a {/* b */} c", &swc)?,
+//         "<p>a  c</p>",
+//         "should support a comment spread"
+//     );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {/* b */} c", &swc);
+//     //     },
+//     //     /Unexpected empty expression/,
+//     //     "should crash on a comment spread w/ `allowEmpty: false`"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("a {...b} c", &swc)?,
+//         "<p>a  c</p>",
+//         "should support a spread"
+//     );
+
+//     Ok(())
+// }
diff --git a/tests/mdx_expression_text.rs b/tests/mdx_expression_text.rs
new file mode 100644
index 0000000..b42faf2
--- /dev/null
+++ b/tests/mdx_expression_text.rs
@@ -0,0 +1,273 @@
+extern crate micromark;
+use micromark::{micromark_with_options, Constructs, Options};
+use pretty_assertions::assert_eq;
+
+// To do: swc.
+// #[test]
+// fn mdx_expression_text_gnostic_core() -> Result<(), String> {
+//     assert_eq!(
+//         micromark_with_options("a {} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an empty expression (1)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a { \t\r\n} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an empty expression (2)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {/**/} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support a multiline comment (1)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {  /*\n*/\t} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support a multiline comment (2)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {/*b*//*c*/} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support a multiline comment (3)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {b/*c*/} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support a multiline comment (4)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {/*b*/c} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support a multiline comment (4)"
+//     );
+
+//     //   To do: errors.
+//     //   t.throws(
+//     //     () => {
+//     //       micromark_with_options("a {//} b", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on an incorrect line comment (1)"
+//     //   );
+
+//     //   To do: errors.
+//     //   t.throws(
+//     //     () => {
+//     //       micromark_with_options("a { // b } c", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on an incorrect line comment (2)"
+//     //   );
+
+//     assert_eq!(
+//         micromark_with_options("a {//\n} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support a line comment followed by a line ending"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {// b\nd} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support a line comment followed by a line ending and an expression"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {b// c\n} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support an expression followed by a line comment and a line ending"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {/*b*/ // c\n} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support comments (1)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {b.c} d", &swc)?,
+//         "<p>a  d</p>",
+//         "should support expression statements (1)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {1 + 1} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support expression statements (2)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a {function () {}} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support expression statements (3)"
+//     );
+
+//     //   To do: errors.
+//     //   t.throws(
+//     //     () => {
+//     //       micromark_with_options("a {var b = \"c\"} d", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on non-expressions"
+//     //   );
+
+//     assert_eq!(
+//         micromark_with_options("> a {\n> b} c", &swc)?,
+//         "<blockquote>\n<p>a  c</p>\n</blockquote>",
+//         "should support expressions in containers"
+//     );
+
+//     //   To do: errors.
+//     //   t.throws(
+//     //     () => {
+//     //       micromark_with_options("> a {\n> b<} c", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on incorrect expressions in containers (1)"
+//     //   );
+
+//     //   To do: errors.
+//     //   t.throws(
+//     //     () => {
+//     //       micromark_with_options("> a {\n> b\n> c} d", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected content after expression/,
+//     //     "should crash on incorrect expressions in containers (2)"
+//     //   );
+
+//     Ok(())
+// }
+
+#[test]
+fn mdx_expression_text_agnostic() -> Result<(), String> {
+    let mdx = Options {
+        constructs: Constructs::mdx(),
+        ..Options::default()
+    };
+
+    assert_eq!(
+        micromark_with_options("a {b} c", &mdx)?,
+        "<p>a  c</p>",
+        "should support an expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("a {} b", &mdx)?,
+        "<p>a  b</p>",
+        "should support an empty expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("a {b c", &mdx).err().unwrap(),
+        "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        "should crash if no closing brace is found (1)"
+    );
+
+    assert_eq!(
+        micromark_with_options("a {b { c } d", &mdx)
+            .err()
+            .unwrap(),
+        "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
+        "should crash if no closing brace is found (2)"
+    );
+
+    assert_eq!(
+        micromark_with_options("a {\n} b", &mdx)?,
+        "<p>a  b</p>",
+        "should support a line ending in an expression"
+    );
+
+    assert_eq!(
+        micromark_with_options("a } b", &mdx)?,
+        "<p>a } b</p>",
+        "should support just a closing brace"
+    );
+
+    assert_eq!(
+        micromark_with_options("{ a } b", &mdx)?,
+        "<p> b</p>",
+        "should support expressions as the first thing when following by other things"
+    );
+
+    Ok(())
+}
+
+// // To do: swc.
+// #[test]
+// fn mdx_expression_text_gnostic() -> Result<(), String> {
+//     assert_eq!(
+//         micromark_with_options("a {b} c", &swc)?,
+//         "<p>a  c</p>",
+//         "should support an expression"
+//     );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {??} b", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected token/,
+//     //     "should crash on an incorrect expression"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("a {} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an empty expression"
+//     );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {b c", &swc);
+//     //     },
+//     //     /Unexpected end of file in expression, expected a corresponding closing brace for `{`/,
+//     //     "should crash if no closing brace is found (1)"
+//     // );
+
+//     //   To do: errors.
+//     // t.throws(
+//     //     () => {
+//     //     micromark_with_options("a {b { c } d", &swc);
+//     //     },
+//     //     /Could not parse expression with swc: Unexpected content after expression/,
+//     //     "should crash if no closing brace is found (2)"
+//     // );
+
+//     assert_eq!(
+//         micromark_with_options("a {\n} b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support a line ending in an expression"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a } b", &swc)?,
+//         "<p>a } b</p>",
+//         "should support just a closing brace"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("{ a } b", &swc)?,
+//         "<p> b</p>",
+//         "should support expressions as the first thing when following by other things"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a { /* { */ } b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an unbalanced opening brace (if JS permits)"
+//     );
+
+//     assert_eq!(
+//         micromark_with_options("a { /* } */ } b", &swc)?,
+//         "<p>a  b</p>",
+//         "should support an unbalanced closing brace (if JS permits)"
+//     );
+
+//     Ok(())
+// }
diff --git a/tests/mdx_jsx_flow.rs b/tests/mdx_jsx_flow.rs
index c9cd18d..ff53dcb 100644
--- a/tests/mdx_jsx_flow.rs
+++ b/tests/mdx_jsx_flow.rs
@@ -84,7 +84,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
 
     assert_eq!(
         micromark_with_options("> <X\n/>", &mdx).err().unwrap(),
-        "2:1: Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
         "should not support lazy flow (1)"
     );
 
@@ -92,7 +92,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
         micromark_with_options("> a\n> <X\n/>", &mdx)
             .err()
             .unwrap(),
-        "3:1: Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "3:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
         "should not support lazy flow (2)"
     );
 
@@ -100,7 +100,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
         micromark_with_options("> <a b='\nc'/> d", &mdx)
             .err()
             .unwrap(),
-        "2:1: Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
         "should not support lazy flow (3)"
     );
 
@@ -108,7 +108,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
         micromark_with_options("> <a b='c\n'/> d", &mdx)
             .err()
             .unwrap(),
-        "2:1: Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
         "should not support lazy flow (4)"
     );
 
@@ -116,7 +116,7 @@ fn mdx_jsx_flow_essence() -> Result<(), String> {
         micromark_with_options("> <a b='c\nd'/> e", &mdx)
             .err()
             .unwrap(),
-        "2:1: Unexpected lazy line in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
+        "2:1: Unexpected lazy line in jsx in container, expected line to be prefixed with `>` when in a block quote, whitespace when in a list, etc",
         "should not support lazy flow (4)"
     );