duvis 0.1.8

Disk usage visualizer for both AI and humans
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

use std::io::{self, Write};
#[cfg(feature = "ui")]
use std::path::PathBuf;

use anyhow::Result;

use crate::classify;
#[cfg(feature = "ui")]
use crate::entry::SortOrder;
use crate::render::{self, RenderConfig};
#[cfg(feature = "ui")]
use crate::scan::HardlinkPolicy;
use crate::scan::{self};
use crate::wire::explain::WireExplain;

use super::plan::{RunPlan, ScanPlan};

/// Dispatch the parsed plan. Each variant handler owns its own IO
/// (stdout lock, async runtime, etc.) so the dispatcher stays a single
/// match.
pub(super) fn run(plan: RunPlan) -> Result<()> {
    match plan {
        RunPlan::ExplainCategory { name, json } => run_explain(&name, json),
        #[cfg(feature = "ui")]
        RunPlan::Ui {
            path,
            port,
            sort,
            reverse,
            hardlinks,
        } => run_ui(path, port, sort, reverse, hardlinks),
        RunPlan::Scan(scan) => run_scan(scan),
    }
}

fn run_explain(name: &str, json: bool) -> Result<()> {
    let stdout = io::stdout();
    let mut out = stdout.lock();
    explain_category(name, json, &mut out)?;
    out.flush()?;
    Ok(())
}

#[cfg(feature = "ui")]
fn run_ui(
    path: PathBuf,
    port: u16,
    sort: SortOrder,
    reverse: bool,
    hardlinks: HardlinkPolicy,
) -> Result<()> {
    // The UI server runs the scan in a background task so the browser can
    // pop up immediately and show "Scanning..." while we wait.
    let rt = tokio::runtime::Runtime::new()?;
    rt.block_on(crate::ui::serve(path, port, sort, reverse, hardlinks))?;
    Ok(())
}

fn run_scan(plan: ScanPlan) -> Result<()> {
    let (mut tree, counts) = scan::scan(&plan.path, plan.hardlinks)?;
    tree.sort(&plan.sort, plan.reverse);

    let config = RenderConfig {
        max_depth: plan.max_depth,
        top: plan.top,
        scan_root: &plan.path,
        counts: &counts,
        hardlinks: plan.hardlinks,
        filter: &plan.filter,
    };
    let stdout = io::stdout();
    let mut out = stdout.lock();
    render::write(&tree, &config, plan.mode, &mut out)?;
    out.flush()?;

    let skipped = counts.skipped();
    if skipped > 0 {
        let plural = if skipped == 1 { "" } else { "s" };
        eprintln!(
            "warning: {skipped} path{plural} could not be read \
             (permission denied or path vanished); reported total may be incomplete"
        );
    }
    Ok(())
}

/// Render `--explain-category <NAME>`. We classify the name both as a
/// directory and as a file (the same string can match different rules in
/// each role — e.g. `node_modules` is `cache` as a dir but `other` as a
/// file) and surface both so callers don't have to guess which role to
/// pass.
fn explain_category(name: &str, json: bool, out: &mut impl Write) -> Result<()> {
    let as_dir = classify::explain_dir(name);
    let as_file = classify::explain_file(name);
    if json {
        let payload = WireExplain::new(name, &as_dir, &as_file);
        writeln!(out, "{}", serde_json::to_string_pretty(&payload)?)?;
    } else {
        writeln!(out, "{name:?}")?;
        writeln!(
            out,
            "  as directory: {:<12} ({})",
            as_dir.category.label(),
            as_dir.reason.describe()
        )?;
        writeln!(
            out,
            "  as file:      {:<12} ({})",
            as_file.category.label(),
            as_file.reason.describe()
        )?;
    }
    Ok(())
}