Fix serde, change `BlockQuote` -> `Blockquote`

Closes GH-72.
Closes GH-74.
Closes GH-135.

.github/workflows/main.yml

···
       - uses: dtolnay/rust-toolchain@v1
         with:
           toolchain: stable
-      - run: cargo install cargo-tarpaulin && cargo tarpaulin --out xml
+      - run: cargo install cargo-tarpaulin && cargo tarpaulin --features json --out xml
       - uses: codecov/codecov-action@v4

Cargo.toml

···
 env_logger = "0.11"
 criterion = "0.5"
 pretty_assertions = "1"
+serde_json = { version = "1" }
 swc_core = { version = "0.100", features = [
   "ecma_ast",
   "ecma_visit",

readme.md

···
     ```
 *   format:
     ```sh
-    cargo fmt && cargo fix --all-targets
+    cargo fmt && cargo fix --all-targets --all-features
     ```
 *   lint:
     ```sh
-    cargo fmt --check && cargo clippy --examples --tests --benches --all-features
+    cargo fmt --check && cargo clippy --examples --tests --benches --all-features --all-features
     ```
 *   test:
     ```sh
-    RUST_BACKTRACE=1 cargo test
+    RUST_BACKTRACE=1 cargo test --all-features
     ```
 *   docs:
     ```sh

src/mdast.rs

···
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "type")
+    serde(tag = "type", rename_all = "camelCase")
 )]
 pub enum Node {
     // Document:
···
 
     // Container:
     /// Block quote.
-    BlockQuote(BlockQuote),
+    Blockquote(Blockquote),
     /// Footnote definition.
     FootnoteDefinition(FootnoteDefinition),
     /// MDX: JSX element (container).
···
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Node::Root(x) => x.fmt(f),
-            Node::BlockQuote(x) => x.fmt(f),
+            Node::Blockquote(x) => x.fmt(f),
             Node::FootnoteDefinition(x) => x.fmt(f),
             Node::MdxJsxFlowElement(x) => x.fmt(f),
             Node::List(x) => x.fmt(f),
···
         match self {
             // Parents.
             Node::Root(x) => children_to_string(&x.children),
-            Node::BlockQuote(x) => children_to_string(&x.children),
+            Node::Blockquote(x) => children_to_string(&x.children),
             Node::FootnoteDefinition(x) => children_to_string(&x.children),
             Node::MdxJsxFlowElement(x) => children_to_string(&x.children),
             Node::List(x) => children_to_string(&x.children),
···
             Node::Root(x) => Some(&x.children),
             Node::Paragraph(x) => Some(&x.children),
             Node::Heading(x) => Some(&x.children),
-            Node::BlockQuote(x) => Some(&x.children),
+            Node::Blockquote(x) => Some(&x.children),
             Node::List(x) => Some(&x.children),
             Node::ListItem(x) => Some(&x.children),
             Node::Emphasis(x) => Some(&x.children),
···
             Node::Root(x) => Some(&mut x.children),
             Node::Paragraph(x) => Some(&mut x.children),
             Node::Heading(x) => Some(&mut x.children),
-            Node::BlockQuote(x) => Some(&mut x.children),
+            Node::Blockquote(x) => Some(&mut x.children),
             Node::List(x) => Some(&mut x.children),
             Node::ListItem(x) => Some(&mut x.children),
             Node::Emphasis(x) => Some(&mut x.children),
···
     pub fn position(&self) -> Option<&Position> {
         match self {
             Node::Root(x) => x.position.as_ref(),
-            Node::BlockQuote(x) => x.position.as_ref(),
+            Node::Blockquote(x) => x.position.as_ref(),
             Node::FootnoteDefinition(x) => x.position.as_ref(),
             Node::MdxJsxFlowElement(x) => x.position.as_ref(),
             Node::List(x) => x.position.as_ref(),
···
     pub fn position_mut(&mut self) -> Option<&mut Position> {
         match self {
             Node::Root(x) => x.position.as_mut(),
-            Node::BlockQuote(x) => x.position.as_mut(),
+            Node::Blockquote(x) => x.position.as_mut(),
             Node::FootnoteDefinition(x) => x.position.as_mut(),
             Node::MdxJsxFlowElement(x) => x.position.as_mut(),
             Node::List(x) => x.position.as_mut(),
···
     pub fn position_set(&mut self, position: Option<Position>) {
         match self {
             Node::Root(x) => x.position = position,
-            Node::BlockQuote(x) => x.position = position,
+            Node::Blockquote(x) => x.position = position,
             Node::FootnoteDefinition(x) => x.position = position,
             Node::MdxJsxFlowElement(x) => x.position = position,
             Node::List(x) => x.position = position,
···
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxJsxExpressionAttribute")
+    serde(untagged, rename = "mdxJsxExpressionAttribute")
 )]
 pub enum AttributeContent {
     /// JSX expression.
···
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "type")
+    serde(untagged)
 )]
 pub enum AttributeValue {
     /// Expression value.
···
     /// > | <a b="c" />
     ///          ^^^
     /// ```
-    #[cfg_attr(feature = "serde", serde(rename = "literal"))]
     Literal(String),
 }
 
···
 ///     ^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "root")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Root {
     // Parent.
     /// Content model.
···
 ///     ^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "paragraph")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Paragraph {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "heading")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Heading {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "thematicBreak")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ThematicBreak {
     // Void.
     /// Positional info.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "blockquote")
-)]
-pub struct BlockQuote {
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Blockquote {
     // Parent.
     /// Content model.
     pub children: Vec<Node>,
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "list")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct List {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "listItem")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ListItem {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "html")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Html {
     // Text.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "code")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Code {
     // Text.
     /// Content model.
···
 ///     ^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "math")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Math {
     // Text.
     /// Content model.
···
 ///     ^^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "definition")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Definition {
     // Void.
     /// Positional info.
···
 ///     ^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "text")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Text {
     // Text.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "emphasis")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Emphasis {
     // Parent.
     /// Content model.
···
 ///     ^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "strong")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Strong {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "inlineCode")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct InlineCode {
     // Text.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "inlineMath")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct InlineMath {
     // Text.
     /// Content model.
···
 ///   | b
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "break")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Break {
     // Void.
     /// Positional info.
···
 ///     ^^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "link")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Link {
     // Parent.
     /// Content model.
···
 ///     ^^^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "image")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Image {
     // Void.
     /// Positional info.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "linkReference")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct LinkReference {
     // Parent.
     /// Content model.
···
 ///     ^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "imageReference")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ImageReference {
     // Void.
     /// Positional info.
···
 ///     ^^^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "footnoteDefinition")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FootnoteDefinition {
     // Parent.
     /// Content model.
···
 ///     ^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "footnoteReference")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FootnoteReference {
     // Void.
     /// Positional info.
···
 ///     ^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "table")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Table {
     // Parent.
     /// Content model.
···
 ///     ^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "tableRow")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TableRow {
     // Parent.
     /// Content model.
···
 ///     ^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "tableCell")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TableCell {
     // Parent.
     /// Content model.
···
 ///     ^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "delete")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Delete {
     // Parent.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "yaml")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Yaml {
     // Void.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "toml")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Toml {
     // Void.
     /// Content model.
···
 ///     ^^^^^^^^^^^^^^^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxjsEsm")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MdxjsEsm {
     // Literal.
     /// Content model.
···
 ///     ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxFlowExpression")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MdxFlowExpression {
     // Literal.
     /// Content model.
···
 ///       ^^^
 /// ```
 #[derive(Clone, Debug, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxTextExpression")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MdxTextExpression {
     // Literal.
     /// Content model.
···
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxJsxFlowElement")
+    serde(rename_all = "camelCase")
 )]
 pub struct MdxJsxFlowElement {
     // Parent.
···
 #[cfg_attr(
     feature = "serde",
     derive(serde::Serialize, serde::Deserialize),
-    serde(tag = "type", rename = "mdxJsxTextElement")
+    serde(rename_all = "camelCase")
 )]
 pub struct MdxJsxTextElement {
     // Parent.
···
 
     #[test]
     fn block_quote() {
-        let mut node = Node::BlockQuote(BlockQuote {
+        let mut node = Node::Blockquote(Blockquote {
             position: None,
             children: vec![],
         });
 
         assert_eq!(
             format!("{:?}", node),
-            "BlockQuote { children: [], position: None }",
+            "Blockquote { children: [], position: None }",
             "should support `Debug`"
         );
         assert_eq!(node.to_string(), "", "should support `ToString`");
···
         node.position_set(Some(Position::new(1, 1, 0, 1, 2, 1)));
         assert_eq!(
             format!("{:?}", node),
-            "BlockQuote { children: [], position: Some(1:1-1:2 (0-1)) }",
+            "Blockquote { children: [], position: Some(1:1-1:2 (0-1)) }",
             "should support `position_set`"
         );
     }

src/to_mdast.rs

···
 
 use crate::event::{Event, Kind, Name};
 use crate::mdast::{
-    AttributeContent, AttributeValue, AttributeValueExpression, BlockQuote, Break, Code,
+    AttributeContent, AttributeValue, AttributeValueExpression, Blockquote, Break, Code,
     Definition, Delete, Emphasis, FootnoteDefinition, FootnoteReference, Heading, Html, Image,
     ImageReference, InlineCode, InlineMath, Link, LinkReference, List, ListItem, Math,
     MdxFlowExpression, MdxJsxAttribute, MdxJsxFlowElement, MdxJsxTextElement, MdxTextExpression,
···
 
 /// Handle [`Enter`][Kind::Enter]:[`BlockQuote`][Name::BlockQuote].
 fn on_enter_block_quote(context: &mut CompileContext) {
-    context.tail_push(Node::BlockQuote(BlockQuote {
+    context.tail_push(Node::Blockquote(Blockquote {
         children: vec![],
         position: None,
     }));

tests/block_quote.rs

···
 use markdown::{
-    mdast::{BlockQuote, Node, Paragraph, Root, Text},
+    mdast::{Blockquote, Node, Paragraph, Root, Text},
     message, to_html, to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
···
     assert_eq!(
         to_mdast("> a", &Default::default())?,
         Node::Root(Root {
-            children: vec![Node::BlockQuote(BlockQuote {
+            children: vec![Node::Blockquote(Blockquote {
                 children: vec![Node::Paragraph(Paragraph {
                     children: vec![Node::Text(Text {
                         value: "a".into(),

tests/serde.rs

···
+use markdown::mdast::Node;
+use markdown::message::Message;
+
+#[allow(unused)]
+#[derive(Debug)]
+enum Error {
+    Mdast(Message),
+    Serde(serde_json::Error),
+}
+
+#[cfg_attr(feature = "serde", test)]
+fn serde() -> Result<(), Error> {
+    let source = markdown::to_mdast(
+        r#"---
+title: Serde
+---
+
+import Test from 'test';
+import Inner from 'test';
+import {Another, YetAnother} from 'another';
+
+# <HelloMessage />, {username}!
+
+> Blockquote
+Add test constructs below!
+
+## Test serialization and deserialization of mdast
+
+<Test id={id} name="test">
+  <Inner name="inner" id={id}>
+    ## Inner
+    [Link](./link.md)
+  </Inner>
+</Test>
+
+<Another id={id} class="test" />
+
+{test} this is text expression
+
+<YetAnother id={id} class="test" />
+
+# Text
+
+~~The world is flat.~~ We now know that the world is round.
+
+*Emphasis*
+
+*Strong Emphasis*
+
+$This is math$
+
+Let's break\
+yes!
+
+***
+
+## List
+
+* item1
+* item2
+* item3
+
+## Code block
+
+```shell
+cargo test --features json
+```
+
+## Inline
+
+`Inline code` with backticks
+
+## Image
+
+![Image](http://url/a.png)
+
+## Table
+
+| Syntax    | Description |
+|-----------|-------------|
+| Header    | Title       |
+| Paragraph | Text        |
+
+## Task lists
+
+- [x] Write the press release
+- [ ] Update the website
+- [ ] Contact the media
+
+## Footnotes
+
+Here's a simple footnote,[^1] and here's a longer one.[^bignote]
+
+[^1]: This is the first footnote.
+
+[^bignote]: Here's one with multiple paragraphs and code.
+
+    Indent paragraphs to include them in the footnote.
+
+    `{ my code }`
+
+    Add as many paragraphs as you like.
+
+"#,
+        &markdown::ParseOptions {
+            constructs: markdown::Constructs {
+                frontmatter: true,
+                ..markdown::Constructs::mdx()
+            },
+            ..markdown::ParseOptions::gfm()
+        },
+    )
+    .map_err(Error::Mdast)?;
+
+    let value: String = serde_json::to_string(&source).map_err(Error::Serde)?;
+
+    let target: Node = serde_json::from_slice(value.as_bytes()).map_err(Error::Serde)?;
+
+    pretty_assertions::assert_eq!(source, target);
+
+    Ok(())
+}