fdu 0.3.0

Fastest native du replacement and detailed file analytics for Python and Rust
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
151
152
153
154
155
156
157
158
159

//! End-to-end color and machine-output contract at the real process boundary.

use std::process::{Command, Output};

fn run(args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_fdu"))
        .args(args)
        .env_remove("NO_COLOR")
        .env_remove("FORCE_COLOR")
        .output()
        .expect("run fdu")
}

fn run_with_color_env(args: &[&str], no_color: Option<&str>, force_color: Option<&str>) -> Output {
    let mut command = Command::new(env!("CARGO_BIN_EXE_fdu"));
    command.args(args).env_remove("NO_COLOR").env_remove("FORCE_COLOR");
    if let Some(value) = no_color {
        command.env("NO_COLOR", value);
    }
    if let Some(value) = force_color {
        command.env("FORCE_COLOR", value);
    }
    command.output().expect("run fdu with color environment")
}

fn has_ansi(bytes: &[u8]) -> bool {
    bytes.windows(2).any(|bytes| bytes == b"\x1b[")
}

#[test]
fn explicit_color_controls_human_output_but_never_json() {
    let root = tempfile::tempdir().expect("tempdir");
    let root = root.path().to_str().expect("temporary path is Unicode");

    let always = run(&["--cache", "off", "--color", "always", root]);
    assert!(always.status.success());
    assert!(has_ansi(&always.stdout));

    let never = run(&["--cache", "off", "--color", "never", root]);
    assert!(never.status.success());
    assert!(!has_ansi(&never.stdout));

    // Every machine format stays plain even when colour is forced: a consumer parsing
    // the output should never have to strip escape sequences first.
    for format in ["json", "jsonl", "yaml"] {
        let machine = run(&["--cache", "off", "--color", "always", "--format", format, root]);
        assert!(machine.status.success(), "{format} run failed");
        assert!(!has_ansi(&machine.stdout), "{format} output was colourized");
        assert!(machine.stderr.is_empty(), "{format} wrote to stderr");
    }

    let skill = run(&["--color", "always", "--skill"]);
    assert!(skill.status.success());
    assert!(!has_ansi(&skill.stdout));
    assert!(skill.stderr.is_empty());
}

/// A multi-view text report labels each block, and the label follows the colour axis.
///
/// Asserted at the process boundary rather than only over `render`, because the header
/// is the one part of the report whose presence depends on how many views were asked
/// for — a flag-parsing decision — and this is where flag parsing actually happens.
#[test]
fn view_headers_appear_only_for_several_views_and_follow_the_color_axis() {
    let root = tempfile::tempdir().expect("tempdir");
    std::fs::write(root.path().join("main.rs"), b"fn main() {}\n").expect("write");
    let root = root.path().to_str().expect("temporary path is Unicode");

    let several = run(&["--cache", "off", "--color", "never", "--view", "types,summary", root]);
    assert!(several.status.success());
    let text = String::from_utf8(several.stdout).expect("utf-8");
    assert!(text.contains("TYPES\n"), "{text}");
    assert!(text.contains("SUMMARY\n"), "{text}");

    // One view is unambiguous on its own, so the layout is left exactly as it was.
    for view in ["types", "summary", "files", "tree"] {
        let lone = run(&["--cache", "off", "--color", "never", "--view", view, root]);
        assert!(lone.status.success());
        let text = String::from_utf8(lone.stdout).expect("utf-8");
        assert!(
            !text.contains(&view.to_uppercase()),
            "a lone {view} view must not be labelled: {text}"
        );
    }

    // Colour applies to the label like any other human decoration: the word is still
    // there uncoloured, so the layout never depends on a terminal supporting escapes.
    let colored = run(&["--cache", "off", "--color", "always", "--view", "types,summary", root]);
    assert!(colored.status.success());
    let colored = String::from_utf8(colored.stdout).expect("utf-8");
    assert!(colored.contains("TYPES"), "{colored:?}");
    let header_line = colored.lines().find(|line| line.contains("TYPES")).expect("a header line");
    assert!(has_ansi(header_line.as_bytes()), "header carries no escapes: {header_line:?}");

    // Machine formats name their view in a field and must not gain the text header.
    for format in ["json", "jsonl", "yaml"] {
        let machine = run(&[
            "--cache",
            "off",
            "--color",
            "always",
            "--format",
            format,
            "--view",
            "types,summary",
            root,
        ]);
        assert!(machine.status.success(), "{format} run failed");
        let text = String::from_utf8(machine.stdout).expect("utf-8");
        assert!(!text.contains("TYPES"), "{format} leaked a text header:\n{text}");
        assert!(!text.contains("SUMMARY"), "{format} leaked a text header:\n{text}");
    }
}

#[test]
fn explicit_color_also_controls_self_documenting_help() {
    let always = run(&["--color", "always", "--help"]);
    assert!(always.status.success());
    assert!(has_ansi(&always.stdout));
    assert!(always.stderr.is_empty());

    let never = run(&["--color", "never", "--help"]);
    assert!(never.status.success());
    assert!(!has_ansi(&never.stdout));
    assert!(never.stderr.is_empty());
}

#[test]
fn automatic_color_honors_environment_with_documented_precedence() {
    let root = tempfile::tempdir().expect("tempdir");
    let root = root.path().to_str().expect("temporary path is Unicode");
    let base = ["--cache", "off", root];

    let forced = run_with_color_env(&base, None, Some("1"));
    assert!(forced.status.success());
    assert!(has_ansi(&forced.stdout));

    let zero_is_not_forced = run_with_color_env(&base, None, Some("0"));
    assert!(zero_is_not_forced.status.success());
    assert!(!has_ansi(&zero_is_not_forced.stdout));

    let suppressed = run_with_color_env(&base, Some("1"), Some("1"));
    assert!(suppressed.status.success());
    assert!(!has_ansi(&suppressed.stdout));

    let empty_no_color_is_ignored = run_with_color_env(&base, Some(""), Some("1"));
    assert!(empty_no_color_is_ignored.status.success());
    assert!(has_ansi(&empty_no_color_is_ignored.stdout));

    let explicit_always =
        run_with_color_env(&["--color", "always", "--cache", "off", root], Some("1"), None);
    assert!(explicit_always.status.success());
    assert!(has_ansi(&explicit_always.stdout));

    let explicit_never =
        run_with_color_env(&["--color", "never", "--cache", "off", root], None, Some("1"));
    assert!(explicit_never.status.success());
    assert!(!has_ansi(&explicit_never.stdout));
}