sal/text/tests/text_indentation_tests.rs

//! Unit tests for text indentation functionality
//!
//! These tests validate the dedent and prefix functions including:
//! - Common whitespace removal (dedent)
//! - Line prefix addition (prefix)
//! - Edge cases and special characters
//! - Tab handling and mixed indentation

use sal_text::{dedent, prefix};

#[test]
fn test_dedent_basic() {
    let indented = "    line 1\n    line 2\n        line 3";
    let expected = "line 1\nline 2\n    line 3";
    assert_eq!(dedent(indented), expected);
}

#[test]
fn test_dedent_empty_lines() {
    let indented = "    line 1\n\n    line 2\n        line 3";
    let expected = "line 1\n\nline 2\n    line 3";
    assert_eq!(dedent(indented), expected);
}

#[test]
fn test_dedent_tabs_as_spaces() {
    let indented = "\t\tline 1\n\t\tline 2\n\t\t\tline 3";
    let expected = "line 1\nline 2\n\tline 3";
    assert_eq!(dedent(indented), expected);
}

#[test]
fn test_dedent_mixed_tabs_and_spaces() {
    let indented = "    \tline 1\n    \tline 2\n    \t    line 3";
    let expected = "line 1\nline 2\n    line 3";
    assert_eq!(dedent(indented), expected);
}

#[test]
fn test_dedent_no_common_indentation() {
    let text = "line 1\n  line 2\n    line 3";
    let expected = "line 1\n  line 2\n    line 3";
    assert_eq!(dedent(text), expected);
}

#[test]
fn test_dedent_single_line() {
    let indented = "    single line";
    let expected = "single line";
    assert_eq!(dedent(indented), expected);
}

#[test]
fn test_dedent_empty_string() {
    assert_eq!(dedent(""), "");
}

#[test]
fn test_dedent_only_whitespace() {
    let whitespace = "    \n        \n    ";
    let expected = "\n\n";
    assert_eq!(dedent(whitespace), expected);
}

#[test]
fn test_prefix_basic() {
    let text = "line 1\nline 2\nline 3";
    let expected = "    line 1\n    line 2\n    line 3";
    assert_eq!(prefix(text, "    "), expected);
}

#[test]
fn test_prefix_with_symbols() {
    let text = "line 1\nline 2\nline 3";
    let expected = "> line 1\n> line 2\n> line 3";
    assert_eq!(prefix(text, "> "), expected);
}

#[test]
fn test_prefix_empty_lines() {
    let text = "line 1\n\nline 3";
    let expected = ">> line 1\n>> \n>> line 3";
    assert_eq!(prefix(text, ">> "), expected);
}

#[test]
fn test_prefix_single_line() {
    let text = "single line";
    let expected = "PREFIX: single line";
    assert_eq!(prefix(text, "PREFIX: "), expected);
}

#[test]
fn test_prefix_empty_string() {
    assert_eq!(prefix("", "PREFIX: "), "");
}

#[test]
fn test_prefix_empty_prefix() {
    let text = "line 1\nline 2";
    assert_eq!(prefix(text, ""), text);
}

#[test]
fn test_dedent_and_prefix_combination() {
    let indented = "    def function():\n        print('hello')\n        return True";
    let dedented = dedent(indented);
    let prefixed = prefix(&dedented, ">>> ");
    
    let expected = ">>> def function():\n>>>     print('hello')\n>>>     return True";
    assert_eq!(prefixed, expected);
}

#[test]
fn test_dedent_real_code_example() {
    let code = r#"
        if condition:
            for item in items:
                process(item)
            return result
        else:
            return None"#;
    
    let dedented = dedent(code);
    let expected = "\nif condition:\n    for item in items:\n        process(item)\n    return result\nelse:\n    return None";
    assert_eq!(dedented, expected);
}

#[test]
fn test_prefix_code_comment() {
    let code = "function main() {\n    console.log('Hello');\n}";
    let commented = prefix(code, "// ");
    let expected = "// function main() {\n//     console.log('Hello');\n// }";
    assert_eq!(commented, expected);
}

#[test]
fn test_dedent_preserves_relative_indentation() {
    let text = "        start\n            indented more\n        back to start level\n            indented again";
    let dedented = dedent(text);
    let expected = "start\n    indented more\nback to start level\n    indented again";
    assert_eq!(dedented, expected);
}

#[test]
fn test_prefix_with_unicode() {
    let text = "Hello 世界\nGoodbye 世界";
    let prefixed = prefix(text, "🔹 ");
    let expected = "🔹 Hello 世界\n🔹 Goodbye 世界";
    assert_eq!(prefixed, expected);
}

#[test]
fn test_dedent_with_unicode() {
    let text = "    Hello 世界\n    Goodbye 世界\n        More indented 世界";
    let dedented = dedent(text);
    let expected = "Hello 世界\nGoodbye 世界\n    More indented 世界";
    assert_eq!(dedented, expected);
}