uncomment 3.0.1

A CLI tool to remove comments from code using tree-sitter for accurate parsing
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::fs;
use tempfile::TempDir;
use uncomment::{
    config::{Config, ConfigManager, LanguageConfig},
    processor::Processor,
};

/// Test error handling for malformed configuration files
#[test]
fn test_malformed_config_error_handling() {
    let temp_dir = TempDir::new().unwrap();
    let config_path = temp_dir.path().join("uncomment.toml");

    let malformed_config = r#"
[global
remove_docs = true  # Missing closing bracket
invalid_field = "value"

[languages.rust
name = "Rust"  # Missing closing bracket
"#;

    fs::write(&config_path, malformed_config).unwrap();

    let result = ConfigManager::new(temp_dir.path());
    if let Err(error) = result {
        let error_msg = error.to_string();
        assert!(error_msg.contains("parse") || error_msg.contains("TOML"));
    } else {
        assert!(result.is_ok());
    }
}

/// Test error handling for unsupported file types in processor
#[test]
fn test_processor_unsupported_file_type_error() {
    let temp_dir = TempDir::new().unwrap();
    let config_manager = ConfigManager::new(temp_dir.path()).unwrap();
    let mut processor = Processor::new();

    let unsupported_file = temp_dir.path().join("test.unsupported");
    fs::write(&unsupported_file, "// Comment in unsupported file").unwrap();

    let result = processor.process_file_with_config(&unsupported_file, &config_manager, None);
    assert!(result.is_err());

    let error_msg = result.unwrap_err().to_string();
    assert!(error_msg.contains("Unsupported file type"));
}

/// Test error handling for nonexistent files in processor
#[test]
fn test_processor_nonexistent_file_error() {
    let temp_dir = TempDir::new().unwrap();
    let config_manager = ConfigManager::new(temp_dir.path()).unwrap();
    let mut processor = Processor::new();

    let nonexistent_file = temp_dir.path().join("nonexistent.rs");

    let result = processor.process_file_with_config(&nonexistent_file, &config_manager, None);
    assert!(result.is_err());

    let error_msg = result.unwrap_err().to_string();
    assert!(error_msg.contains("Failed to read file"));
}

/// Test error handling for configuration validation edge cases
#[test]
fn test_config_validation_edge_cases() {
    let mut config = Config::default();

    let invalid_language = LanguageConfig {
        name: "".to_string(),
        extensions: vec!["test".to_string()],
        comment_nodes: vec!["comment".to_string()],
        doc_comment_nodes: vec![],
        preserve_patterns: vec![],
        remove_todos: None,
        remove_fixme: None,
        remove_docs: None,
        use_default_ignores: None,
    };

    config
        .languages
        .insert("empty_name".to_string(), invalid_language);

    let validation_result = config.validate();
    assert!(validation_result.is_err());

    let mut config2 = Config::default();
    let no_comments_language = LanguageConfig {
        name: "test".to_string(),
        extensions: vec!["test".to_string()],
        comment_nodes: vec![],
        doc_comment_nodes: vec![],
        preserve_patterns: vec![],
        remove_todos: None,
        remove_fixme: None,
        remove_docs: None,
        use_default_ignores: None,
    };

    config2
        .languages
        .insert("no_comments".to_string(), no_comments_language);

    let validation_result2 = config2.validate();
    assert!(validation_result2.is_err());
}

/// Test error recovery and graceful degradation
#[test]
fn test_error_recovery_mechanisms() {
    let temp_dir = TempDir::new().unwrap();
    let config_path = temp_dir.path().join("uncomment.toml");

    let config = r#"
[global]
remove_docs = false

[languages.rust]
name = "Rust"
extensions = ["rs"]
comment_nodes = ["line_comment", "block_comment"]
"#;

    fs::write(&config_path, config).unwrap();

    let config_manager = ConfigManager::new(temp_dir.path()).unwrap();
    let mut processor = Processor::new();

    let rust_file = temp_dir.path().join("test.rs");
    fs::write(&rust_file, "// Comment\nfn main() {}").unwrap();

    let rust_result = processor.process_file_with_config(&rust_file, &config_manager, None);
    assert!(rust_result.is_ok());

    // Unsupported extension should fail gracefully
    let unknown_file = temp_dir.path().join("test.xyz");
    fs::write(&unknown_file, "// Comment").unwrap();

    let unknown_result = processor.process_file_with_config(&unknown_file, &config_manager, None);
    assert!(unknown_result.is_err());

    let error_msg = unknown_result.unwrap_err().to_string();
    assert!(error_msg.contains("Unsupported file type"));
}