dapctl 1.0.0

TUI/CLI sync tool for HiFi Digital Audio Players
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

use std::path::PathBuf;

use clap::Args as ClapArgs;

use crate::audit::{AuditReport, Severity};

#[derive(ClapArgs, Debug)]
pub struct Args {
    /// Path to the music library to audit (defaults to the source of the
    /// first available sync profile if omitted).
    pub path: Option<PathBuf>,

    /// Emit JSON instead of the human table.
    #[arg(long)]
    pub json: bool,

    /// Only report issues at or above this severity (high | med | low).
    #[arg(long, value_name = "LEVEL", default_value = "low")]
    pub min_severity: SeverityArg,

    /// Limit output to the first N albums.
    #[arg(long, value_name = "N")]
    pub limit: Option<usize>,
}

/// Thin newtype so clap can parse "high" / "med" / "low".
#[derive(Debug, Clone, clap::ValueEnum)]
pub enum SeverityArg {
    High,
    Med,
    Low,
}

impl From<&SeverityArg> for Severity {
    fn from(a: &SeverityArg) -> Self {
        match a {
            SeverityArg::High => Severity::High,
            SeverityArg::Med => Severity::Medium,
            SeverityArg::Low => Severity::Low,
        }
    }
}

pub fn run(args: Args) -> anyhow::Result<()> {
    let path = resolve_library_path(args.path)?;
    let min_sev = Severity::from(&args.min_severity);

    eprintln!("Scanning {} …", path.display());
    let report = crate::audit::scan(&path)?;

    if args.json {
        println!("{}", serde_json::to_string_pretty(&report)?);
        return Ok(());
    }

    print_human(&report, min_sev, args.limit);
    Ok(())
}

fn resolve_library_path(arg: Option<PathBuf>) -> anyhow::Result<PathBuf> {
    if let Some(p) = arg {
        return Ok(p);
    }
    // Fall back to the source of the first loadable sync profile.
    let profiles = crate::config::discover()?;
    let Some((_, path)) = profiles.into_iter().next() else {
        anyhow::bail!(
            "No library path given and no sync profile found; \
             pass a path: dapctl audit /path/to/music"
        );
    };
    let profile = crate::config::load(&path)?;
    Ok(PathBuf::from(profile.profile.source))
}

fn print_human(report: &AuditReport, min_sev: Severity, limit: Option<usize>) {
    println!("AUDIT  {}", report.library.display());
    println!(
        "       {} tracks · {} albums · {} with issues",
        report.tracks_scanned, report.albums_scanned, report.albums_with_issues,
    );
    println!("{}", "─".repeat(70));

    let filtered: Vec<_> = report
        .albums
        .iter()
        .filter(|a| a.max_severity().is_some_and(|s| s <= min_sev))
        .collect();

    let shown = match limit {
        Some(n) => &filtered[..filtered.len().min(n)],
        None => &filtered[..],
    };

    for album in shown {
        for ai in &album.issues {
            if ai.severity > min_sev {
                continue;
            }
            println!(
                "  {}  {:<42}  {}",
                ai.severity,
                truncate(&album.display, 42),
                ai.issue.description(),
            );
        }
    }

    if let (Some(_), true) = (limit, filtered.len() > shown.len()) {
        println!(
            "  … {} more albums (remove --limit to see all)",
            filtered.len() - shown.len()
        );
    }

    println!("{}", "─".repeat(70));
    println!(
        "  {} issues  ({} high · {} medium · {} low)",
        report.issues_total, report.high, report.medium, report.low,
    );

    if report.high > 0 {
        println!();
        println!("  Tip: run untagged tracks through MusicBrainz Picard");
    }
}

fn truncate(s: &str, max: usize) -> String {
    if s.len() <= max {
        return s.to_owned();
    }
    format!("…{}", &s[s.len().saturating_sub(max - 1)..])
}