madfun/adf/node/

mod.rs

use super::{Mark, mark::LinkAttrs};
use crate::Error;
use buildstructor::{Builder, buildstructor};
use serde::{Deserialize, Serialize};
use std::fmt::Write;

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum Node {
    /// <https://developer.atlassian.com/cloud/jira/platform/apis/document/nodes/codeBlock/>
    ///
    /// ```json
    /// {
    ///   "type": "codeBlock",
    ///   "attrs": {
    ///     "language": "javascript"
    ///   },
    ///   "content": [
    ///     {
    ///       "type": "text",
    ///       "text": "var foo = {};\nvar bar = [];"
    ///     }
    ///   ]
    /// }
    CodeBlock {
        #[serde(skip_serializing_if = "Option::is_none")]
        attrs: Option<CodeBlockAttrs>,

        #[serde(skip_serializing_if = "Vec::is_empty")]
        content: Vec<Self>,
    },

    /// <https://developer.atlassian.com/cloud/jira/platform/apis/document/nodes/doc/>
    ///
    /// ```json
    /// {
    ///   "version": 1,
    ///   "type": "doc",
    ///   "content": [
    ///     {
    ///       "type": "paragraph",
    ///       "content": [
    ///         {
    ///           "type": "text",
    ///           "text": "Hello world"
    ///         }
    ///       ]
    ///     }
    ///   ]
    /// }
    /// ```
    Doc {
        version: u64,
        content: Vec<Self>,
    },

    /// <https://developer.atlassian.com/cloud/jira/platform/apis/document/nodes/heading/>
    ///
    /// ```json
    /// {
    ///   "type": "heading",
    ///   "attrs": {
    ///     "level": 1
    ///   },
    ///   "content": [
    ///     {
    ///       "type": "text",
    ///       "text": "Heading 1"
    ///     }
    ///   ]
    /// }
    /// ```
    Heading {
        content: Vec<Self>,
        attrs: HeadingAttrs,
    },

    /// <https://developer.atlassian.com/cloud/jira/platform/apis/document/nodes/paragraph/>
    ///
    /// ```json
    /// {
    ///   "type": "paragraph",
    ///   "content": [
    ///     {
    ///       "type": "text",
    ///       "text": "Hello world"
    ///     }
    ///   ]
    /// }
    /// ```
    Paragraph {
        #[serde(skip_serializing_if = "Option::is_none")]
        attrs: Option<ParagraphAttrs>,
        content: Vec<Self>,
    },

    /// <https://developer.atlassian.com/cloud/jira/platform/apis/document/nodes/text/>
    ///
    /// ```json
    /// {
    ///   "type": "text",
    ///   "text": "Hello world"
    /// }
    /// ```
    Text {
        text: String,
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        marks: Vec<Mark>,
    },
}

#[buildstructor]
impl Node {
    /// Create a new builder for a CodeBlock discriminant.
    #[must_use]
    #[builder(entry = "codeblock")]
    pub fn new_codeblock(
        content: Vec<Node>,
        attrs: Option<CodeBlockAttrs>,
    ) -> Self {
        Self::CodeBlock {
            attrs,
            content,
        }
    }

    /// Create a new builder for a Doc discriminant.
    #[must_use]
    #[builder(entry = "doc")]
    pub fn new_doc(content: Vec<Node>) -> Self {
        Self::Doc {
            content,
            version: 1,
        }
    }

    /// Create a new builder for a Heading discriminant.
    #[must_use]
    #[builder(entry = "heading")]
    pub fn new_heading(content: Vec<Node>, attrs: HeadingAttrs) -> Self {
        Self::Heading {
            attrs,
            content,
        }
    }

    /// Create a new builder for a Paragraph discriminant.
    #[must_use]
    #[builder(entry = "paragraph")]
    pub fn new_paragraph(
        content: Vec<Node>,
        attrs: Option<ParagraphAttrs>,
    ) -> Self {
        Self::Paragraph {
            attrs,
            content,
        }
    }

    /// Create a new builder for a Text discriminant.
    #[must_use]
    #[builder(entry = "text")]
    pub fn new_text(text: String, marks: Vec<Mark>) -> Self {
        Self::Text {
            text,
            marks,
        }
    }

    /// # Errors
    ///
    /// Returns an error if writing to the buffer fails or the ADF is malformed
    /// (nodes where they don't belong).
    pub fn to_markdown(&self, mut buf: String) -> Result<String, Error> {
        Ok(match self {
            Node::CodeBlock {
                attrs,
                content,
            } => {
                writeln!(
                    &mut buf,
                    "```{}",
                    attrs.as_ref().map_or("", |a| &*a.language),
                )?;
                for node in content {
                    match node {
                        Node::Text {
                            text,
                            marks,
                        } => {
                            if !marks.is_empty() {
                                return Err(Error::InvalidNode);
                            }

                            writeln!(&mut buf, "{text}",)?;
                        },
                        _ => return Err(Error::InvalidNode),
                    }
                }

                // Write the closing backticks.
                writeln!(&mut buf, "```\n")?;

                buf
            },
            Node::Doc {
                content,
                ..
            } => {
                for node in content {
                    buf = node.to_markdown(buf)?;
                }

                buf
            },
            Node::Heading {
                content,
                attrs,
            } => {
                write!(&mut buf, "{}", "#".repeat(attrs.level as usize))?;

                for node in content {
                    buf = node.to_markdown(buf)?;
                }

                write!(&mut buf, "\n\n")?;

                buf
            },
            Node::Paragraph {
                content,
                ..
            } => {
                for node in content {
                    buf = node.to_markdown(buf)?;
                }

                write!(&mut buf, "\n\n")?;

                buf
            },
            Node::Text {
                text,
                marks,
            } => {
                // Go through any marks and print the corresponding opening
                // character.
                for mark in marks {
                    match mark {
                        Mark::Code => write!(&mut buf, "`")?,
                        Mark::Link {
                            ..
                        } => {
                            write!(&mut buf, "[")?;
                        },
                    }
                }

                // Print the main, actual content.
                write!(&mut buf, "{text}")?;

                // Go through the marks again and print any corresponding
                // closing characters. We go through in reverse order to
                // (hopefully) produce sane nested markup.
                for mark in marks.iter().rev() {
                    match mark {
                        Mark::Code => write!(&mut buf, "`")?,
                        Mark::Link {
                            attrs:
                                LinkAttrs {
                                    href,
                                    title,
                                    ..
                                },
                        } => {
                            write!(&mut buf, "]({href}")?;

                            if let Some(title) = title {
                                write!(&mut buf, " \"{title}\"")?;
                            }

                            write!(&mut buf, ")")?;
                        },
                    }
                }

                buf
            },
        })
    }
}

#[derive(Builder, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ParagraphAttrs {
    #[serde(rename = "locallid")]
    local_id: String,
}

#[derive(Builder, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct CodeBlockAttrs {
    language: String,
}

#[derive(Builder, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct HeadingAttrs {
    level: u8,

    #[serde(rename = "locallid")]
    local_id: Option<String>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    mod codeblock {
        use super::*;

        mod serialize {
            use super::*;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_empty() {
                // Empty of content.
                let adf = serde_json::to_value(Node::CodeBlock {
                    attrs: None,
                    content: vec![],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "type": "codeBlock",
                    }),
                    "{adf:?}"
                );
            }

            #[test]
            fn test_content() {
                // With content.
                let adf = serde_json::to_value(Node::CodeBlock {
                    attrs: None,
                    content: vec![Node::Text {
                        text: "Hello world".into(),
                        marks: vec![],
                    }],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "type": "codeBlock",
                        "content": [
                          {
                            "type": "text",
                            "text": "Hello world"
                          }
                        ]
                    }),
                    "{adf:?}"
                );
            }

            #[test]
            fn test_with_attrs() {
                let adf = serde_json::to_value(Node::CodeBlock {
                    attrs: Some(CodeBlockAttrs {
                        language: "foobar".into(),
                    }),
                    content: vec![],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "attrs": {
                            "language": "foobar",
                        },
                        "type": "codeBlock",
                    }),
                    "{adf:?}"
                );
            }
        }
    }

    mod doc {
        use super::*;

        mod serialize {
            use super::*;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_empty() {
                // Empty of content.
                let adf = serde_json::to_value(Node::Doc {
                    version: 1,
                    content: vec![],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "version": 1,
                        "type": "doc",
                        "content": []
                    }),
                    "{adf:?}"
                );
            }

            #[test]
            fn test_with_content() {
                let adf = serde_json::to_value(Node::Doc {
                    version: 1,
                    content: vec![Node::Paragraph {
                        attrs: None,
                        content: vec![Node::Text {
                            text: "Hello world".into(),
                            marks: vec![],
                        }],
                    }],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "version": 1,
                        "type": "doc",
                        "content": [
                          {
                            "type": "paragraph",
                            "content": [
                              {
                                "type": "text",
                                "text": "Hello world"
                              }
                            ]
                          }
                        ]
                    }),
                    "{adf:?}"
                );
            }
        }

        mod markdown {
            use super::*;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_roundtrip_in_doc() {
                assert_eq!(
                    crate::from_str(concat!(
                        "Some paragraph text.\n",
                        "```\nsome code here\n```\n\n",
                        "And now some paragraph text with a ",
                        "[link](https://example.com).",
                    ),)
                    .unwrap(),
                    Node::doc()
                        .content(vec![
                            Node::Paragraph {
                                attrs: None,
                                content: vec![Node::Text {
                                    text: "Some paragraph text.".into(),
                                    marks: vec![],
                                },],
                            },
                            Node::CodeBlock {
                                attrs: None,
                                content: vec![Node::Text {
                                    text: "some code here".into(),
                                    marks: vec![],
                                },],
                            },
                            Node::Paragraph {
                                attrs: None,
                                content: vec![
                                    Node::Text {
                                        text: "And now some paragraph text with a ".into(),
                                        marks: vec![],
                                    },
                                    Node::Text {
                                        text: "link".into(),
                                        marks: vec![
                                            Mark::Link {
                                                attrs: LinkAttrs {
                                                    collection: None,
                                                    href: "https://example.com".into(),
                                                    id: None,
                                                    occurrence_key: None,
                                                    title: None,
                                                },
                                            },
                                        ],
                                    },
                                    Node::Text {
                                        text: ".".into(),
                                        marks: vec![],
                                    },
                                ],
                            },
                        ])
                        .build(),
                );
            }
        }
    }

    mod paragraph {
        use super::*;

        mod serialize {
            use super::*;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_empty() {
                // Empty of content.
                let adf = serde_json::to_value(Node::Paragraph {
                    attrs: None,
                    content: vec![],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "type": "paragraph",
                        "content": []
                    }),
                    "{adf:?}"
                );
            }

            #[test]
            fn test_content() {
                // With content.
                let adf = serde_json::to_value(Node::Paragraph {
                    attrs: None,
                    content: vec![Node::Text {
                        text: "Hello world".into(),
                        marks: vec![],
                    }],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "type": "paragraph",
                        "content": [
                          {
                            "type": "text",
                            "text": "Hello world"
                          }
                        ]
                    }),
                    "{adf:?}"
                );
            }

            #[test]
            fn test_with_attrs() {
                let adf = serde_json::to_value(Node::Paragraph {
                    attrs: Some(ParagraphAttrs {
                        local_id: "foobar".into(),
                    }),
                    content: vec![],
                })
                .unwrap();
                assert_eq!(
                    adf,
                    json!({
                        "attrs": {
                            "locallid": "foobar",
                        },
                        "type": "paragraph",
                        "content": [],
                    }),
                    "{adf:?}"
                );
            }
        }
    }

    mod to_markdown {
        use super::*;

        mod codeblock {
            use super::*;
            use crate::ToAdf;
            use markdown::mdast;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_from_adf_no_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &Node::codeblock()
                            .content_entry(
                                Node::text().text("let a = 1;").build()
                            )
                            .build(),
                    )
                    .unwrap(),
                    "```\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_from_adf_with_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &Node::codeblock()
                            .content_entry(
                                Node::text().text("let a = 1;").build()
                            )
                            .attrs(
                                CodeBlockAttrs::builder()
                                    .language("rust")
                                    .build()
                            )
                            .build(),
                    )
                    .unwrap(),
                    "```rust\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_from_mdast_no_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &mdast::Node::Code(mdast::Code {
                            value: "let a = 1;".into(),
                            position: None,
                            lang: None,
                            meta: None,
                        })
                        .to_adf()
                    )
                    .unwrap(),
                    "```\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_from_mdast_with_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &mdast::Node::Code(mdast::Code {
                            value: "let a = 1;".into(),
                            position: None,
                            lang: Some("rust".into()),
                            meta: None,
                        })
                        .to_adf()
                    )
                    .unwrap(),
                    "```rust\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_roundtrip_no_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str("```\nlet a = 1;\n```\n").unwrap()
                    )
                    .unwrap(),
                    "```\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_roundtrip_with_lang() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str("```rust\nlet a = 1;\n```").unwrap()
                    )
                    .unwrap(),
                    "```rust\nlet a = 1;\n```"
                );
            }

            #[test]
            fn test_roundtrip_in_doc() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str(concat!(
                            "Some paragraph text.\n\n",
                            "```\nsome code here\n```\n\n",
                            "And now some paragraph text with a ",
                            "[link](https://example.com).",
                        ),)
                        .unwrap()
                    )
                    .unwrap(),
                    concat!(
                        "Some paragraph text.\n\n",
                        "```\nsome code here\n```\n\n",
                        "And now some paragraph text with a ",
                        "[link](https://example.com).",
                    ),
                );
            }
        }

        mod text {
            use super::*;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_plain() {
                assert_eq!(
                    crate::to_markdown(
                        &Node::paragraph()
                            .content_entry(
                                Node::text().text("This is text.").build()
                            )
                            .build(),
                    )
                    .unwrap(),
                    "This is text."
                );
            }

            #[test]
            fn test_link() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str("[a link](https://example.com)")
                            .unwrap()
                    )
                    .unwrap(),
                    "[a link](https://example.com)"
                );
            }
        }

        mod paragraph {
            use super::*;
            use crate::ToAdf;
            use markdown::mdast;
            use pretty_assertions::assert_eq;

            #[test]
            fn test_from_adf_oneline() {
                assert_eq!(
                    crate::to_markdown(
                        &Node::paragraph()
                            .content_entry(
                                Node::text().text("Have a paragraph.").build()
                            )
                            .build(),
                    )
                    .unwrap(),
                    "Have a paragraph."
                );
            }

            #[test]
            fn test_from_adf_multiline() {
                assert_eq!(
                    crate::to_markdown(
                        &Node::paragraph()
                            .content_entry(
                                Node::text().text("Have a\nparagraph").build()
                            )
                            .build(),
                    )
                    .unwrap(),
                    "Have a\nparagraph"
                );
            }

            #[test]
            fn test_from_mdast() {
                assert_eq!(
                    crate::to_markdown(
                        &mdast::Node::Paragraph(mdast::Paragraph {
                            children: vec![mdast::Node::Text(mdast::Text {
                                value: "This is a paragraph.".into(),
                                position: None,
                            })],
                            position: None,
                        })
                        .to_adf()
                    )
                    .unwrap(),
                    "This is a paragraph."
                );
            }

            #[test]
            fn test_roundtrip() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str("Hello, world").unwrap()
                    )
                    .unwrap(),
                    "Hello, world"
                );
            }

            #[test]
            fn test_roundtrip_multi_paragraph() {
                assert_eq!(
                    crate::to_markdown(
                        &crate::from_str("Hello, world\n\nHi there").unwrap()
                    )
                    .unwrap(),
                    "Hello, world\n\nHi there"
                );
            }
        }
    }
}