fix: Preserve formatting in fenced code blocks / quotes

Author: johnlepikhin

src/parser/blocks/blockquote.rs

@@ -3,6 +3,7 @@ use crate::parser::util::*;
 use crate::parser::MarkdownParserState;
 use nom::{
     character::complete::char,
+    combinator::opt,
     multi::{many1, many_m_n},
     sequence::preceded,
     IResult, Parser,
@@ -13,13 +14,16 @@ pub(crate) fn blockquote<'a>(
     state: Rc<MarkdownParserState>,
 ) -> impl FnMut(&'a str) -> IResult<&'a str, Vec<Block>> {
     move |input: &'a str| {
-        let prefix = preceded(many_m_n(0, 3, char(' ')), char('>'));
+        // Block quote marker: 0-3 leading spaces, '>', optional space
+        // Per CommonMark spec, the space after '>' is part of the marker and should be stripped
+        let prefix = preceded(many_m_n(0, 3, char(' ')), (char('>'), opt(char(' '))));
 
         let (input, lines) =
             many1(preceded(prefix, line_terminated(not_eof_or_eol0))).parse(input)?;
         let inner = lines.join("\n");
 
-        let (_, inner) = many1(crate::parser::blocks::block(state.clone()))
+        let nested_state = Rc::new(state.nested());
+        let (_, inner) = many1(crate::parser::blocks::block(nested_state))
             .parse(&inner)
             .map_err(|err| err.map_input(|_| input))?;
 

src/parser/blocks/code_block.rs

@@ -46,11 +46,18 @@ pub(crate) fn code_block_indented<'a>(
 }
 
 pub(crate) fn code_block_fenced<'a>(
-    _state: Rc<MarkdownParserState>,
+    state: Rc<MarkdownParserState>,
 ) -> impl FnMut(&'a str) -> IResult<&'a str, CodeBlock> {
     move |input: &'a str| {
         let (input, space_prefix) = many_m_n(0, 3, char(' ')).parse(input)?;
-        let prefix_length = space_prefix.len();
+        // Only strip prefix indentation when NOT in nested context.
+        // In nested context (inside list items, blockquotes, etc.), the container
+        // parser already stripped the container's indentation from the content.
+        let prefix_length = if state.is_nested_block_context {
+            0
+        } else {
+            space_prefix.len()
+        };
 
         let (input, (fence, info)) = line_terminated((
             recognize(alt((

src/parser/blocks/footnote_definition.rs

@@ -37,7 +37,8 @@ pub(crate) fn footnote_definition<'a>(
             footnote_content.push_str(line)
         }
 
-        let (_, blocks) = many0(crate::parser::blocks::block(state.clone()))
+        let nested_state = Rc::new(state.nested());
+        let (_, blocks) = many0(crate::parser::blocks::block(nested_state))
             .parse(&footnote_content)
             .map_err(|err| err.map_input(|_| input))?;
 

src/parser/blocks/github_alert.rs

@@ -67,17 +67,24 @@ pub(crate) fn github_alert<'a>(
         };
 
         // Now parse the rest of the blockquote lines
-        let prefix = preceded(many_m_n(0, 3, char(' ')), char('>'));
-        let (input, mut lines) =
+        // Block quote marker: 0-3 leading spaces, '>', optional space
+        // Per CommonMark spec, the space after '>' is part of the marker and should be stripped
+        let prefix = preceded(many_m_n(0, 3, char(' ')), (char('>'), opt(char(' '))));
+        let (input, lines) =
             many1(preceded(prefix, line_terminated(not_eof_or_eol0))).parse(input)?;
 
         // Remove the first line (alert marker) and join the rest
-        lines.remove(0); // Remove the alert marker line completely
-        let inner = lines.join("\n");
+        // Use slice instead of remove(0) to avoid panic on empty vec (although many1 guarantees at least one)
+        let inner = if lines.len() > 1 {
+            lines[1..].join("\n")
+        } else {
+            String::new()
+        };
 
         // Parse the inner content as blocks
+        let nested_state = Rc::new(state.nested());
         let (_, blocks) = if !inner.is_empty() {
-            many1(crate::parser::blocks::block(state.clone()))
+            many1(crate::parser::blocks::block(nested_state))
                 .parse(&inner)
                 .map_err(|err| err.map_input(|_| input))?
         } else {

src/parser/blocks/list.rs

@@ -215,7 +215,8 @@ pub(crate) fn list_item(
             }
         }
 
-        let (_, blocks) = many0(crate::parser::blocks::block(state.clone()))
+        let nested_state = Rc::new(state.nested());
+        let (_, blocks) = many0(crate::parser::blocks::block(nested_state))
             .parse(&item_content)
             .map_err(|err| err.map_input(|_| input))?;
 

src/parser/mod.rs

@@ -82,9 +82,16 @@ use std::rc::Rc;
 /// let config = MarkdownParserConfig::default();
 /// let state = MarkdownParserState::with_config(config);
 /// ```
+/// Note: This struct is marked `#[non_exhaustive]` to allow adding new fields
+/// in future versions without breaking existing code.
+#[non_exhaustive]
 pub struct MarkdownParserState {
     /// The parser configuration (reference-counted for efficient cloning)
     pub config: Rc<MarkdownParserConfig>,
+    /// Whether we are parsing content extracted from a container block (list item, blockquote, etc.)
+    /// When true, fenced code blocks should not strip additional indentation from their content.
+    /// This field is for internal use only.
+    pub(crate) is_nested_block_context: bool,
 }
 
 impl MarkdownParserState {
@@ -118,6 +125,19 @@ impl MarkdownParserState {
     pub fn with_config(config: MarkdownParserConfig) -> Self {
         Self {
             config: Rc::new(config),
+            is_nested_block_context: false,
+        }
+    }
+
+    /// Create a nested parser state for parsing content extracted from container blocks
+    ///
+    /// This method creates a new state that shares the same configuration but marks
+    /// the parsing context as nested. This prevents double-stripping of indentation
+    /// when parsing fenced code blocks inside list items, blockquotes, etc.
+    pub(crate) fn nested(&self) -> Self {
+        Self {
+            config: self.config.clone(),
+            is_nested_block_context: true,
         }
     }
 }

src/printer/block.rs

@@ -59,13 +59,36 @@ impl<'a> ToDoc<'a> for Block {
                 match kind {
                     CodeBlockKind::Fenced { info } => {
                         let info = info.as_deref().unwrap_or("");
-                        arena
-                            .text(format!("```{info}\n"))
-                            .append(arena.text(literal.clone()))
-                            .append(arena.text("\n```"))
+                        // Use hardline() between lines so nest() indentation applies correctly
+                        // when the code block is inside a list or other nested structure.
+                        // We use split('\n') instead of lines() to preserve trailing newlines.
+                        let mut doc = arena.text(format!("```{info}"));
+
+                        // Handle code block content.
+                        // For non-empty content, we use split('\n') instead of lines() to preserve
+                        // trailing newlines. Each line gets a hardline() before it so that nest()
+                        // indentation applies correctly when inside lists or other nested structures.
+                        // IMPORTANT: For blank lines (empty or whitespace-only), we only add
+                        // hardline() without any text, so that nest() doesn't compound whitespace
+                        // on repeated format passes. This ensures idempotent formatting.
+                        if !literal.is_empty() {
+                            let lines: Vec<&str> = literal.split('\n').collect();
+                            for line in lines {
+                                doc = doc.append(arena.hardline());
+                                // Only add text for lines with non-whitespace content.
+                                // This prevents whitespace from compounding on each format pass.
+                                let trimmed = line.trim_start();
+                                if !trimmed.is_empty() {
+                                    doc = doc.append(arena.text(line.to_string()));
+                                }
+                            }
+                        }
+
+                        // Closing fence must be on its own line
+                        doc.append(arena.hardline()).append(arena.text("```"))
                     }
                     CodeBlockKind::Indented => {
-                        // каждый строка с отступом 4 пробела
+                        // Each line indented with 4 spaces
                         let indented = literal
                             .lines()
                             .map(|l| format!("    {l}"))

src/printer/tests/list.rs

@@ -70,3 +70,170 @@ fn symmetric_round_trip_list_without_empty_line_before_list(input: &str) {
     let result = crate::printer::render_markdown(&doc, config);
     assert_eq!(input, result);
 }
+
+// Regression test: fenced code blocks inside list items should preserve internal indentation
+// and formatting should be idempotent (format(format(x)) == format(x))
+// Fix for bug: fenced code blocks inside lists were losing indentation on each render pass
+// because literal '\n' characters prevented nest() from applying indentation properly.
+#[rstest(
+    input,
+    // Basic code block in ordered list item
+    case(
+        r#" 1. **Example:**
+
+    ```rust
+    fn test() {
+        println!("hello");
+    }
+    ```"#
+    ),
+    // Code block with multiple indentation levels
+    case(
+        r#" 1. Item with code:
+
+    ```python
+    def foo():
+        if True:
+            return bar()
+    ```"#
+    ),
+    // Nested list with code block (2 levels)
+    case(
+        r#" - Outer item
+    - Inner item with code:
+
+      ```js
+      function test() {
+          console.log("nested");
+      }
+      ```"#
+    ),
+    // Empty code block in list item
+    case(
+        r#" - Empty code block:
+
+    ```rust
+    ```"#
+    ),
+    // Code block with blank lines inside
+    case(
+        r#" - Code with blank lines:
+
+    ```python
+    def foo():
+        pass
+
+    def bar():
+        pass
+    ```"#
+    ),
+    // Deeply nested list with code block (3 levels)
+    case(
+        r#" - Level 1
+    - Level 2
+       - Level 3 with code:
+
+         ```rust
+         fn deep() {
+             nested();
+         }
+         ```"#
+    ),
+    // Unordered list with asterisk marker
+    case(
+        r#" * Item with asterisk:
+
+    ```rust
+    fn asterisk() {}
+    ```"#
+    ),
+    // Unordered list with plus marker
+    case(
+        r#" + Item with plus:
+
+    ```rust
+    fn plus() {}
+    ```"#
+    ),
+    // Multiple code blocks in one list item
+    case(
+        r#" - Multiple blocks:
+
+    First:
+
+    ```rust
+    fn first() {}
+    ```
+
+    Second:
+
+    ```rust
+    fn second() {}
+    ```"#
+    ),
+    // Code block with unusual info string
+    case(
+        r#" - Item:
+
+    ```rust,no_run,edition=2021
+    fn info_string() {}
+    ```"#
+    ),
+)]
+fn fenced_code_block_in_list_idempotent(input: &str) {
+    // First pass
+    let doc1 = crate::parser::parse_markdown(crate::parser::MarkdownParserState::default(), input)
+        .unwrap();
+    let pass1 = crate::printer::render_markdown(&doc1, crate::printer::config::Config::default());
+
+    // Second pass - should be identical to first pass (idempotent)
+    let doc2 = crate::parser::parse_markdown(crate::parser::MarkdownParserState::default(), &pass1)
+        .unwrap();
+    let pass2 = crate::printer::render_markdown(&doc2, crate::printer::config::Config::default());
+
+    assert_eq!(
+        pass1, pass2,
+        "Formatting should be idempotent.\nInput:\n{}\n\nFirst pass:\n{}\n\nSecond pass:\n{}",
+        input, pass1, pass2
+    );
+}
+
+// Test that code blocks in blockquotes are also idempotent
+#[rstest(
+    input,
+    // Code block in blockquote
+    case(
+        r#"> Quote with code:
+>
+> ```rust
+> fn quoted() {
+>     println!("in quote");
+> }
+> ```"#
+    ),
+    // Code block in GitHub alert
+    case(
+        r#"> [!NOTE]
+> Alert with code:
+>
+> ```python
+> def alert():
+>     pass
+> ```"#
+    ),
+)]
+fn fenced_code_block_in_blockquote_idempotent(input: &str) {
+    let doc1 = crate::parser::parse_markdown(crate::parser::MarkdownParserState::default(), input)
+        .unwrap();
+    let pass1 = crate::printer::render_markdown(&doc1, crate::printer::config::Config::default());
+
+    let doc2 = crate::parser::parse_markdown(crate::parser::MarkdownParserState::default(), &pass1)
+        .unwrap();
+    let pass2 = crate::printer::render_markdown(&doc2, crate::printer::config::Config::default());
+
+    assert_eq!(
+        pass1, pass2,
+        "Formatting should be idempotent.\nInput:\n{}\n\nFirst pass:\n{}\n\nSecond pass:\n{}",
+        input, pass1, pass2
+    );
+}