codepack 0.11.7

A *lightning-fast* tool that transforms a directory into a single, LLM-friendly text file, perfect for easy processing and analysis.
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

use codepack::DirectoryProcessor;
use std::path::Path;

#[test]
fn test_should_process_file_empty_path() {
    let processor = DirectoryProcessor::new(vec![], vec![], false, String::new(), false, vec![]);
    let path = Path::new("");
    assert!(!processor.should_process_file(path));
}

#[test]
fn test_should_process_file_regular_file() {
    let processor = DirectoryProcessor::new(vec![], vec![], false, String::new(), false, vec![]);
    let path = Path::new("test.txt");
    assert!(processor.should_process_file(path));
}

#[test]
fn test_should_process_file_included_extension() {
    let processor = DirectoryProcessor::new(
        vec!["rs".to_string()],
        vec![],
        false,
        String::new(),
        false,
        vec![],
    );
    let path = Path::new("main.rs");
    assert!(processor.should_process_file(path));
}
#[test]
fn test_should_process_file_excluded_file() {
    let processor = DirectoryProcessor::new(
        vec![],
        vec!["main.rs".to_string()],
        false,
        String::new(),
        false,
        vec![],
    );
    let path = Path::new("main.rs");
    assert!(!processor.should_process_file(path));
}

#[test]
fn test_should_process_file_excluded_file_by_name() {
    let processor = DirectoryProcessor::new(
        vec![],
        vec!["status".to_string()],
        false,
        String::new(),
        false,
        vec![],
    );
    let path = Path::new("/home/json/code/src/status");
    assert!(!processor.should_process_file(path));
}

#[test]
fn test_should_process_file_excluded_globed_file() {
    let processor = DirectoryProcessor::new(
        vec![],
        vec!["*.py".to_string()],
        false,
        String::new(),
        false,
        vec![],
    );
    let path = Path::new("script.py");
    assert!(!processor.should_process_file(path));
}

#[test]
fn test_validate_output_file() {
    let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
    let test_file_path = temp_dir.path().join("test.txt");
    std::fs::write(&test_file_path, "This is a test file.").expect("Failed to write file");

    let output_path = test_file_path.to_str().unwrap().to_string();
    let mut mock_input = std::io::Cursor::new(b"n\n");
    let mut mock_output = Vec::new();

    let processor = DirectoryProcessor::new(
        vec!["txt".to_string()],
        vec![],
        false,
        output_path.clone(),
        false,
        vec![],
    );

    // if user chooses not to overwrite, should return false
    assert!(!processor
        .validate_output_file(
            output_path.clone(),
            false,
            &mut mock_input,
            &mut mock_output
        )
        .expect("Failed to validate output file"));

    // if forced overwrite, should return true
    assert!(processor
        .validate_output_file(output_path, true, &mut mock_input, &mut mock_output)
        .expect("Failed to validate output file"));
}

#[test]
fn test_run_and_validate_output_file() {
    let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
    let output_path = temp_dir
        .path()
        .join("test.txt")
        .to_str()
        .unwrap()
        .to_string();

    let processor = DirectoryProcessor::new(
        vec!["txt".to_string()],
        vec![],
        false,
        output_path.clone(),
        false,
        vec![],
    );

    processor
        .run(temp_dir.path())
        .expect("Failed to run processor");

    let mut mock_input = std::io::Cursor::new(b"n\n");
    let mut mock_output = Vec::new();

    // should return true because it is processor generated content
    assert!(processor
        .validate_output_file(output_path, false, &mut mock_input, &mut mock_output)
        .expect("Failed to validate output file"));
}