ascfix 0.7.1

Automatic ASCII diagram repair tool for Markdown files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! Mode-specific processing implementations.

mod check;
mod diagram;
mod safe;
mod table;

use crate::cli::Mode;

/// Process content according to the specified mode.
///
/// # Modes
/// - `Safe`: Only normalize Markdown tables (minimal changes, no diagrams)
/// - `Diagram`: Detect and normalize ASCII diagrams (boxes, arrows, text)
/// - `Check`: Validate content but don't modify (used with --check flag)
///
/// If `repair_fences` is true, fence normalization is applied first.
#[must_use]
#[allow(dead_code)] // Reason: Used by main processing pipeline
pub fn process_by_mode(
    mode: &Mode,
    content: &str,
    repair_fences: bool,
    config: &crate::config::Config,
) -> String {
    // For backward compatibility in internal calls, use default config when none provided
    let _default_config = crate::config::Config::default();
    let effective_config = config;

    // Apply fence repair first if enabled
    let content = if repair_fences {
        crate::fences::normalize_fences(content)
    } else {
        content.to_string()
    };

    match mode {
        Mode::Safe => safe::process_safe_mode(&content),
        Mode::Diagram => diagram::process_diagram_mode(&content, effective_config),
        Mode::Check => check::process_check_mode(&content),
    }
}

/// Compare original and processed content to determine if fixes are needed.
///
/// Returns true if the content has been modified, false if identical.
#[must_use]
#[allow(dead_code)] // Reason: Used by CLI for --check mode
pub fn content_needs_fixing(original: &str, processed: &str) -> bool {
    original != processed
}

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

    fn default_config() -> crate::config::Config {
        crate::config::Config::default()
    }

    #[test]
    fn test_all_modes_are_safe() {
        let content = "# Header\n\nText content\n\nMore text";
        let safe_result = process_by_mode(&Mode::Safe, content, false, &default_config());
        let diagram_result = process_by_mode(&Mode::Diagram, content, false, &default_config());
        let check_result = process_by_mode(&Mode::Check, content, false, &default_config());

        // All modes should handle content safely (no crashes, no panics)
        assert!(!safe_result.is_empty());
        assert!(!diagram_result.is_empty());
        assert!(!check_result.is_empty());
    }

    #[test]
    fn test_content_needs_fixing_detects_differences() {
        let original = "┌──┐\n│Hi│\n└──┘";
        let processed = process_by_mode(&Mode::Diagram, original, false, &default_config());
        // If there are primitives, processing might change formatting
        // Check that comparison would detect the difference
        let needs_fixing = content_needs_fixing(original, &processed);
        // This depends on if diagram mode changes anything
        let _ = needs_fixing; // Just verify function compiles
    }

    #[test]
    fn test_content_needs_fixing_detects_identical() {
        let original = "# Title\n\nNo diagrams";
        let processed = process_by_mode(&Mode::Diagram, original, false, &default_config());
        // When no changes are made, content should be identical
        let needs_fixing = content_needs_fixing(original, &processed);
        assert!(!needs_fixing);
    }

    #[test]
    fn test_content_needs_fixing_simple_case() {
        let original = "abc";
        let modified = "def";
        assert!(content_needs_fixing(original, modified));
    }

    #[test]
    fn test_content_needs_fixing_identical_strings() {
        let content = "exact same content";
        assert!(!content_needs_fixing(content, content));
    }

    #[test]
    fn test_content_needs_fixing_ignores_trailing_whitespace() {
        let original = "line1\nline2";
        let modified = "line1\nline2";
        assert!(!content_needs_fixing(original, modified));
    }
}