durt 1.0.3

Command line tool for calculating the size of files and directories
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

use clap::{IntoApp, Parser};
use tabular::{Row, Table};
use wild;

mod cli;
use cli::Cli;
use durt::{format_size, Entry};

fn main() {
    #[cfg(windows)]
    ansi_term::enable_ansi_support().expect("Failed to enable ANSI support.");

    let cli = Cli::parse_from(wild::args_os());

    if cli.paths.is_empty() {
        Cli::into_app().print_help().unwrap();
        return;
    }

    let all_entries = cli.paths.iter().filter_map(|path| Entry::from_path(&path));
    let mut entries: Vec<Entry>;

    #[cfg(unix)]
    {
        entries = if cli.same_fs {
            let mut all_entries = all_entries.peekable();
            let first_fs = match all_entries.peek() {
                Some(first) => first.filesystem_id,
                None => return,
            };

            all_entries
                .filter(|e| e.filesystem_id == first_fs)
                .collect()
        } else {
            all_entries.collect()
        };
    }

    #[cfg(not(unix))]
    {
        entries = all_entries.collect::<Vec<_>>();
    }

    if cli.sort {
        if cli.sort_by_path {
            entries.sort_by(|a, b| a.path.cmp(&b.path));
        } else {
            entries.sort_by_key(|e| e.size);
        }
    }

    if cli.reverse_order {
        entries.reverse();
    }

    let mut table = if cli.show_percentages {
        Table::new("  {:>}  {:>}  {:<}")
    } else {
        Table::new("  {:>}  {:<}")
    };

    let total_size = entries.iter().map(|e| e.size).sum();
    let mut omitted_entries = 0;

    for entry in entries {
        let percentage = entry.size as f64 / total_size as f64 * 100.0;

        if let Some(m) = cli.minimum_percentage {
            if percentage < m {
                omitted_entries += 1;
                continue;
            }
        }

        let formatted_size = format_size(entry.size, cli.use_binary_prefixes);
        let mut row = Row::new().with_cell(formatted_size);

        if cli.show_percentages {
            row.add_cell(format!("({:>5.2}%)", percentage));
        }

        row.add_cell(entry.path.display());
        table.add_row(row);
    }

    if omitted_entries > 0 {
        let mut row = Row::new().with_cell("");

        if cli.show_percentages {
            row.add_cell("");
        }

        row.add_cell(if omitted_entries == 1 {
            format!("({} entry omitted)", omitted_entries)
        } else {
            format!("({} entries omitted)", omitted_entries)
        });

        table.add_row(row);
    }

    if cli.show_total {
        let separator = "-".repeat(if cli.use_binary_prefixes { 10 } else { 9 });
        let mut row = Row::new().with_cell(separator);

        if cli.show_percentages {
            row.add_cell("");
        }

        table.add_row(row.with_cell(""));

        let formatted_total = format_size(total_size, cli.use_binary_prefixes);
        let mut row = Row::new().with_cell(formatted_total);

        if cli.show_percentages {
            row.add_cell("");
        }

        row.add_cell("(total)");
        table.add_row(row);
    }

    print!("{}", table);
}