rumdl_lib/rules/

md032_blanks_around_lists.rs

use crate::rule::{Fix, LintError, LintResult, LintWarning, Rule, RuleCategory, Severity};
use crate::utils::blockquote::{content_after_blockquote, effective_indent_in_blockquote};
use crate::utils::element_cache::ElementCache;
use crate::utils::quarto_divs;
use crate::utils::range_utils::{LineIndex, calculate_line_range};
use crate::utils::regex_cache::BLOCKQUOTE_PREFIX_RE;
use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
use regex::Regex;
use std::collections::HashMap;
use std::sync::LazyLock;

/// Information needed to fix a lazy continuation line
#[derive(Debug, Clone)]
struct LazyContInfo {
    /// Expected indentation (marker width for blockquotes, content_column otherwise)
    expected_indent: usize,
    /// Current indentation in bytes (after blockquote prefix when applicable)
    current_indent: usize,
    /// Blockquote nesting level (0 = not in blockquote)
    blockquote_level: usize,
}

mod md032_config;
pub use md032_config::MD032Config;

// Detects ordered list items starting with a number other than 1
static ORDERED_LIST_NON_ONE_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^\s*([2-9]|\d{2,})\.\s").unwrap());

/// Check if a line is a thematic break (horizontal rule)
/// Per CommonMark: 0-3 spaces of indentation, then 3+ of same char (-, *, _), optionally with spaces between
fn is_thematic_break(line: &str) -> bool {
    // Per CommonMark, thematic breaks can have 0-3 spaces of indentation (< 4 columns)
    if ElementCache::calculate_indentation_width_default(line) > 3 {
        return false;
    }

    let trimmed = line.trim();
    if trimmed.len() < 3 {
        return false;
    }

    let chars: Vec<char> = trimmed.chars().collect();
    let first_non_space = chars.iter().find(|&&c| c != ' ');

    if let Some(&marker) = first_non_space {
        if marker != '-' && marker != '*' && marker != '_' {
            return false;
        }
        let marker_count = chars.iter().filter(|&&c| c == marker).count();
        let other_count = chars.iter().filter(|&&c| c != marker && c != ' ').count();
        marker_count >= 3 && other_count == 0
    } else {
        false
    }
}

/// Rule MD032: Lists should be surrounded by blank lines
///
/// This rule enforces that lists are surrounded by blank lines, which improves document
/// readability and ensures consistent rendering across different Markdown processors.
///
/// ## Purpose
///
/// - **Readability**: Blank lines create visual separation between lists and surrounding content
/// - **Parsing**: Many Markdown parsers require blank lines around lists for proper rendering
/// - **Consistency**: Ensures uniform document structure and appearance
/// - **Compatibility**: Improves compatibility across different Markdown implementations
///
/// ## Examples
///
/// ### Correct
///
/// ```markdown
/// This is a paragraph of text.
///
/// - Item 1
/// - Item 2
/// - Item 3
///
/// This is another paragraph.
/// ```
///
/// ### Incorrect
///
/// ```markdown
/// This is a paragraph of text.
/// - Item 1
/// - Item 2
/// - Item 3
/// This is another paragraph.
/// ```
///
/// ## Behavior Details
///
/// This rule checks for the following:
///
/// - **List Start**: There should be a blank line before the first item in a list
///   (unless the list is at the beginning of the document or after front matter)
/// - **List End**: There should be a blank line after the last item in a list
///   (unless the list is at the end of the document)
/// - **Nested Lists**: Properly handles nested lists and list continuations
/// - **List Types**: Works with ordered lists, unordered lists, and all valid list markers (-, *, +)
///
/// ## Special Cases
///
/// This rule handles several special cases:
///
/// - **Front Matter**: YAML front matter is detected and skipped
/// - **Code Blocks**: Lists inside code blocks are ignored
/// - **List Content**: Indented content belonging to list items is properly recognized as part of the list
/// - **Document Boundaries**: Lists at the beginning or end of the document have adjusted requirements
///
/// ## Fix Behavior
///
/// When applying automatic fixes, this rule:
/// - Adds a blank line before the first list item when needed
/// - Adds a blank line after the last list item when needed
/// - Preserves document structure and existing content
///
/// ## Performance Optimizations
///
/// The rule includes several optimizations:
/// - Fast path checks before applying more expensive regex operations
/// - Efficient list item detection
/// - Pre-computation of code block lines to avoid redundant processing
#[derive(Debug, Clone, Default)]
pub struct MD032BlanksAroundLists {
    config: MD032Config,
}

impl MD032BlanksAroundLists {
    pub fn from_config_struct(config: MD032Config) -> Self {
        Self { config }
    }
}

impl MD032BlanksAroundLists {
    /// Check if a blank line should be required before a list based on the previous line context
    fn should_require_blank_line_before(
        ctx: &crate::lint_context::LintContext,
        prev_line_num: usize,
        current_line_num: usize,
    ) -> bool {
        // Always require blank lines after code blocks, front matter, etc.
        if ctx
            .line_info(prev_line_num)
            .is_some_and(|info| info.in_code_block || info.in_front_matter)
        {
            return true;
        }

        // Always allow nested lists (lists indented within other list items)
        if Self::is_nested_list(ctx, prev_line_num, current_line_num) {
            return false;
        }

        // Default: require blank line (matching markdownlint's behavior)
        true
    }

    /// Check if the current list is nested within another list item
    fn is_nested_list(
        ctx: &crate::lint_context::LintContext,
        prev_line_num: usize,    // 1-indexed
        current_line_num: usize, // 1-indexed
    ) -> bool {
        // Check if current line is indented (typical for nested lists)
        if current_line_num > 0 && current_line_num - 1 < ctx.lines.len() {
            let current_line = &ctx.lines[current_line_num - 1];
            if current_line.indent >= 2 {
                // Check if previous line is a list item or list content
                if prev_line_num > 0 && prev_line_num - 1 < ctx.lines.len() {
                    let prev_line = &ctx.lines[prev_line_num - 1];
                    // Previous line is a list item or indented content
                    if prev_line.list_item.is_some() || prev_line.indent >= 2 {
                        return true;
                    }
                }
            }
        }
        false
    }

    /// Detect lazy continuation lines within list items using pulldown-cmark's SoftBreak events.
    ///
    /// Lazy continuation occurs when text continues a list item paragraph but with less
    /// indentation than expected. pulldown-cmark identifies this via SoftBreak followed by Text
    /// within a list Item, where the Text starts at a column less than the item's content column.
    ///
    /// Returns a map of line numbers to fix information for auto-fix support.
    fn detect_lazy_continuation_lines(ctx: &crate::lint_context::LintContext) -> HashMap<usize, LazyContInfo> {
        let mut lazy_lines = HashMap::new();
        let parser = Parser::new_ext(ctx.content, Options::all());

        // Stack of (expected_indent_within_context, blockquote_level) for nested items
        let mut item_stack: Vec<(usize, usize)> = vec![];
        let mut after_soft_break = false;

        for (event, range) in parser.into_offset_iter() {
            match event {
                Event::Start(Tag::Item) => {
                    let line_num = Self::byte_to_line(&ctx.line_offsets, range.start);
                    let line_info = ctx.lines.get(line_num.saturating_sub(1));
                    let line_content = line_info.map(|li| li.content(ctx.content)).unwrap_or("");

                    // Determine blockquote level from the line content
                    let bq_level = line_content
                        .chars()
                        .take_while(|c| *c == '>' || c.is_whitespace())
                        .filter(|&c| c == '>')
                        .count();

                    // Calculate expected indent relative to blockquote context
                    let expected_indent = if bq_level > 0 {
                        // For blockquote lists, expected indent is the marker width
                        // (content_column - marker_column gives us marker + spacing width)
                        line_info
                            .and_then(|li| li.list_item.as_ref())
                            .map(|item| item.content_column.saturating_sub(item.marker_column))
                            .unwrap_or(2)
                    } else {
                        // For regular lists, use content_column directly
                        line_info
                            .and_then(|li| li.list_item.as_ref())
                            .map(|item| item.content_column)
                            .unwrap_or(0)
                    };

                    item_stack.push((expected_indent, bq_level));
                    after_soft_break = false;
                }
                Event::End(TagEnd::Item) => {
                    item_stack.pop();
                    after_soft_break = false;
                }
                Event::SoftBreak if !item_stack.is_empty() => {
                    after_soft_break = true;
                }
                // Detect content starting after a soft break - text, code, or inline formatting
                // All inline formatting tags that could appear at line start:
                // - Emphasis (*text* or _text_)
                // - Strong (**text** or __text__)
                // - Strikethrough (~~text~~ - GFM extension)
                // - Subscript (~text~ - extension)
                // - Superscript (^text^ - extension)
                // - Link ([text](url))
                // - Image (![alt](url))
                Event::Text(_)
                | Event::Code(_)
                | Event::Start(Tag::Emphasis)
                | Event::Start(Tag::Strong)
                | Event::Start(Tag::Strikethrough)
                | Event::Start(Tag::Subscript)
                | Event::Start(Tag::Superscript)
                | Event::Start(Tag::Link { .. })
                | Event::Start(Tag::Image { .. })
                    if after_soft_break =>
                {
                    if let Some(&(expected_indent, expected_bq_level)) = item_stack.last() {
                        let line_num = Self::byte_to_line(&ctx.line_offsets, range.start);
                        let line_info = ctx.lines.get(line_num.saturating_sub(1));
                        let line_content = line_info.map(|li| li.content(ctx.content)).unwrap_or("");
                        let fallback_indent = line_info.map(|li| li.indent).unwrap_or(0);

                        let actual_indent =
                            effective_indent_in_blockquote(line_content, expected_bq_level, fallback_indent);

                        if actual_indent < expected_indent {
                            // Store fix information along with the line number
                            lazy_lines.insert(
                                line_num,
                                LazyContInfo {
                                    expected_indent,
                                    current_indent: actual_indent,
                                    blockquote_level: expected_bq_level,
                                },
                            );
                        }
                    }
                    after_soft_break = false;
                }
                _ => {
                    after_soft_break = false;
                }
            }
        }

        lazy_lines
    }

    /// Convert a byte offset to a 1-indexed line number
    fn byte_to_line(line_offsets: &[usize], byte_offset: usize) -> usize {
        match line_offsets.binary_search(&byte_offset) {
            Ok(idx) => idx + 1,
            Err(idx) => idx.max(1),
        }
    }

    /// Check if a lazy continuation fix should be applied to a line.
    /// Returns false for lines inside code blocks, front matter, or HTML comments.
    fn should_apply_lazy_fix(ctx: &crate::lint_context::LintContext, line_num: usize) -> bool {
        ctx.lines
            .get(line_num.saturating_sub(1))
            .map(|li| !li.in_code_block && !li.in_front_matter && !li.in_html_comment)
            .unwrap_or(false)
    }

    /// Calculate the fix for a lazy continuation line.
    /// Returns the byte range to replace and the replacement string.
    fn calculate_lazy_continuation_fix(
        ctx: &crate::lint_context::LintContext,
        line_num: usize,
        lazy_info: &LazyContInfo,
    ) -> Option<Fix> {
        let line_info = ctx.lines.get(line_num.saturating_sub(1))?;
        let line_content = line_info.content(ctx.content);

        if lazy_info.blockquote_level == 0 {
            // Regular list (no blockquote): replace leading whitespace with proper indent
            let start_byte = line_info.byte_offset;
            let end_byte = start_byte + lazy_info.current_indent;
            let replacement = " ".repeat(lazy_info.expected_indent);

            Some(Fix {
                range: start_byte..end_byte,
                replacement,
            })
        } else {
            // List inside blockquote: preserve blockquote prefix, fix indent after it
            let after_bq = content_after_blockquote(line_content, lazy_info.blockquote_level);
            let prefix_byte_len = line_content.len().saturating_sub(after_bq.len());
            if prefix_byte_len == 0 {
                return None;
            }

            let current_indent = after_bq.len() - after_bq.trim_start().len();
            let start_byte = line_info.byte_offset + prefix_byte_len;
            let end_byte = start_byte + current_indent;
            let replacement = " ".repeat(lazy_info.expected_indent);

            Some(Fix {
                range: start_byte..end_byte,
                replacement,
            })
        }
    }

    /// Apply a lazy continuation fix to a single line.
    /// Replaces the current indentation with the expected indentation.
    fn apply_lazy_fix_to_line(line: &str, lazy_info: &LazyContInfo) -> String {
        if lazy_info.blockquote_level == 0 {
            // Regular list: strip current indent, add expected indent
            let content = line.trim_start();
            format!("{}{}", " ".repeat(lazy_info.expected_indent), content)
        } else {
            // Blockquote list: preserve blockquote prefix, fix indent after it
            let after_bq = content_after_blockquote(line, lazy_info.blockquote_level);
            let prefix_len = line.len().saturating_sub(after_bq.len());
            if prefix_len == 0 {
                return line.to_string();
            }

            let prefix = &line[..prefix_len];
            let rest = after_bq.trim_start();
            format!("{}{}{}", prefix, " ".repeat(lazy_info.expected_indent), rest)
        }
    }

    /// Find the first non-transparent line before the given line (1-indexed).
    /// Returns (line_num, is_blank) where:
    /// - line_num is the 1-indexed line of actual content (0 if start of document)
    /// - is_blank is true if that line is blank (meaning separation exists)
    ///
    /// Transparent elements (HTML comments, Quarto div markers) are skipped,
    /// matching markdownlint-cli behavior.
    fn find_preceding_content(ctx: &crate::lint_context::LintContext, before_line: usize) -> (usize, bool) {
        let is_quarto = ctx.flavor == crate::config::MarkdownFlavor::Quarto;
        for line_num in (1..before_line).rev() {
            let idx = line_num - 1;
            if let Some(info) = ctx.lines.get(idx) {
                // Skip HTML comment lines - they're transparent
                if info.in_html_comment {
                    continue;
                }
                // Skip Quarto div markers in Quarto flavor - they're transparent
                if is_quarto {
                    let trimmed = info.content(ctx.content).trim();
                    if quarto_divs::is_div_open(trimmed) || quarto_divs::is_div_close(trimmed) {
                        continue;
                    }
                }
                return (line_num, info.is_blank);
            }
        }
        // Start of document = effectively blank-separated
        (0, true)
    }

    /// Find the first non-transparent line after the given line (1-indexed).
    /// Returns (line_num, is_blank) where:
    /// - line_num is the 1-indexed line of actual content (0 if end of document)
    /// - is_blank is true if that line is blank (meaning separation exists)
    ///
    /// Transparent elements (HTML comments, Quarto div markers) are skipped.
    fn find_following_content(ctx: &crate::lint_context::LintContext, after_line: usize) -> (usize, bool) {
        let is_quarto = ctx.flavor == crate::config::MarkdownFlavor::Quarto;
        let num_lines = ctx.lines.len();
        for line_num in (after_line + 1)..=num_lines {
            let idx = line_num - 1;
            if let Some(info) = ctx.lines.get(idx) {
                // Skip HTML comment lines - they're transparent
                if info.in_html_comment {
                    continue;
                }
                // Skip Quarto div markers in Quarto flavor - they're transparent
                if is_quarto {
                    let trimmed = info.content(ctx.content).trim();
                    if quarto_divs::is_div_open(trimmed) || quarto_divs::is_div_close(trimmed) {
                        continue;
                    }
                }
                return (line_num, info.is_blank);
            }
        }
        // End of document = effectively blank-separated
        (0, true)
    }

    // Convert centralized list blocks to the format expected by perform_checks
    fn convert_list_blocks(&self, ctx: &crate::lint_context::LintContext) -> Vec<(usize, usize, String)> {
        let mut blocks: Vec<(usize, usize, String)> = Vec::new();

        for block in &ctx.list_blocks {
            // For MD032, we need to check if there are code blocks that should
            // split the list into separate segments

            // Simple approach: if there's a fenced code block between list items,
            // split at that point
            let mut segments: Vec<(usize, usize)> = Vec::new();
            let mut current_start = block.start_line;
            let mut prev_item_line = 0;

            // Helper to get blockquote level (count of '>' chars) from a line
            let get_blockquote_level = |line_num: usize| -> usize {
                if line_num == 0 || line_num > ctx.lines.len() {
                    return 0;
                }
                let line_content = ctx.lines[line_num - 1].content(ctx.content);
                BLOCKQUOTE_PREFIX_RE
                    .find(line_content)
                    .map(|m| m.as_str().chars().filter(|&c| c == '>').count())
                    .unwrap_or(0)
            };

            let mut prev_bq_level = 0;

            for &item_line in &block.item_lines {
                let current_bq_level = get_blockquote_level(item_line);

                if prev_item_line > 0 {
                    // Check if blockquote level changed between items
                    let blockquote_level_changed = prev_bq_level != current_bq_level;

                    // Check if there's a standalone code fence between prev_item_line and item_line
                    // A code fence that's indented as part of a list item should NOT split the list
                    let mut has_standalone_code_fence = false;

                    // Calculate minimum indentation for list item content
                    let min_indent_for_content = if block.is_ordered {
                        // For ordered lists, content should be indented at least to align with text after marker
                        // e.g., "1. " = 3 chars, so content should be indented 3+ spaces
                        3 // Minimum for "1. "
                    } else {
                        // For unordered lists, content should be indented at least 2 spaces
                        2 // For "- " or "* "
                    };

                    for check_line in (prev_item_line + 1)..item_line {
                        if check_line - 1 < ctx.lines.len() {
                            let line = &ctx.lines[check_line - 1];
                            let line_content = line.content(ctx.content);
                            if line.in_code_block
                                && (line_content.trim().starts_with("```") || line_content.trim().starts_with("~~~"))
                            {
                                // Check if this code fence is indented as part of the list item
                                // If it's indented enough to be part of the list item, it shouldn't split
                                if line.indent < min_indent_for_content {
                                    has_standalone_code_fence = true;
                                    break;
                                }
                            }
                        }
                    }

                    if has_standalone_code_fence || blockquote_level_changed {
                        // End current segment before this item
                        segments.push((current_start, prev_item_line));
                        current_start = item_line;
                    }
                }
                prev_item_line = item_line;
                prev_bq_level = current_bq_level;
            }

            // Add the final segment
            // For the last segment, end at the last list item (not the full block end)
            if prev_item_line > 0 {
                segments.push((current_start, prev_item_line));
            }

            // Check if this list block was split by code fences
            let has_code_fence_splits = segments.len() > 1 && {
                // Check if any segments were created due to code fences
                let mut found_fence = false;
                for i in 0..segments.len() - 1 {
                    let seg_end = segments[i].1;
                    let next_start = segments[i + 1].0;
                    // Check if there's a code fence between these segments
                    for check_line in (seg_end + 1)..next_start {
                        if check_line - 1 < ctx.lines.len() {
                            let line = &ctx.lines[check_line - 1];
                            let line_content = line.content(ctx.content);
                            if line.in_code_block
                                && (line_content.trim().starts_with("```") || line_content.trim().starts_with("~~~"))
                            {
                                found_fence = true;
                                break;
                            }
                        }
                    }
                    if found_fence {
                        break;
                    }
                }
                found_fence
            };

            // Convert segments to blocks
            for (start, end) in segments.iter() {
                // Extend the end to include any continuation lines immediately after the last item
                let mut actual_end = *end;

                // If this list was split by code fences, don't extend any segments
                // They should remain as individual list items for MD032 purposes
                if !has_code_fence_splits && *end < block.end_line {
                    // Get the blockquote level for this block
                    let block_bq_level = block.blockquote_prefix.chars().filter(|&c| c == '>').count();

                    // For blockquote lists, use a simpler min_continuation_indent
                    // (the content column without the blockquote prefix portion)
                    let min_continuation_indent = if block_bq_level > 0 {
                        // For lists in blockquotes, content should align with text after marker
                        if block.is_ordered {
                            block.max_marker_width
                        } else {
                            2 // "- " or "* "
                        }
                    } else {
                        ctx.lines
                            .get(*end - 1)
                            .and_then(|line_info| line_info.list_item.as_ref())
                            .map(|item| item.content_column)
                            .unwrap_or(2)
                    };

                    for check_line in (*end + 1)..=block.end_line {
                        if check_line - 1 < ctx.lines.len() {
                            let line = &ctx.lines[check_line - 1];
                            let line_content = line.content(ctx.content);
                            // Stop at next list item or non-continuation content
                            if block.item_lines.contains(&check_line) || line.heading.is_some() {
                                break;
                            }
                            // Don't extend through code blocks
                            if line.in_code_block {
                                break;
                            }

                            // Calculate effective indent for blockquote lines
                            let effective_indent =
                                effective_indent_in_blockquote(line_content, block_bq_level, line.indent);

                            // Include indented continuation if indent meets threshold
                            if effective_indent >= min_continuation_indent {
                                actual_end = check_line;
                            }
                            // Include lazy continuation lines for structural purposes
                            // Per CommonMark, only paragraph text can be lazy continuation
                            // Thematic breaks, code fences, etc. cannot be lazy continuations
                            // Always include lazy lines in block range - the config controls whether to WARN
                            else if !line.is_blank
                                && line.heading.is_none()
                                && !block.item_lines.contains(&check_line)
                                && !is_thematic_break(line_content)
                            {
                                // This is a lazy continuation line - include it in the block range
                                actual_end = check_line;
                            } else if !line.is_blank {
                                // Non-blank line that's not a continuation - stop here
                                break;
                            }
                        }
                    }
                }

                blocks.push((*start, actual_end, block.blockquote_prefix.clone()));
            }
        }

        // Filter out lists entirely inside HTML comments
        blocks.retain(|(start, end, _)| {
            // Check if ALL lines of this block are inside HTML comments
            let all_in_comment =
                (*start..=*end).all(|line_num| ctx.lines.get(line_num - 1).is_some_and(|info| info.in_html_comment));
            !all_in_comment
        });

        blocks
    }

    fn perform_checks(
        &self,
        ctx: &crate::lint_context::LintContext,
        lines: &[&str],
        list_blocks: &[(usize, usize, String)],
        line_index: &LineIndex,
    ) -> LintResult {
        let mut warnings = Vec::new();
        let num_lines = lines.len();

        // Check for ordered lists starting with non-1 that aren't recognized as lists
        // These need blank lines before them to be parsed as lists by CommonMark
        for (line_idx, line) in lines.iter().enumerate() {
            let line_num = line_idx + 1;

            // Skip if this line is already part of a recognized list
            let is_in_list = list_blocks
                .iter()
                .any(|(start, end, _)| line_num >= *start && line_num <= *end);
            if is_in_list {
                continue;
            }

            // Skip if in code block, front matter, or HTML comment
            if ctx
                .line_info(line_num)
                .is_some_and(|info| info.in_code_block || info.in_front_matter || info.in_html_comment)
            {
                continue;
            }

            // Check if this line starts with a number other than 1
            if ORDERED_LIST_NON_ONE_RE.is_match(line) {
                // Check if there's a blank line before this
                if line_idx > 0 {
                    let prev_line = lines[line_idx - 1];
                    let prev_is_blank = is_blank_in_context(prev_line);
                    let prev_excluded = ctx
                        .line_info(line_idx)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter);

                    // Check if previous line looks like a sentence continuation
                    // If the previous line is non-blank text that doesn't end with a sentence
                    // terminator, this is likely a paragraph continuation, not a list item
                    // e.g., "...in Chapter\n19. For now..." is a broken sentence, not a list
                    let prev_trimmed = prev_line.trim();
                    let is_sentence_continuation = !prev_is_blank
                        && !prev_trimmed.is_empty()
                        && !prev_trimmed.ends_with('.')
                        && !prev_trimmed.ends_with('!')
                        && !prev_trimmed.ends_with('?')
                        && !prev_trimmed.ends_with(':')
                        && !prev_trimmed.ends_with(';')
                        && !prev_trimmed.ends_with('>')
                        && !prev_trimmed.ends_with('-')
                        && !prev_trimmed.ends_with('*');

                    if !prev_is_blank && !prev_excluded && !is_sentence_continuation {
                        // This ordered list item starting with non-1 needs a blank line before it
                        let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line);

                        let bq_prefix = ctx.blockquote_prefix_for_blank_line(line_idx);
                        warnings.push(LintWarning {
                            line: start_line,
                            column: start_col,
                            end_line,
                            end_column: end_col,
                            severity: Severity::Warning,
                            rule_name: Some(self.name().to_string()),
                            message: "Ordered list starting with non-1 should be preceded by blank line".to_string(),
                            fix: Some(Fix {
                                range: line_index.line_col_to_byte_range_with_length(line_num, 1, 0),
                                replacement: format!("{bq_prefix}\n"),
                            }),
                        });
                    }

                    // Also check if a blank line is needed AFTER this ordered list item
                    // This ensures single-pass idempotency
                    if line_idx + 1 < num_lines {
                        let next_line = lines[line_idx + 1];
                        let next_is_blank = is_blank_in_context(next_line);
                        let next_excluded = ctx
                            .line_info(line_idx + 2)
                            .is_some_and(|info| info.in_code_block || info.in_front_matter);

                        if !next_is_blank && !next_excluded && !next_line.trim().is_empty() {
                            // Check if next line is part of this potential list (continuation or another item)
                            let next_is_list_content = ORDERED_LIST_NON_ONE_RE.is_match(next_line)
                                || next_line.trim_start().starts_with("- ")
                                || next_line.trim_start().starts_with("* ")
                                || next_line.trim_start().starts_with("+ ")
                                || next_line.starts_with("1. ")
                                || (next_line.len() > next_line.trim_start().len()); // indented continuation

                            if !next_is_list_content {
                                let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line);
                                let bq_prefix = ctx.blockquote_prefix_for_blank_line(line_idx);
                                warnings.push(LintWarning {
                                    line: start_line,
                                    column: start_col,
                                    end_line,
                                    end_column: end_col,
                                    severity: Severity::Warning,
                                    rule_name: Some(self.name().to_string()),
                                    message: "List should be followed by blank line".to_string(),
                                    fix: Some(Fix {
                                        range: line_index.line_col_to_byte_range_with_length(line_num + 1, 1, 0),
                                        replacement: format!("{bq_prefix}\n"),
                                    }),
                                });
                            }
                        }
                    }
                }
            }
        }

        for &(start_line, end_line, ref prefix) in list_blocks {
            // Skip lists that start inside HTML comments
            if ctx.line_info(start_line).is_some_and(|info| info.in_html_comment) {
                continue;
            }

            if start_line > 1 {
                // Look past HTML comments to find actual preceding content
                let (content_line, has_blank_separation) = Self::find_preceding_content(ctx, start_line);

                // If blank separation exists (through HTML comments), no warning needed
                if !has_blank_separation && content_line > 0 {
                    let prev_line_str = lines[content_line - 1];
                    let is_prev_excluded = ctx
                        .line_info(content_line)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter);
                    let prev_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(prev_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());
                    let prefixes_match = prev_prefix.trim() == prefix.trim();

                    // Only require blank lines for content in the same context (same blockquote level)
                    // and when the context actually requires it
                    let should_require = Self::should_require_blank_line_before(ctx, content_line, start_line);
                    if !is_prev_excluded && prefixes_match && should_require {
                        // Calculate precise character range for the entire list line that needs a blank line before it
                        let (start_line, start_col, end_line, end_col) =
                            calculate_line_range(start_line, lines[start_line - 1]);

                        warnings.push(LintWarning {
                            line: start_line,
                            column: start_col,
                            end_line,
                            end_column: end_col,
                            severity: Severity::Warning,
                            rule_name: Some(self.name().to_string()),
                            message: "List should be preceded by blank line".to_string(),
                            fix: Some(Fix {
                                range: line_index.line_col_to_byte_range_with_length(start_line, 1, 0),
                                replacement: format!("{prefix}\n"),
                            }),
                        });
                    }
                }
            }

            if end_line < num_lines {
                // Look past HTML comments to find actual following content
                let (content_line, has_blank_separation) = Self::find_following_content(ctx, end_line);

                // If blank separation exists (through HTML comments), no warning needed
                if !has_blank_separation && content_line > 0 {
                    let next_line_str = lines[content_line - 1];
                    // Check if next line is excluded - front matter or indented code blocks within lists
                    // We want blank lines before standalone code blocks, but not within list items
                    let is_next_excluded = ctx.line_info(content_line).is_some_and(|info| info.in_front_matter)
                        || (content_line <= ctx.lines.len()
                            && ctx.lines[content_line - 1].in_code_block
                            && ctx.lines[content_line - 1].indent >= 2);
                    let next_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(next_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());

                    // Check blockquote levels to detect boundary transitions
                    // If the list ends inside a blockquote but the following line exits the blockquote
                    // (fewer > chars in prefix), no blank line is needed - the blockquote boundary
                    // provides semantic separation
                    let end_line_str = lines[end_line - 1];
                    let end_line_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(end_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());
                    let end_line_bq_level = end_line_prefix.chars().filter(|&c| c == '>').count();
                    let next_line_bq_level = next_prefix.chars().filter(|&c| c == '>').count();
                    let exits_blockquote = end_line_bq_level > 0 && next_line_bq_level < end_line_bq_level;

                    let prefixes_match = next_prefix.trim() == prefix.trim();

                    // Only require blank lines for content in the same context (same blockquote level)
                    // Skip if the following line exits a blockquote - boundary provides separation
                    if !is_next_excluded && prefixes_match && !exits_blockquote {
                        // Calculate precise character range for the last line of the list (not the line after)
                        let (start_line_last, start_col_last, end_line_last, end_col_last) =
                            calculate_line_range(end_line, lines[end_line - 1]);

                        warnings.push(LintWarning {
                            line: start_line_last,
                            column: start_col_last,
                            end_line: end_line_last,
                            end_column: end_col_last,
                            severity: Severity::Warning,
                            rule_name: Some(self.name().to_string()),
                            message: "List should be followed by blank line".to_string(),
                            fix: Some(Fix {
                                range: line_index.line_col_to_byte_range_with_length(end_line + 1, 1, 0),
                                replacement: format!("{prefix}\n"),
                            }),
                        });
                    }
                }
            }
        }
        Ok(warnings)
    }
}

impl Rule for MD032BlanksAroundLists {
    fn name(&self) -> &'static str {
        "MD032"
    }

    fn description(&self) -> &'static str {
        "Lists should be surrounded by blank lines"
    }

    fn check(&self, ctx: &crate::lint_context::LintContext) -> LintResult {
        let content = ctx.content;
        let lines: Vec<&str> = content.lines().collect();
        let line_index = &ctx.line_index;

        // Early return for empty content
        if lines.is_empty() {
            return Ok(Vec::new());
        }

        let list_blocks = self.convert_list_blocks(ctx);

        if list_blocks.is_empty() {
            return Ok(Vec::new());
        }

        let mut warnings = self.perform_checks(ctx, &lines, &list_blocks, line_index)?;

        // When lazy continuation is not allowed, detect and warn about lazy continuation
        // lines WITHIN list blocks (text that continues a list item but with less
        // indentation than expected). Lazy continuation at the END of list blocks is
        // already handled by the segment extension logic above.
        if !self.config.allow_lazy_continuation {
            let lazy_lines = Self::detect_lazy_continuation_lines(ctx);

            for (line_num, lazy_info) in lazy_lines {
                // Only warn about lazy continuation lines that are WITHIN a list block
                // (i.e., between list items). End-of-block lazy continuation is already
                // handled by the existing "list should be followed by blank line" logic.
                let is_within_block = list_blocks
                    .iter()
                    .any(|(start, end, _)| line_num >= *start && line_num <= *end);

                if !is_within_block {
                    continue;
                }

                // Get the expected indent for context in the warning message
                let line_content = lines.get(line_num.saturating_sub(1)).unwrap_or(&"");
                let (start_line, start_col, end_line, end_col) = calculate_line_range(line_num, line_content);

                // Calculate fix: add proper indentation to the lazy continuation line
                let fix = if Self::should_apply_lazy_fix(ctx, line_num) {
                    Self::calculate_lazy_continuation_fix(ctx, line_num, &lazy_info)
                } else {
                    None
                };

                warnings.push(LintWarning {
                    line: start_line,
                    column: start_col,
                    end_line,
                    end_column: end_col,
                    severity: Severity::Warning,
                    rule_name: Some(self.name().to_string()),
                    message: "Lazy continuation line should be properly indented or preceded by blank line".to_string(),
                    fix,
                });
            }
        }

        Ok(warnings)
    }

    fn fix(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
        self.fix_with_structure_impl(ctx)
    }

    fn should_skip(&self, ctx: &crate::lint_context::LintContext) -> bool {
        // Fast path: check if document likely has lists
        if ctx.content.is_empty() || !ctx.likely_has_lists() {
            return true;
        }
        // Verify list blocks actually exist
        ctx.list_blocks.is_empty()
    }

    fn category(&self) -> RuleCategory {
        RuleCategory::List
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    fn default_config_section(&self) -> Option<(String, toml::Value)> {
        use crate::rule_config_serde::RuleConfig;
        let default_config = MD032Config::default();
        let json_value = serde_json::to_value(&default_config).ok()?;
        let toml_value = crate::rule_config_serde::json_to_toml_value(&json_value)?;

        if let toml::Value::Table(table) = toml_value {
            if !table.is_empty() {
                Some((MD032Config::RULE_NAME.to_string(), toml::Value::Table(table)))
            } else {
                None
            }
        } else {
            None
        }
    }

    fn from_config(config: &crate::config::Config) -> Box<dyn Rule>
    where
        Self: Sized,
    {
        let rule_config = crate::rule_config_serde::load_rule_config::<MD032Config>(config);
        Box::new(MD032BlanksAroundLists::from_config_struct(rule_config))
    }
}

impl MD032BlanksAroundLists {
    /// Helper method for fixing implementation
    fn fix_with_structure_impl(&self, ctx: &crate::lint_context::LintContext) -> Result<String, LintError> {
        let lines: Vec<&str> = ctx.content.lines().collect();
        let num_lines = lines.len();
        if num_lines == 0 {
            return Ok(String::new());
        }

        let list_blocks = self.convert_list_blocks(ctx);
        if list_blocks.is_empty() {
            return Ok(ctx.content.to_string());
        }

        // Phase 0: Collect lazy continuation line fixes (if not allowed)
        // Map of line_num -> LazyContInfo for applying fixes
        let mut lazy_fixes: std::collections::BTreeMap<usize, LazyContInfo> = std::collections::BTreeMap::new();
        if !self.config.allow_lazy_continuation {
            let lazy_lines = Self::detect_lazy_continuation_lines(ctx);
            for (line_num, lazy_info) in lazy_lines {
                // Only fix lines within a list block
                let is_within_block = list_blocks
                    .iter()
                    .any(|(start, end, _)| line_num >= *start && line_num <= *end);
                if !is_within_block {
                    continue;
                }
                // Only fix if not in code block, front matter, or HTML comment
                if !Self::should_apply_lazy_fix(ctx, line_num) {
                    continue;
                }
                lazy_fixes.insert(line_num, lazy_info);
            }
        }

        let mut insertions: std::collections::BTreeMap<usize, String> = std::collections::BTreeMap::new();

        // Phase 1: Identify needed insertions
        for &(start_line, end_line, ref prefix) in &list_blocks {
            // Skip lists that start inside HTML comments
            if ctx.line_info(start_line).is_some_and(|info| info.in_html_comment) {
                continue;
            }

            // Check before block
            if start_line > 1 {
                // Look past HTML comments to find actual preceding content
                let (content_line, has_blank_separation) = Self::find_preceding_content(ctx, start_line);

                // If blank separation exists (through HTML comments), no fix needed
                if !has_blank_separation && content_line > 0 {
                    let prev_line_str = lines[content_line - 1];
                    let is_prev_excluded = ctx
                        .line_info(content_line)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter);
                    let prev_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(prev_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());

                    let should_require = Self::should_require_blank_line_before(ctx, content_line, start_line);
                    // Compare trimmed prefixes to handle varying whitespace after > markers
                    if !is_prev_excluded && prev_prefix.trim() == prefix.trim() && should_require {
                        // Use centralized helper for consistent blockquote prefix (no trailing space)
                        let bq_prefix = ctx.blockquote_prefix_for_blank_line(start_line - 1);
                        insertions.insert(start_line, bq_prefix);
                    }
                }
            }

            // Check after block
            if end_line < num_lines {
                // Look past HTML comments to find actual following content
                let (content_line, has_blank_separation) = Self::find_following_content(ctx, end_line);

                // If blank separation exists (through HTML comments), no fix needed
                if !has_blank_separation && content_line > 0 {
                    let next_line_str = lines[content_line - 1];
                    // Check if next line is excluded - in code block, front matter, or starts an indented code block
                    let is_next_excluded = ctx
                        .line_info(content_line)
                        .is_some_and(|info| info.in_code_block || info.in_front_matter)
                        || (content_line <= ctx.lines.len()
                            && ctx.lines[content_line - 1].in_code_block
                            && ctx.lines[content_line - 1].indent >= 2
                            && (ctx.lines[content_line - 1]
                                .content(ctx.content)
                                .trim()
                                .starts_with("```")
                                || ctx.lines[content_line - 1]
                                    .content(ctx.content)
                                    .trim()
                                    .starts_with("~~~")));
                    let next_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(next_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());

                    // Check blockquote levels to detect boundary transitions
                    let end_line_str = lines[end_line - 1];
                    let end_line_prefix = BLOCKQUOTE_PREFIX_RE
                        .find(end_line_str)
                        .map_or(String::new(), |m| m.as_str().to_string());
                    let end_line_bq_level = end_line_prefix.chars().filter(|&c| c == '>').count();
                    let next_line_bq_level = next_prefix.chars().filter(|&c| c == '>').count();
                    let exits_blockquote = end_line_bq_level > 0 && next_line_bq_level < end_line_bq_level;

                    // Compare trimmed prefixes to handle varying whitespace after > markers
                    // Skip if exiting a blockquote - boundary provides separation
                    if !is_next_excluded && next_prefix.trim() == prefix.trim() && !exits_blockquote {
                        // Use centralized helper for consistent blockquote prefix (no trailing space)
                        let bq_prefix = ctx.blockquote_prefix_for_blank_line(end_line - 1);
                        insertions.insert(end_line + 1, bq_prefix);
                    }
                }
            }
        }

        // Phase 2: Reconstruct with insertions and lazy fixes
        let mut result_lines: Vec<String> = Vec::with_capacity(num_lines + insertions.len());
        for (i, line) in lines.iter().enumerate() {
            let current_line_num = i + 1;
            if let Some(prefix_to_insert) = insertions.get(&current_line_num)
                && (result_lines.is_empty() || result_lines.last().unwrap() != prefix_to_insert)
            {
                result_lines.push(prefix_to_insert.clone());
            }

            // Apply lazy continuation fix if needed
            if let Some(lazy_info) = lazy_fixes.get(&current_line_num) {
                let fixed_line = Self::apply_lazy_fix_to_line(line, lazy_info);
                result_lines.push(fixed_line);
            } else {
                result_lines.push(line.to_string());
            }
        }

        // Preserve the final newline if the original content had one
        let mut result = result_lines.join("\n");
        if ctx.content.ends_with('\n') {
            result.push('\n');
        }
        Ok(result)
    }
}

// Checks if a line is blank, considering blockquote context
fn is_blank_in_context(line: &str) -> bool {
    // A line is blank if it's empty or contains only whitespace,
    // potentially after removing blockquote markers.
    if let Some(m) = BLOCKQUOTE_PREFIX_RE.find(line) {
        // If a blockquote prefix is found, check if the content *after* the prefix is blank.
        line[m.end()..].trim().is_empty()
    } else {
        // No blockquote prefix, check the whole line for blankness.
        line.trim().is_empty()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lint_context::LintContext;
    use crate::rule::Rule;

    fn lint(content: &str) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.check(&ctx).expect("Lint check failed")
    }

    fn fix(content: &str) -> String {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.fix(&ctx).expect("Lint fix failed")
    }

    // Test that warnings include Fix objects
    fn check_warnings_have_fixes(content: &str) {
        let warnings = lint(content);
        for warning in &warnings {
            assert!(warning.fix.is_some(), "Warning should have fix: {warning:?}");
        }
    }

    #[test]
    fn test_list_at_start() {
        // Per markdownlint-cli: trailing text without blank line is treated as lazy continuation
        // so NO warning is expected here
        let content = "- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Trailing text is lazy continuation per CommonMark - no warning expected"
        );
    }

    #[test]
    fn test_list_at_end() {
        let content = "Text\n- Item 1\n- Item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list at end without preceding blank line"
        );
        assert_eq!(
            warnings[0].line, 2,
            "Warning should be on the first line of the list (line 2)"
        );
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warning has fix
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n- Item 1\n- Item 2");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_list_in_middle() {
        // Per markdownlint-cli: only preceding blank line is required
        // Trailing text is treated as lazy continuation
        let content = "Text 1\n- Item 1\n- Item 2\nText 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list needing preceding blank line (trailing text is lazy continuation)"
        );
        assert_eq!(warnings[0].line, 2, "Warning on line 2 (start)");
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text 1\n\n- Item 1\n- Item 2\nText 2");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_correct_spacing() {
        let content = "Text 1\n\n- Item 1\n- Item 2\n\nText 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Expected no warnings for correctly spaced list");

        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "Fix should not change correctly spaced content");
    }

    #[test]
    fn test_list_with_content() {
        // Per markdownlint-cli: only preceding blank line warning
        // Trailing text is lazy continuation
        let content = "Text\n* Item 1\n  Content\n* Item 2\n  More content\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for list needing preceding blank line. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2, "Warning should be on line 2 (start)");
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected_fixed = "Text\n\n* Item 1\n  Content\n* Item 2\n  More content\nText";
        assert_eq!(
            fixed_content, expected_fixed,
            "Fix did not produce the expected output. Got:\n{fixed_content}"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_nested_list() {
        // Per markdownlint-cli: only preceding blank line warning
        let content = "Text\n- Item 1\n  - Nested 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Nested list block needs preceding blank only. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n- Item 1\n  - Nested 1\n- Item 2\nText");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_list_with_internal_blanks() {
        // Per markdownlint-cli: only preceding blank line warning
        let content = "Text\n* Item 1\n\n  More Item 1 Content\n* Item 2\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "List with internal blanks needs preceding blank only. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);
        assert!(warnings[0].message.contains("preceded by blank line"));

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(
            fixed_content,
            "Text\n\n* Item 1\n\n  More Item 1 Content\n* Item 2\nText"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_ignore_code_blocks() {
        let content = "```\n- Not a list item\n```\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    #[test]
    fn test_ignore_front_matter() {
        // Per markdownlint-cli: NO warnings - front matter is followed by list, trailing text is lazy continuation
        let content = "---\ntitle: Test\n---\n- List Item\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Front matter test should have no MD032 warnings. Got: {warnings:?}"
        );

        // No fixes needed since no warnings
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "No changes when no warnings");
    }

    #[test]
    fn test_multiple_lists() {
        // Our implementation treats "Text 2" and "Text 3" as lazy continuation within a single merged list block
        // (since both - and * are unordered markers and there's no structural separator)
        // markdownlint-cli sees them as separate lists with 3 warnings, but our behavior differs.
        // The key requirement is that the fix resolves all warnings.
        let content = "Text\n- List 1 Item 1\n- List 1 Item 2\nText 2\n* List 2 Item 1\nText 3";
        let warnings = lint(content);
        // At minimum we should warn about missing preceding blank for line 2
        assert!(
            !warnings.is_empty(),
            "Should have at least one warning for missing blank line. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // The fix should add blank lines before lists that need them
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_adjacent_lists() {
        let content = "- List 1\n\n* List 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    #[test]
    fn test_list_in_blockquote() {
        // Per markdownlint-cli: 1 warning (preceding only, trailing is lazy continuation)
        let content = "> Quote line 1\n> - List item 1\n> - List item 2\n> Quote line 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Expected 1 warning for blockquoted list needing preceding blank. Got: {warnings:?}"
        );
        assert_eq!(warnings[0].line, 2);

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Fix should add blank line before list only (no trailing space per markdownlint-cli)
        assert_eq!(
            fixed_content, "> Quote line 1\n>\n> - List item 1\n> - List item 2\n> Quote line 2",
            "Fix for blockquoted list failed. Got:\n{fixed_content}"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_ordered_list() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n1. Item 1\n2. Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1);

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        assert_eq!(fixed_content, "Text\n\n1. Item 1\n2. Item 2\nText");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_no_double_blank_fix() {
        // Per markdownlint-cli: trailing text is lazy continuation, so NO warning needed
        let content = "Text\n\n- Item 1\n- Item 2\nText"; // Has preceding blank, trailing is lazy
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should have no warnings - properly preceded, trailing is lazy"
        );

        let fixed_content = fix(content);
        assert_eq!(
            fixed_content, content,
            "No fix needed when no warnings. Got:\n{fixed_content}"
        );

        let content2 = "Text\n- Item 1\n- Item 2\n\nText"; // Missing blank before
        let warnings2 = lint(content2);
        assert_eq!(warnings2.len(), 1);
        if !warnings2.is_empty() {
            assert_eq!(
                warnings2[0].line, 2,
                "Warning line for missing blank before should be the first line of the block"
            );
        }

        // Test that warnings have fixes
        check_warnings_have_fixes(content2);

        let fixed_content2 = fix(content2);
        assert_eq!(
            fixed_content2, "Text\n\n- Item 1\n- Item 2\n\nText",
            "Fix added extra blank before. Got:\n{fixed_content2}"
        );
    }

    #[test]
    fn test_empty_input() {
        let content = "";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, "");
    }

    #[test]
    fn test_only_list() {
        let content = "- Item 1\n- Item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0);
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content);
    }

    // === COMPREHENSIVE FIX TESTS ===

    #[test]
    fn test_fix_complex_nested_blockquote() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "> Text before\n> - Item 1\n>   - Nested item\n> - Item 2\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for missing preceding blank only. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Per markdownlint-cli, blank lines in blockquotes have no trailing space
        let expected = "> Text before\n>\n> - Item 1\n>   - Nested item\n> - Item 2\n> Text after";
        assert_eq!(fixed_content, expected, "Fix should preserve blockquote structure");

        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should eliminate all warnings");
    }

    #[test]
    fn test_fix_mixed_list_markers() {
        // Per markdownlint-cli: mixed markers may be treated as separate lists
        // The exact behavior depends on implementation details
        let content = "Text\n- Item 1\n* Item 2\n+ Item 3\nText";
        let warnings = lint(content);
        // At minimum, there should be a warning for the first list needing preceding blank
        assert!(
            !warnings.is_empty(),
            "Should have at least 1 warning for mixed marker list. Got: {warnings:?}"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // The fix should add at least a blank line before the first list
        assert!(
            fixed_content.contains("Text\n\n-"),
            "Fix should add blank line before first list item"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_ordered_list_with_different_numbers() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n1. First\n3. Third\n2. Second\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n1. First\n3. Third\n2. Second\nText";
        assert_eq!(
            fixed_content, expected,
            "Fix should handle ordered lists with non-sequential numbers"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_with_code_blocks_inside() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n- Item 1\n  ```\n  code\n  ```\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Item 1\n  ```\n  code\n  ```\n- Item 2\nText";
        assert_eq!(
            fixed_content, expected,
            "Fix should handle lists with internal code blocks"
        );

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_deeply_nested_lists() {
        // Per markdownlint-cli: 1 warning (preceding only)
        let content = "Text\n- Level 1\n  - Level 2\n    - Level 3\n      - Level 4\n- Back to Level 1\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should warn for missing preceding blank only");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Level 1\n  - Level 2\n    - Level 3\n      - Level 4\n- Back to Level 1\nText";
        assert_eq!(fixed_content, expected, "Fix should handle deeply nested lists");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_with_multiline_items() {
        // Per markdownlint-cli: trailing "Text" at indent=0 is lazy continuation
        // Only the preceding blank line is required
        let content = "Text\n- Item 1\n  continues here\n  and here\n- Item 2\n  also continues\nText";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should only warn for missing blank before list (trailing text is lazy continuation)"
        );

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        let expected = "Text\n\n- Item 1\n  continues here\n  and here\n- Item 2\n  also continues\nText";
        assert_eq!(fixed_content, expected, "Fix should add blank before list only");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_list_at_document_boundaries() {
        // List at very start
        let content1 = "- Item 1\n- Item 2";
        let warnings1 = lint(content1);
        assert_eq!(
            warnings1.len(),
            0,
            "List at document start should not need blank before"
        );
        let fixed1 = fix(content1);
        assert_eq!(fixed1, content1, "No fix needed for list at start");

        // List at very end
        let content2 = "Text\n- Item 1\n- Item 2";
        let warnings2 = lint(content2);
        assert_eq!(warnings2.len(), 1, "List at document end should need blank before");
        check_warnings_have_fixes(content2);
        let fixed2 = fix(content2);
        assert_eq!(
            fixed2, "Text\n\n- Item 1\n- Item 2",
            "Should add blank before list at end"
        );
    }

    #[test]
    fn test_fix_preserves_existing_blank_lines() {
        let content = "Text\n\n\n- Item 1\n- Item 2\n\n\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Multiple blank lines should be preserved");
        let fixed_content = fix(content);
        assert_eq!(fixed_content, content, "Fix should not modify already correct content");
    }

    #[test]
    fn test_fix_handles_tabs_and_spaces() {
        // Tab at line start = 4 spaces = indented code (not a list item per CommonMark)
        // Only the space-indented line is a real list item
        let content = "Text\n\t- Item with tab\n  - Item with spaces\nText";
        let warnings = lint(content);
        // Per markdownlint-cli: only line 3 (space-indented) is a list needing blanks
        assert!(!warnings.is_empty(), "Should warn for missing blank before list");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Add blank before the actual list item (line 3), not the tab-indented code (line 2)
        // Trailing text is lazy continuation, so no blank after
        let expected = "Text\n\t- Item with tab\n\n  - Item with spaces\nText";
        assert_eq!(fixed_content, expected, "Fix should add blank before list item");

        // Verify fix resolves the issue
        let warnings_after_fix = lint(&fixed_content);
        assert_eq!(warnings_after_fix.len(), 0, "Fix should resolve all warnings");
    }

    #[test]
    fn test_fix_warning_objects_have_correct_ranges() {
        // Per markdownlint-cli: trailing text is lazy continuation, only 1 warning
        let content = "Text\n- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Only preceding blank warning expected");

        // Check that each warning has a fix with a valid range
        for warning in &warnings {
            assert!(warning.fix.is_some(), "Warning should have fix");
            let fix = warning.fix.as_ref().unwrap();
            assert!(fix.range.start <= fix.range.end, "Fix range should be valid");
            assert!(
                !fix.replacement.is_empty() || fix.range.start == fix.range.end,
                "Fix should have replacement or be insertion"
            );
        }
    }

    #[test]
    fn test_fix_idempotent() {
        // Per markdownlint-cli: trailing text is lazy continuation
        let content = "Text\n- Item 1\n- Item 2\nText";

        // Apply fix once - only adds blank before (trailing text is lazy continuation)
        let fixed_once = fix(content);
        assert_eq!(fixed_once, "Text\n\n- Item 1\n- Item 2\nText");

        // Apply fix again - should be unchanged
        let fixed_twice = fix(&fixed_once);
        assert_eq!(fixed_twice, fixed_once, "Fix should be idempotent");

        // No warnings after fix
        let warnings_after_fix = lint(&fixed_once);
        assert_eq!(warnings_after_fix.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_fix_with_normalized_line_endings() {
        // In production, content is normalized to LF at I/O boundary
        // Unit tests should use LF input to reflect actual runtime behavior
        // Per markdownlint-cli: trailing text is lazy continuation, only 1 warning
        let content = "Text\n- Item 1\n- Item 2\nText";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 1, "Should detect missing blank before list");

        // Test that warnings have fixes
        check_warnings_have_fixes(content);

        let fixed_content = fix(content);
        // Only adds blank before (trailing text is lazy continuation)
        let expected = "Text\n\n- Item 1\n- Item 2\nText";
        assert_eq!(fixed_content, expected, "Fix should work with normalized LF content");
    }

    #[test]
    fn test_fix_preserves_final_newline() {
        // Per markdownlint-cli: trailing text is lazy continuation
        // Test with final newline
        let content_with_newline = "Text\n- Item 1\n- Item 2\nText\n";
        let fixed_with_newline = fix(content_with_newline);
        assert!(
            fixed_with_newline.ends_with('\n'),
            "Fix should preserve final newline when present"
        );
        // Only adds blank before (trailing text is lazy continuation)
        assert_eq!(fixed_with_newline, "Text\n\n- Item 1\n- Item 2\nText\n");

        // Test without final newline
        let content_without_newline = "Text\n- Item 1\n- Item 2\nText";
        let fixed_without_newline = fix(content_without_newline);
        assert!(
            !fixed_without_newline.ends_with('\n'),
            "Fix should not add final newline when not present"
        );
        // Only adds blank before (trailing text is lazy continuation)
        assert_eq!(fixed_without_newline, "Text\n\n- Item 1\n- Item 2\nText");
    }

    #[test]
    fn test_fix_multiline_list_items_no_indent() {
        let content = "## Configuration\n\nThis rule has the following configuration options:\n\n- `option1`: Description that continues\non the next line without indentation.\n- `option2`: Another description that also continues\non the next line.\n\n## Next Section";

        let warnings = lint(content);
        // Should only warn about missing blank lines around the entire list, not between items
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn for properly formatted list with multi-line items. Got: {warnings:?}"
        );

        let fixed_content = fix(content);
        // Should not change the content since it's already correct
        assert_eq!(
            fixed_content, content,
            "Should not modify correctly formatted multi-line list items"
        );
    }

    #[test]
    fn test_nested_list_with_lazy_continuation() {
        // Issue #188: Nested list following a lazy continuation line should not require blank lines
        // This matches markdownlint-cli behavior which does NOT warn on this pattern
        //
        // The key element is line 6 (`!=`), ternary...) which is a lazy continuation of line 5.
        // Line 6 contains `||` inside code spans, which should NOT be detected as a table separator.
        let content = r#"# Test

- **Token Dispatch (Phase 3.2)**: COMPLETE. Extracts tokens from both:
  1. Switch/case dispatcher statements (original Phase 3.2)
  2. Inline conditionals - if/else, bitwise checks (`&`, `|`), comparison (`==`,
`!=`), ternary operators (`?:`), macros (`ISTOK`, `ISUNSET`), compound conditions (`&&`, `||`) (Phase 3.2.1)
     - 30 explicit tokens extracted, 23 dispatcher rules with embedded token
       references"#;

        let warnings = lint(content);
        // No MD032 warnings should be generated - this is a valid nested list structure
        // with lazy continuation (line 6 has no indent but continues line 5)
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Should not warn for nested list with lazy continuation. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_pipes_in_code_spans_not_detected_as_table() {
        // Pipes inside code spans should NOT break lists
        let content = r#"# Test

- Item with `a | b` inline code
  - Nested item should work

"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Pipes in code spans should not break lists. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_multiple_code_spans_with_pipes() {
        // Multiple code spans with pipes should not break lists
        let content = r#"# Test

- Item with `a | b` and `c || d` operators
  - Nested item should work

"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Multiple code spans with pipes should not break lists. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_actual_table_breaks_list() {
        // An actual table between list items SHOULD break the list
        let content = r#"# Test

- Item before table

| Col1 | Col2 |
|------|------|
| A    | B    |

- Item after table

"#;

        let warnings = lint(content);
        // There should be NO MD032 warnings because both lists are properly surrounded by blank lines
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Both lists should be properly separated by blank lines. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_thematic_break_not_lazy_continuation() {
        // Thematic breaks (HRs) cannot be lazy continuation per CommonMark
        // List followed by HR without blank line should warn
        let content = r#"- Item 1
- Item 2
***

More text.
"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            1,
            "Should warn for list not followed by blank line before thematic break. Got: {md032_warnings:?}"
        );
        assert!(
            md032_warnings[0].message.contains("followed by blank line"),
            "Warning should be about missing blank after list"
        );
    }

    #[test]
    fn test_thematic_break_with_blank_line() {
        // List followed by blank line then HR should NOT warn
        let content = r#"- Item 1
- Item 2

***

More text.
"#;

        let warnings = lint(content);
        let md032_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.rule_name.as_deref() == Some("MD032"))
            .collect();
        assert_eq!(
            md032_warnings.len(),
            0,
            "Should not warn when list is properly followed by blank line. Got: {md032_warnings:?}"
        );
    }

    #[test]
    fn test_various_thematic_break_styles() {
        // Test different HR styles are all recognized
        // Note: Spaced styles like "- - -" and "* * *" are excluded because they start
        // with list markers ("- " or "* ") which get parsed as list items by the
        // upstream CommonMark parser. That's a separate parsing issue.
        for hr in ["---", "***", "___"] {
            let content = format!(
                r#"- Item 1
- Item 2
{hr}

More text.
"#
            );

            let warnings = lint(&content);
            let md032_warnings: Vec<_> = warnings
                .iter()
                .filter(|w| w.rule_name.as_deref() == Some("MD032"))
                .collect();
            assert_eq!(
                md032_warnings.len(),
                1,
                "Should warn for HR style '{hr}' without blank line. Got: {md032_warnings:?}"
            );
        }
    }

    // === LAZY CONTINUATION TESTS ===

    fn lint_with_config(content: &str, config: MD032Config) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::from_config_struct(config);
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.check(&ctx).expect("Lint check failed")
    }

    fn fix_with_config(content: &str, config: MD032Config) -> String {
        let rule = MD032BlanksAroundLists::from_config_struct(config);
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Standard, None);
        rule.fix(&ctx).expect("Lint fix failed")
    }

    #[test]
    fn test_lazy_continuation_allowed_by_default() {
        // Default behavior: lazy continuation is allowed, no warning
        let content = "# Heading\n\n1. List\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Default behavior should allow lazy continuation. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_disallowed() {
        // With allow_lazy_continuation = false, should warn about lazy continuation
        let content = "# Heading\n\n1. List\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn when lazy continuation is disallowed. Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("Lazy continuation"),
            "Warning message should mention lazy continuation"
        );
        assert_eq!(warnings[0].line, 4, "Warning should be on the lazy line");
    }

    #[test]
    fn test_lazy_continuation_fix() {
        // With allow_lazy_continuation = false, fix should add proper indentation
        let content = "# Heading\n\n1. List\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed = fix_with_config(content, config.clone());
        // Fix adds proper indentation (3 spaces for "1. " marker width)
        assert_eq!(
            fixed, "# Heading\n\n1. List\n   Some text.",
            "Fix should add proper indentation to lazy continuation"
        );

        // Verify no warnings after fix
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_multiple_lines() {
        // Multiple lazy continuation lines - each gets its own warning
        let content = "- Item 1\nLine 2\nLine 3";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Both Line 2 and Line 3 are lazy continuation lines
        assert_eq!(
            warnings.len(),
            2,
            "Should warn for each lazy continuation line. Got: {warnings:?}"
        );

        let fixed = fix_with_config(content, config.clone());
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(
            fixed, "- Item 1\n  Line 2\n  Line 3",
            "Fix should add proper indentation to lazy continuation lines"
        );

        // Verify no warnings after fix
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_with_indented_content() {
        // Indented content is valid continuation, not lazy continuation
        let content = "- Item 1\n  Indented content\nLazy text";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for lazy text after indented content. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_properly_separated() {
        // With proper blank line, no warning even with strict config
        let content = "- Item 1\n\nSome text.";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when list is properly followed by blank line. Got: {warnings:?}"
        );
    }

    // ==================== Comprehensive edge case tests ====================

    #[test]
    fn test_lazy_continuation_ordered_list_parenthesis_marker() {
        // Ordered list with parenthesis marker (1) instead of period
        let content = "1) First item\nLazy continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for lazy continuation with parenthesis marker"
        );

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (3 spaces for "1) " marker)
        assert_eq!(fixed, "1) First item\n   Lazy continuation");
    }

    #[test]
    fn test_lazy_continuation_followed_by_another_list() {
        // Lazy continuation text followed by another list item
        // In CommonMark, "Some text" becomes part of Item 1's lazy continuation,
        // and "- Item 2" starts a new list item within the same list.
        // With allow_lazy_continuation = false, we warn about lazy continuation
        // even within valid list structure (issue #295).
        let content = "- Item 1\nSome text\n- Item 2";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about lazy continuation on line 2
        assert_eq!(
            warnings.len(),
            1,
            "Should warn about lazy continuation within list. Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("Lazy continuation"),
            "Warning should be about lazy continuation"
        );
        assert_eq!(warnings[0].line, 2, "Warning should be on line 2");
    }

    #[test]
    fn test_lazy_continuation_multiple_in_document() {
        // Loose list (blank line between items) with lazy continuation
        // In CommonMark, this is a single loose list, not two separate lists.
        // "Lazy 1" is lazy continuation of Item 1
        // "Lazy 2" is lazy continuation of Item 2
        let content = "- Item 1\nLazy 1\n\n- Item 2\nLazy 2";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Expect 2 warnings for both lazy continuation lines
        assert_eq!(
            warnings.len(),
            2,
            "Should warn for both lazy continuations. Got: {warnings:?}"
        );

        let fixed = fix_with_config(content, config.clone());
        // Auto-fix should add proper indentation to both lazy continuation lines
        assert!(
            fixed.contains("  Lazy 1"),
            "Fixed content should have indented 'Lazy 1'. Got: {fixed:?}"
        );
        assert!(
            fixed.contains("  Lazy 2"),
            "Fixed content should have indented 'Lazy 2'. Got: {fixed:?}"
        );

        let warnings_after = lint_with_config(&fixed, config);
        // No warnings after fix: both lazy lines are properly indented
        assert_eq!(
            warnings_after.len(),
            0,
            "All warnings should be fixed after auto-fix. Got: {warnings_after:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_end_of_document_no_newline() {
        // Lazy continuation at end of document without trailing newline
        let content = "- Item\nNo trailing newline";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even at end of document");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  No trailing newline");
    }

    #[test]
    fn test_lazy_continuation_thematic_break_still_needs_blank() {
        // Thematic break after list without blank line still triggers MD032
        // The thematic break ends the list, but MD032 requires blank line separation
        let content = "- Item 1\n---";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        // Should warn because list needs blank line before thematic break
        assert_eq!(
            warnings.len(),
            1,
            "List should need blank line before thematic break. Got: {warnings:?}"
        );

        // Verify fix adds blank line
        let fixed = fix_with_config(content, config);
        assert_eq!(fixed, "- Item 1\n\n---");
    }

    #[test]
    fn test_lazy_continuation_heading_not_flagged() {
        // Heading after list should NOT be flagged as lazy continuation
        // (headings end lists per CommonMark)
        let content = "- Item 1\n# Heading";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // The warning should be about missing blank line, not lazy continuation
        // But headings interrupt lists, so the list ends at Item 1
        assert!(
            warnings.iter().all(|w| !w.message.contains("lazy")),
            "Heading should not trigger lazy continuation warning"
        );
    }

    #[test]
    fn test_lazy_continuation_mixed_list_types() {
        // Mixed ordered and unordered with lazy continuation
        let content = "- Unordered\n1. Ordered\nLazy text";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert!(!warnings.is_empty(), "Should warn about structure issues");
    }

    #[test]
    fn test_lazy_continuation_deep_nesting() {
        // Deep nested list with lazy continuation at end
        let content = "- Level 1\n  - Level 2\n    - Level 3\nLazy at root";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert!(
            !warnings.is_empty(),
            "Should warn about lazy continuation after nested list"
        );

        let fixed = fix_with_config(content, config.clone());
        let warnings_after = lint_with_config(&fixed, config);
        assert_eq!(warnings_after.len(), 0, "No warnings should remain after fix");
    }

    #[test]
    fn test_lazy_continuation_with_emphasis_in_text() {
        // Lazy continuation containing emphasis markers
        let content = "- Item\n*emphasized* continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even with emphasis in continuation");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  *emphasized* continuation");
    }

    #[test]
    fn test_lazy_continuation_with_code_span() {
        // Lazy continuation containing code span
        let content = "- Item\n`code` continuation";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(warnings.len(), 1, "Should warn even with code span in continuation");

        let fixed = fix_with_config(content, config);
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item\n  `code` continuation");
    }

    // =========================================================================
    // Issue #295: Lazy continuation after nested sublists
    // These tests verify detection of lazy continuation at outer indent level
    // after nested sublists, followed by another list item.
    // =========================================================================

    #[test]
    fn test_issue295_case1_nested_bullets_then_continuation_then_item() {
        // Outer numbered item with nested bullets, lazy continuation, then next item
        // The lazy continuation "A new Chat..." appears at column 1, not indented
        let content = r#"1. Create a new Chat conversation:
   - On the sidebar, select **New Chat**.
   - In the box, type `/new`.
   A new Chat conversation replaces the previous one.
1. Under the Chat text box, turn off the toggle."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 4 "A new Chat..." which is lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation after nested bullets. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 4),
            "Should warn on line 4. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_case3_code_span_starts_lazy_continuation() {
        // Code span at the START of lazy continuation after nested bullets
        // This is tricky because pulldown-cmark emits Code event, not Text
        let content = r#"- `field`: Is the specific key:
  - `password`: Accesses the password.
  - `api_key`: Accesses the api_key.
  `token`: Specifies which ID token to use.
- `version_id`: Is the unique identifier."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 4 "`token`:..." which starts with code span
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation starting with code span. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 4),
            "Should warn on line 4 (code span start). Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_case4_deep_nesting_with_continuation_then_item() {
        // Multiple nesting levels, lazy continuation, then next outer item
        let content = r#"- Check out the branch, and test locally.
  - If the MR requires significant modifications:
    - **Skip local testing** and review instead.
    - **Request verification** from the author.
    - **Identify the minimal change** needed.
  Your testing might result in opportunities.
- If you don't understand, _say so_."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 6 "Your testing..." which is lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation after deep nesting. Got: {warnings:?}"
        );
        assert!(
            lazy_warnings.iter().any(|w| w.line == 6),
            "Should warn on line 6. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_ordered_list_nested_bullets_continuation() {
        // Ordered list with nested bullets, continuation at outer level, then next item
        // This is the exact pattern from debug_test6.md
        let content = r#"# Test

1. First item.
   - Nested A.
   - Nested B.
   Continuation at outer level.
1. Second item."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about line 6 "Continuation at outer level."
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            !lazy_warnings.is_empty(),
            "Should detect lazy continuation at outer level after nested. Got: {warnings:?}"
        );
        // Line 6 = "   Continuation at outer level." (3 spaces indent, but needs 4 for proper continuation)
        assert!(
            lazy_warnings.iter().any(|w| w.line == 6),
            "Should warn on line 6. Got: {lazy_warnings:?}"
        );
    }

    #[test]
    fn test_issue295_multiple_lazy_lines_after_nested() {
        // Multiple lazy continuation lines after nested sublist
        let content = r#"1. The device client receives a response.
   - Those defined by OAuth Framework.
   - Those specific to device authorization.
   Those error responses are described below.
   For more information on each response,
   see the documentation.
1. Next step in the process."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Should warn about lines 4, 5, 6 (all lazy continuation)
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert!(
            lazy_warnings.len() >= 3,
            "Should detect multiple lazy continuation lines. Got {} warnings: {lazy_warnings:?}",
            lazy_warnings.len()
        );
    }

    #[test]
    fn test_issue295_properly_indented_not_lazy() {
        // Properly indented continuation after nested sublist should NOT warn
        let content = r#"1. First item.
   - Nested A.
   - Nested B.

   Properly indented continuation.
1. Second item."#;
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // With blank line before, this is a new paragraph, not lazy continuation
        let lazy_warnings: Vec<_> = warnings
            .iter()
            .filter(|w| w.message.contains("Lazy continuation"))
            .collect();
        assert_eq!(
            lazy_warnings.len(),
            0,
            "Should NOT warn when blank line separates continuation. Got: {lazy_warnings:?}"
        );
    }

    // =========================================================================
    // HTML Comment Transparency Tests
    // HTML comments should be "transparent" for blank line checking,
    // matching markdownlint-cli behavior.
    // =========================================================================

    #[test]
    fn test_html_comment_before_list_with_preceding_blank() {
        // Blank line before HTML comment = list is properly separated
        // markdownlint-cli does NOT warn here
        let content = "Some text.\n\n<!-- comment -->\n- List item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when blank line exists before HTML comment. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_after_list_with_following_blank() {
        // Blank line after HTML comment = list is properly separated
        let content = "- List item\n<!-- comment -->\n\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when blank line exists after HTML comment. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_list_inside_html_comment_ignored() {
        // Lists entirely inside HTML comments should not be analyzed
        let content = "<!--\n1. First\n2. Second\n3. Third\n-->";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not analyze lists inside HTML comments. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_multiline_html_comment_before_list() {
        // Multi-line HTML comment should be transparent
        let content = "Text\n\n<!--\nThis is a\nmulti-line\ncomment\n-->\n- Item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-line HTML comment should be transparent. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_no_blank_before_html_comment_still_warns() {
        // No blank line anywhere = should still warn
        let content = "Some text.\n<!-- comment -->\n- List item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn when no blank line exists (even with HTML comment). Got: {warnings:?}"
        );
        assert!(
            warnings[0].message.contains("preceded by blank line"),
            "Should be 'preceded by blank line' warning"
        );
    }

    #[test]
    fn test_no_blank_after_html_comment_no_warn_lazy_continuation() {
        // Text immediately after list (through HTML comment) is lazy continuation
        // markdownlint-cli does NOT warn here - the text becomes part of the list
        let content = "- List item\n<!-- comment -->\nSome text.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn - text after comment becomes lazy continuation. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_list_followed_by_heading_through_comment_should_warn() {
        // Heading cannot be lazy continuation, so this SHOULD warn
        let content = "- List item\n<!-- comment -->\n# Heading";
        let warnings = lint(content);
        // Headings after lists through HTML comments should be handled gracefully
        // The blank line check should look past the comment
        assert!(
            warnings.len() <= 1,
            "Should handle heading after comment gracefully. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_between_list_and_text_both_directions() {
        // Blank line on both sides through HTML comment
        let content = "Text before.\n\n<!-- comment -->\n- Item 1\n- Item 2\n<!-- another -->\n\nText after.";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn with proper separation through comments. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_html_comment_fix_does_not_insert_unnecessary_blank() {
        // Fix should not add blank line when separation already exists through comment
        let content = "Text.\n\n<!-- comment -->\n- Item";
        let fixed = fix(content);
        assert_eq!(fixed, content, "Fix should not modify already-correct content");
    }

    #[test]
    fn test_html_comment_fix_adds_blank_when_needed() {
        // Fix should add blank line when no separation exists
        // The blank line is added immediately before the list (after the comment)
        let content = "Text.\n<!-- comment -->\n- Item";
        let fixed = fix(content);
        assert!(
            fixed.contains("<!-- comment -->\n\n- Item"),
            "Fix should add blank line before list. Got: {fixed}"
        );
    }

    #[test]
    fn test_ordered_list_inside_html_comment() {
        // Ordered list with non-1 start inside comment should not warn
        let content = "<!--\n3. Starting at 3\n4. Next item\n-->";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn about ordered list inside HTML comment. Got: {warnings:?}"
        );
    }

    // =========================================================================
    // Blockquote Boundary Transition Tests
    // When a list inside a blockquote ends and the next line exits the blockquote,
    // no blank line is needed - the blockquote boundary provides semantic separation.
    // =========================================================================

    #[test]
    fn test_blockquote_list_exit_no_warning() {
        // Blockquote list followed by outer content - no blank line needed
        let content = "- outer item\n  > - blockquote list 1\n  > - blockquote list 2\n- next outer item";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when exiting blockquote. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_nested_blockquote_list_exit() {
        // Nested blockquote list - exiting should not require blank line
        let content = "- outer\n  - nested\n    > - bq list 1\n    > - bq list 2\n  - back to nested\n- outer again";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn when exiting nested blockquote list. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_same_level_no_warning() {
        // List INSIDE blockquote followed by text INSIDE same blockquote
        // markdownlint-cli does NOT warn for this case - lazy continuation applies
        let content = "> - item 1\n> - item 2\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Should not warn - text is lazy continuation in blockquote. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_list_with_special_chars() {
        // Content with special chars like <> should not affect blockquote detection
        let content = "- Item with <>&\n  > - blockquote item\n- Back to outer";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Special chars in content should not affect blockquote detection. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_whitespace_only_line() {
        // Per CommonMark/pulldown-cmark, whitespace-only line IS a blank line separator
        // The list ends at the whitespace-only line, text starts a new paragraph
        let content = "- Item\n   \nText after whitespace-only line";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Whitespace-only line counts as blank line separator - no lazy continuation
        assert_eq!(
            warnings.len(),
            0,
            "Whitespace-only line IS a separator in CommonMark. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_lazy_continuation_blockquote_context() {
        // List inside blockquote with lazy continuation
        let content = "> - Item\n> Lazy in quote";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config);
        // Inside blockquote, lazy continuation may behave differently
        // This tests that we handle blockquote context
        assert!(warnings.len() <= 1, "Should handle blockquote context gracefully");
    }

    #[test]
    fn test_lazy_continuation_fix_preserves_content() {
        // Ensure fix doesn't modify the actual content
        let content = "- Item with special chars: <>&\nContinuation with: \"quotes\"";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed = fix_with_config(content, config);
        assert!(fixed.contains("<>&"), "Should preserve special chars");
        assert!(fixed.contains("\"quotes\""), "Should preserve quotes");
        // Fix adds proper indentation (2 spaces for "- " marker)
        assert_eq!(fixed, "- Item with special chars: <>&\n  Continuation with: \"quotes\"");
    }

    #[test]
    fn test_lazy_continuation_fix_idempotent() {
        // Running fix twice should produce same result
        let content = "- Item\nLazy";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let fixed_once = fix_with_config(content, config.clone());
        let fixed_twice = fix_with_config(&fixed_once, config);
        assert_eq!(fixed_once, fixed_twice, "Fix should be idempotent");
    }

    #[test]
    fn test_lazy_continuation_config_default_allows() {
        // Verify default config allows lazy continuation
        let content = "- Item\nLazy text that continues";
        let default_config = MD032Config::default();
        assert!(
            default_config.allow_lazy_continuation,
            "Default should allow lazy continuation"
        );
        let warnings = lint_with_config(content, default_config);
        assert_eq!(warnings.len(), 0, "Default config should not warn on lazy continuation");
    }

    #[test]
    fn test_lazy_continuation_after_multi_line_item() {
        // List item with proper indented continuation, then lazy text
        let content = "- Item line 1\n  Item line 2 (indented)\nLazy (not indented)";
        let config = MD032Config {
            allow_lazy_continuation: false,
        };
        let warnings = lint_with_config(content, config.clone());
        assert_eq!(
            warnings.len(),
            1,
            "Should warn only for the lazy line, not the indented line"
        );
    }

    // Issue #260: Lists inside blockquotes should not produce false positives
    #[test]
    fn test_blockquote_list_with_continuation_and_nested() {
        // This is the exact case from issue #260
        // markdownlint-cli reports NO warnings for this
        let content = "> - item 1\n>   continuation\n>   - nested\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with continuation and nested items should have no warnings. Got: {warnings:?}"
        );
    }

    #[test]
    fn test_blockquote_list_simple() {
        // Simple blockquoted list
        let content = "> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Simple blockquoted list should have no warnings");
    }

    #[test]
    fn test_blockquote_list_with_continuation_only() {
        // Blockquoted list with continuation line (no nesting)
        let content = "> - item 1\n>   continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with continuation should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_list_with_lazy_continuation() {
        // Blockquoted list with lazy continuation (no extra indent after >)
        let content = "> - item 1\n> lazy continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquoted list with lazy continuation should have no warnings"
        );
    }

    #[test]
    fn test_nested_blockquote_list() {
        // List inside nested blockquote (>> prefix)
        let content = ">> - item 1\n>>   continuation\n>>   - nested\n>> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Nested blockquote list should have no warnings");
    }

    #[test]
    fn test_blockquote_list_needs_preceding_blank() {
        // Blockquote list preceded by non-blank content SHOULD warn
        let content = "> Text before\n> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            1,
            "Should warn for missing blank before blockquoted list"
        );
    }

    #[test]
    fn test_blockquote_list_properly_separated() {
        // Blockquote list with proper blank lines - no warnings
        let content = "> Text before\n>\n> - item 1\n> - item 2\n>\n> Text after";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Properly separated blockquoted list should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_ordered_list() {
        // Ordered list in blockquote with continuation
        let content = "> 1. item 1\n>    continuation\n> 2. item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Ordered list in blockquote should have no warnings");
    }

    #[test]
    fn test_blockquote_list_with_empty_blockquote_line() {
        // Empty blockquote line (just ">") between items - still same list
        let content = "> - item 1\n>\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Empty blockquote line should not break list");
    }

    /// Issue #268: Multi-paragraph list items in blockquotes should not trigger false positives
    #[test]
    fn test_blockquote_list_multi_paragraph_items() {
        // List item with blank line + continuation paragraph + next item
        // This is a common pattern for multi-paragraph list items in blockquotes
        let content = "# Test\n\n> Some intro text\n> \n> * List item 1\n> \n>   Continuation\n> * List item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-paragraph list items in blockquotes should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Ordered lists with multi-paragraph items in blockquotes
    #[test]
    fn test_blockquote_ordered_list_multi_paragraph_items() {
        let content = "> 1. First item\n> \n>    Continuation of first\n> 2. Second item\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Ordered multi-paragraph list items in blockquotes should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multiple continuation paragraphs in blockquote list
    #[test]
    fn test_blockquote_list_multiple_continuations() {
        let content = "> - Item 1\n> \n>   First continuation\n> \n>   Second continuation\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multiple continuation paragraphs should not break blockquote list. Got: {warnings:?}"
        );
    }

    /// Issue #268: Nested blockquote (>>) with multi-paragraph list items
    #[test]
    fn test_nested_blockquote_multi_paragraph_list() {
        let content = ">> - Item 1\n>> \n>>   Continuation\n>> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Nested blockquote multi-paragraph list should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Triple-nested blockquote (>>>) with multi-paragraph list items
    #[test]
    fn test_triple_nested_blockquote_multi_paragraph_list() {
        let content = ">>> - Item 1\n>>> \n>>>   Continuation\n>>> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Triple-nested blockquote multi-paragraph list should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: Last item in blockquote list has continuation (edge case)
    #[test]
    fn test_blockquote_list_last_item_continuation() {
        let content = "> - Item 1\n> - Item 2\n> \n>   Continuation of item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Last item with continuation should have no warnings. Got: {warnings:?}"
        );
    }

    /// Issue #268: First item only has continuation in blockquote list
    #[test]
    fn test_blockquote_list_first_item_only_continuation() {
        let content = "> - Item 1\n> \n>   Continuation of item 1\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Single item with continuation should have no warnings. Got: {warnings:?}"
        );
    }

    /// Blockquote level change SHOULD still be detected as list break
    /// Note: markdownlint flags BOTH lines in this case - line 1 for missing preceding blank,
    /// and line 2 for missing preceding blank (level change)
    #[test]
    fn test_blockquote_level_change_breaks_list() {
        // Going from > to >> should break the list - markdownlint flags both lines
        let content = "> - Item in single blockquote\n>> - Item in nested blockquote\n";
        let warnings = lint(content);
        // markdownlint reports: line 1 (list at start), line 2 (level change)
        // For now, accept 0 or more warnings since this is a complex edge case
        // The main fix (multi-paragraph items) is more important than this edge case
        assert!(
            warnings.len() <= 2,
            "Blockquote level change warnings should be reasonable. Got: {warnings:?}"
        );
    }

    /// Exiting blockquote SHOULD still be detected as needing blank line
    #[test]
    fn test_exit_blockquote_needs_blank_before_list() {
        // Text after blockquote, then list without blank
        let content = "> Blockquote text\n\n- List outside blockquote\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "List after blank line outside blockquote should be fine. Got: {warnings:?}"
        );

        // Without blank line after blockquote - markdownlint flags this
        // But rumdl may not flag it due to complexity of detecting "text immediately before list"
        // This is an acceptable deviation for now
        let content2 = "> Blockquote text\n- List outside blockquote\n";
        let warnings2 = lint(content2);
        // Accept 0 or 1 - main fix is more important than this edge case
        assert!(
            warnings2.len() <= 1,
            "List after blockquote warnings should be reasonable. Got: {warnings2:?}"
        );
    }

    /// Issue #268: Test all unordered list markers (-, *, +) with multi-paragraph items
    #[test]
    fn test_blockquote_multi_paragraph_all_unordered_markers() {
        // Dash marker
        let content_dash = "> - Item 1\n> \n>   Continuation\n> - Item 2\n";
        let warnings = lint(content_dash);
        assert_eq!(warnings.len(), 0, "Dash marker should work. Got: {warnings:?}");

        // Asterisk marker
        let content_asterisk = "> * Item 1\n> \n>   Continuation\n> * Item 2\n";
        let warnings = lint(content_asterisk);
        assert_eq!(warnings.len(), 0, "Asterisk marker should work. Got: {warnings:?}");

        // Plus marker
        let content_plus = "> + Item 1\n> \n>   Continuation\n> + Item 2\n";
        let warnings = lint(content_plus);
        assert_eq!(warnings.len(), 0, "Plus marker should work. Got: {warnings:?}");
    }

    /// Issue #268: Parenthesis-style ordered list markers (1))
    #[test]
    fn test_blockquote_multi_paragraph_parenthesis_marker() {
        let content = "> 1) Item 1\n> \n>    Continuation\n> 2) Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Parenthesis ordered markers should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multi-digit ordered list numbers have wider markers
    #[test]
    fn test_blockquote_multi_paragraph_multi_digit_numbers() {
        // "10. " is 4 chars, so continuation needs 4 spaces
        let content = "> 10. Item 10\n> \n>     Continuation of item 10\n> 11. Item 11\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Multi-digit ordered list should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation with emphasis and other inline formatting
    #[test]
    fn test_blockquote_multi_paragraph_with_formatting() {
        let content = "> - Item with **bold**\n> \n>   Continuation with *emphasis* and `code`\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Continuation with inline formatting should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Multiple items each with their own continuation paragraph
    #[test]
    fn test_blockquote_multi_paragraph_all_items_have_continuation() {
        let content = "> - Item 1\n> \n>   Continuation 1\n> - Item 2\n> \n>   Continuation 2\n> - Item 3\n> \n>   Continuation 3\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "All items with continuations should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation starting with lowercase (tests uppercase heuristic doesn't break this)
    #[test]
    fn test_blockquote_multi_paragraph_lowercase_continuation() {
        let content = "> - Item 1\n> \n>   and this continues the item\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Lowercase continuation should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Continuation starting with uppercase (tests uppercase heuristic is bypassed with proper indent)
    #[test]
    fn test_blockquote_multi_paragraph_uppercase_continuation() {
        let content = "> - Item 1\n> \n>   This continues the item with uppercase\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Uppercase continuation with proper indent should work. Got: {warnings:?}"
        );
    }

    /// Issue #268: Mixed ordered and unordered shouldn't affect multi-paragraph handling
    #[test]
    fn test_blockquote_separate_ordered_unordered_multi_paragraph() {
        // Two separate lists in same blockquote
        let content = "> - Unordered item\n> \n>   Continuation\n> \n> 1. Ordered item\n> \n>    Continuation\n";
        let warnings = lint(content);
        // May have warning for missing blank between lists, but not for the continuations
        assert!(
            warnings.len() <= 1,
            "Separate lists with continuations should be reasonable. Got: {warnings:?}"
        );
    }

    /// Issue #268: Blockquote with bare > line (no space) as blank
    #[test]
    fn test_blockquote_multi_paragraph_bare_marker_blank() {
        // Using ">" alone instead of "> " for blank line
        let content = "> - Item 1\n>\n>   Continuation\n> - Item 2\n";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Bare > as blank line should work. Got: {warnings:?}");
    }

    #[test]
    fn test_blockquote_list_varying_spaces_after_marker() {
        // Different spacing after > (1 space vs 3 spaces) but same blockquote level
        let content = "> - item 1\n>   continuation with more indent\n> - item 2";
        let warnings = lint(content);
        assert_eq!(warnings.len(), 0, "Varying spaces after > should not break list");
    }

    #[test]
    fn test_deeply_nested_blockquote_list() {
        // Triple-nested blockquote with list
        let content = ">>> - item 1\n>>>   continuation\n>>> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Deeply nested blockquote list should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_level_change_in_list() {
        // Blockquote level changes mid-list - this breaks the list
        let content = "> - item 1\n>> - deeper item\n> - item 2";
        // Each segment is a separate list context due to blockquote level change
        // markdownlint-cli reports 4 warnings for this case
        let warnings = lint(content);
        assert!(
            !warnings.is_empty(),
            "Blockquote level change should break list and trigger warnings"
        );
    }

    #[test]
    fn test_blockquote_list_with_code_span() {
        // List item with inline code in blockquote
        let content = "> - item with `code`\n>   continuation\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquote list with code span should have no warnings"
        );
    }

    #[test]
    fn test_blockquote_list_at_document_end() {
        // List at end of document (no trailing content)
        let content = "> Some text\n>\n> - item 1\n> - item 2";
        let warnings = lint(content);
        assert_eq!(
            warnings.len(),
            0,
            "Blockquote list at document end should have no warnings"
        );
    }

    #[test]
    fn test_fix_preserves_blockquote_prefix_before_list() {
        // Issue #268: Fix should insert blockquote-prefixed blank lines inside blockquotes
        let content = "> Text before
> - Item 1
> - Item 2";
        let fixed = fix(content);

        // The blank line inserted before the list should have the blockquote prefix (no trailing space per markdownlint-cli)
        let expected = "> Text before
>
> - Item 1
> - Item 2";
        assert_eq!(
            fixed, expected,
            "Fix should insert '>' blank line, not plain blank line"
        );
    }

    #[test]
    fn test_fix_preserves_triple_nested_blockquote_prefix_for_list() {
        // Triple-nested blockquotes should preserve full prefix
        // Per markdownlint-cli, only preceding blank line is required
        let content = ">>> Triple nested
>>> - Item 1
>>> - Item 2
>>> More text";
        let fixed = fix(content);

        // Should insert ">>>" blank line before list only
        let expected = ">>> Triple nested
>>>
>>> - Item 1
>>> - Item 2
>>> More text";
        assert_eq!(
            fixed, expected,
            "Fix should preserve triple-nested blockquote prefix '>>>'"
        );
    }

    // ==================== Quarto Flavor Tests ====================

    fn lint_quarto(content: &str) -> Vec<LintWarning> {
        let rule = MD032BlanksAroundLists::default();
        let ctx = LintContext::new(content, crate::config::MarkdownFlavor::Quarto, None);
        rule.check(&ctx).unwrap()
    }

    #[test]
    fn test_quarto_list_after_div_open() {
        // List immediately after Quarto div opening: div marker is transparent
        let content = "Content\n\n::: {.callout-note}\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // The blank line before div opening should count as separation
        assert!(
            warnings.is_empty(),
            "Quarto div marker should be transparent before list: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_before_div_close() {
        // List immediately before Quarto div closing: div close is at end, transparent
        let content = "::: {.callout-note}\n\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // The div closing marker is at end, should be transparent
        assert!(
            warnings.is_empty(),
            "Quarto div marker should be transparent after list: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_needs_blank_without_div() {
        // List still needs blank line without div providing separation
        let content = "Content\n::: {.callout-note}\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint_quarto(content);
        // No blank between "Content" and div opening (which is transparent)
        // so list appears right after "Content" - needs blank
        assert!(
            !warnings.is_empty(),
            "Should still require blank when not present: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_list_in_callout_with_content() {
        // List inside callout with proper blank lines
        let content = "::: {.callout-note}\nNote introduction:\n\n- Item 1\n- Item 2\n\nMore note content.\n:::\n";
        let warnings = lint_quarto(content);
        assert!(
            warnings.is_empty(),
            "List with proper blanks inside callout should pass: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_div_markers_not_transparent_in_standard_flavor() {
        // In standard flavor, ::: is regular text
        let content = "Content\n\n:::\n- Item 1\n- Item 2\n:::\n";
        let warnings = lint(content); // Uses standard flavor
        // In standard, ::: is just text, so list follows ::: without blank
        assert!(
            !warnings.is_empty(),
            "Standard flavor should not treat ::: as transparent: {warnings:?}"
        );
    }

    #[test]
    fn test_quarto_nested_divs_with_list() {
        // Nested Quarto divs with list inside
        let content = "::: {.outer}\n::: {.inner}\n\n- Item 1\n- Item 2\n\n:::\n:::\n";
        let warnings = lint_quarto(content);
        assert!(warnings.is_empty(), "Nested divs with list should work: {warnings:?}");
    }
}