Serialize mdast to markdown

Cargo.toml

@@ -12,6 +12,12 @@ keywords = ["commonmark", "markdown", "parse", "render", "tokenize"]
 categories = ["compilers", "encoding", "parser-implementations", "parsing", "text-processing"]
 include = ["src/", "license"]
 
+[workspace]
+members = ["generate", "mdast_util_to_markdown"]
+
+[workspace.dependencies]
+pretty_assertions = "1"
+
 [[bench]]
 name = "bench"
 path = "benches/bench.rs"
@@ -31,14 +37,11 @@ serde = { version = "1", features = ["derive"], optional = true }
 [dev-dependencies]
 env_logger = "0.11"
 criterion = "0.5"
-pretty_assertions = "1"
+pretty_assertions = { workspace = true }
 serde_json = { version = "1" }
 swc_core = { version = "0.100", features = [
   "ecma_ast",
   "ecma_visit",
   "ecma_parser",
   "common",
 ] }
-
-[workspace]
-members = ["generate"]

mdast_util_to_markdown/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "mdast_util_to_markdown"
+version = "0.0.0"
+edition = "2018"
+license = "MIT"
+
+[dependencies]
+markdown = { path = "../" }
+regex = { version = "1.7.3" }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }

mdast_util_to_markdown/src/association.rs

@@ -0,0 +1,37 @@
+use alloc::string::String;
+use markdown::mdast::{Definition, ImageReference, LinkReference};
+
+pub trait Association {
+    fn identifier(&self) -> &String;
+    fn label(&self) -> &Option<String>;
+}
+
+impl Association for Definition {
+    fn identifier(&self) -> &String {
+        &self.identifier
+    }
+
+    fn label(&self) -> &Option<String> {
+        &self.label
+    }
+}
+
+impl Association for ImageReference {
+    fn identifier(&self) -> &String {
+        &self.identifier
+    }
+
+    fn label(&self) -> &Option<String> {
+        &self.label
+    }
+}
+
+impl Association for LinkReference {
+    fn identifier(&self) -> &String {
+        &self.identifier
+    }
+
+    fn label(&self) -> &Option<String> {
+        &self.label
+    }
+}

mdast_util_to_markdown/src/configure.rs

@@ -0,0 +1,52 @@
+#[allow(dead_code)]
+pub struct Options {
+    pub bullet: char,
+    pub bullet_other: char,
+    pub bullet_ordered: char,
+    pub emphasis: char,
+    pub fence: char,
+    pub fences: bool,
+    pub list_item_indent: IndentOptions,
+    pub quote: char,
+    pub rule: char,
+    pub strong: char,
+    pub increment_list_marker: bool,
+    pub close_atx: bool,
+    pub resource_link: bool,
+    pub rule_spaces: bool,
+    pub setext: bool,
+    pub tight_definitions: bool,
+    pub rule_repetition: u32,
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+pub enum IndentOptions {
+    Mixed,
+    One,
+    Tab,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            bullet: '*',
+            bullet_other: '-',
+            bullet_ordered: '.',
+            emphasis: '*',
+            fence: '`',
+            fences: true,
+            increment_list_marker: true,
+            rule_repetition: 3,
+            list_item_indent: IndentOptions::One,
+            quote: '"',
+            rule: '*',
+            strong: '*',
+            close_atx: false,
+            rule_spaces: false,
+            resource_link: false,
+            setext: false,
+            tight_definitions: false,
+        }
+    }
+}

mdast_util_to_markdown/src/construct_name.rs

@@ -0,0 +1,31 @@
+#[derive(Clone, PartialEq)]
+#[allow(dead_code)]
+pub enum ConstructName {
+    Autolink,
+    Blockquote,
+    CodeIndented,
+    CodeFenced,
+    CodeFencedLangGraveAccent,
+    CodeFencedLangTilde,
+    CodeFencedMetaGraveAccent,
+    CodeFencedMetaTilde,
+    Definition,
+    DestinationLiteral,
+    DestinationRaw,
+    Emphasis,
+    HeadingAtx,
+    HeadingSetext,
+    Image,
+    ImageReference,
+    Label,
+    Link,
+    LinkReference,
+    List,
+    ListItem,
+    Paragraph,
+    Phrasing,
+    Reference,
+    Strong,
+    TitleApostrophe,
+    TitleQuote,
+}

mdast_util_to_markdown/src/handle/blockquote.rs

@@ -0,0 +1,38 @@
+use alloc::string::String;
+use markdown::mdast::{Blockquote, Node};
+
+use crate::{
+    construct_name::ConstructName,
+    message::Message,
+    state::{Info, State},
+    util::indent_lines::indent_lines,
+};
+
+use super::Handle;
+
+impl Handle for Blockquote {
+    fn handle(
+        &self,
+        state: &mut State,
+        _info: &Info,
+        _parent: Option<&Node>,
+        node: &Node,
+    ) -> Result<alloc::string::String, Message> {
+        state.enter(ConstructName::Blockquote);
+        let value = indent_lines(&state.container_flow(node)?, map);
+        Ok(value)
+    }
+}
+
+fn map(value: &str, _line: usize, blank: bool) -> String {
+    let marker = ">";
+    let total_allocation = marker.len() + value.len() + 1;
+    let mut result = String::with_capacity(total_allocation);
+    result.push_str(marker);
+    if !blank {
+        let blank_str = " ";
+        result.push_str(blank_str);
+    }
+    result.push_str(value);
+    result
+}

mdast_util_to_markdown/src/handle/break.rs

@@ -0,0 +1,33 @@
+use alloc::string::ToString;
+use markdown::mdast::{Break, Node};
+
+use crate::{
+    message::Message,
+    state::{Info, State},
+    util::pattern_in_scope::pattern_in_scope,
+};
+
+use super::Handle;
+
+impl Handle for Break {
+    fn handle(
+        &self,
+        state: &mut State,
+        info: &Info,
+        _parent: Option<&Node>,
+        _node: &Node,
+    ) -> Result<alloc::string::String, Message> {
+        for pattern in state.r#unsafe.iter() {
+            if pattern.character == '\n' && pattern_in_scope(&state.stack, pattern) {
+                let is_whitespace_or_tab = info.before.chars().any(|c| c == ' ' || c == '\t');
+                if is_whitespace_or_tab {
+                    return Ok("".to_string());
+                }
+
+                return Ok(" ".to_string());
+            }
+        }
+
+        Ok("\\\n".to_string())
+    }
+}

mdast_util_to_markdown/src/handle/code.rs

@@ -0,0 +1,90 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+};
+use markdown::mdast::{Code, Node};
+
+use crate::{
+    construct_name::ConstructName,
+    message::Message,
+    state::{Info, State},
+    util::{
+        check_fence::check_fence, format_code_as_indented::format_code_as_indented,
+        indent_lines::indent_lines, longest_char_streak::longest_char_streak, safe::SafeConfig,
+    },
+};
+
+use super::Handle;
+
+impl Handle for Code {
+    fn handle(
+        &self,
+        state: &mut State,
+        _info: &Info,
+        _parent: Option<&Node>,
+        _node: &Node,
+    ) -> Result<alloc::string::String, Message> {
+        let marker = check_fence(state)?;
+
+        if format_code_as_indented(self, state) {
+            state.enter(ConstructName::CodeIndented);
+            let value = indent_lines(&self.value, map);
+            state.exit();
+            return Ok(value);
+        }
+
+        let sequence = marker
+            .to_string()
+            .repeat((longest_char_streak(&self.value, marker) + 1).max(3));
+
+        state.enter(ConstructName::CodeFenced);
+        let mut value = sequence.clone();
+
+        if let Some(lang) = &self.lang {
+            let code_fenced_lang_construct = if marker == '`' {
+                ConstructName::CodeFencedLangGraveAccent
+            } else {
+                ConstructName::CodeFencedLangTilde
+            };
+            state.enter(code_fenced_lang_construct);
+
+            value.push_str(&state.safe(lang, &SafeConfig::new(&value, " ", Some('`'))));
+
+            state.exit();
+
+            if let Some(meta) = &self.meta {
+                let code_fenced_meta_construct = if marker == '`' {
+                    ConstructName::CodeFencedMetaGraveAccent
+                } else {
+                    ConstructName::CodeFencedMetaTilde
+                };
+
+                state.enter(code_fenced_meta_construct);
+                value.push(' ');
+
+                value.push_str(&state.safe(meta, &SafeConfig::new(&value, "\n", Some('`'))));
+
+                state.exit();
+            }
+        }
+
+        value.push('\n');
+
+        if !self.value.is_empty() {
+            value.push_str(&self.value);
+            value.push('\n');
+        }
+
+        value.push_str(&sequence);
+
+        Ok(value)
+    }
+}
+
+fn map(value: &str, _line: usize, blank: bool) -> String {
+    if blank {
+        String::new()
+    } else {
+        format!("    {}", value)
+    }
+}