lineguard 0.1.7

A fast and reliable file linter that ensures proper line endings and clean formatting
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
149
150

use assert_cmd::cargo::cargo_bin_cmd;
use predicates::prelude::*;
use tempfile::TempDir;

#[test]
fn test_ignore_pattern_simple() {
    let temp_dir = TempDir::new().unwrap();

    // Create test files
    std::fs::write(temp_dir.path().join("good.txt"), "content\n").unwrap();
    std::fs::write(temp_dir.path().join("bad.txt"), "content  \n").unwrap();
    std::fs::write(temp_dir.path().join("ignore.txt"), "content  \n").unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg(".");
    cmd.arg("--recursive");
    cmd.arg("--ignore").arg("ignore.txt");
    cmd.arg("--format").arg("json");

    cmd.assert()
        .failure()  // Should fail due to bad.txt
        .stdout(predicate::str::contains("\"files_checked\": 2"))  // Only good.txt and bad.txt
        .stdout(predicate::str::contains("bad.txt"))
        .stdout(predicate::str::contains("ignore.txt").not());
}

#[test]
fn test_ignore_pattern_glob() {
    let temp_dir = TempDir::new().unwrap();

    // Create test files
    std::fs::write(temp_dir.path().join("test.txt"), "content\n").unwrap();
    std::fs::write(temp_dir.path().join("test.log"), "content  \n").unwrap();
    std::fs::write(temp_dir.path().join("test.tmp"), "content  \n").unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg(".");
    cmd.arg("--recursive");
    cmd.arg("--ignore").arg("*.log");
    cmd.arg("--ignore").arg("*.tmp");
    cmd.arg("--format").arg("json");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("\"files_checked\": 1")); // Only test.txt
}

#[test]
fn test_ignore_pattern_directory() {
    let temp_dir = TempDir::new().unwrap();

    // Create test files
    std::fs::write(temp_dir.path().join("good.txt"), "content\n").unwrap();
    std::fs::create_dir(temp_dir.path().join("node_modules")).unwrap();
    std::fs::write(temp_dir.path().join("node_modules/bad.txt"), "content  \n").unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg(".");
    cmd.arg("--recursive");
    cmd.arg("--ignore").arg("**/node_modules/**");
    cmd.arg("--format").arg("json");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("\"files_checked\": 1")); // Only good.txt
}

#[test]
fn test_ignore_pattern_relative_directory() {
    let temp_dir = TempDir::new().unwrap();

    // Create nested directory structure
    std::fs::create_dir_all(temp_dir.path().join("utils/corpus")).unwrap();
    std::fs::write(temp_dir.path().join("good.txt"), "content\n").unwrap();
    std::fs::write(
        temp_dir.path().join("utils/corpus/ignore_me.txt"),
        "content  \n",
    )
    .unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg(".");
    cmd.arg("--recursive");
    cmd.arg("--ignore").arg("utils/corpus/**");
    cmd.arg("--format").arg("json");

    cmd.assert()
        .success() // Should succeed because only good.txt is checked
        .stdout(predicate::str::contains("\"files_checked\": 1"))
        .stdout(predicate::str::contains("ignore_me.txt").not());
}

#[test]
fn test_ignore_pattern_normalization() {
    let temp_dir = TempDir::new().unwrap();

    // Create structure:
    // root/
    //   foo/
    //     bar.txt (bad content)

    std::fs::create_dir_all(temp_dir.path().join("foo")).unwrap();
    let bad_file = temp_dir.path().join("foo/bar.txt");
    std::fs::write(&bad_file, "content  \n").unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg("--stdin");
    cmd.arg("--ignore").arg("foo/bar.txt");
    cmd.arg("--format").arg("json");

    // We pass path with .. that normalizes to foo/bar.txt
    // foo/../foo/bar.txt -> foo/bar.txt
    cmd.write_stdin("foo/../foo/bar.txt\n");

    // If ignored, no files found -> exit 0, empty stdout (no JSON report), stderr has message
    // If NOT ignored, file found -> checked -> has issues -> exit 1, JSON report with issues
    cmd.assert()
        .success()
        .stderr(predicate::str::contains("No files found to check"));
}

#[test]
fn test_ignore_pattern_redundant_prefixes() {
    let temp_dir = TempDir::new().unwrap();

    // Create test files
    std::fs::write(temp_dir.path().join("good.txt"), "content\n").unwrap();
    std::fs::create_dir_all(temp_dir.path().join("ignored_dir")).unwrap();
    std::fs::write(
        temp_dir.path().join("ignored_dir/ignore_me.txt"),
        "content  \n",
    )
    .unwrap();

    let mut cmd = cargo_bin_cmd!("lineguard");
    cmd.current_dir(&temp_dir);
    cmd.arg("--stdin");
    cmd.arg("--ignore").arg("ignored_dir/**");
    cmd.arg("--format").arg("json");
    cmd.write_stdin("good.txt\n././ignored_dir/ignore_me.txt\n");

    cmd.assert()
        .success()
        .stdout(predicate::str::contains("\"files_checked\": 1")); // Only good.txt
}