caesura 0.31.0

An all-in-one command line tool to transcode FLAC audio files and upload to gazelle based indexers/trackers
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

use crate::prelude::*;

/// A `.torrent` file previously inspected by the `audit` command.
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub(crate) struct AuditItem {
    /// Absolute path to the `.torrent` file.
    pub path: PathBuf,
    /// Torrent name, for human-readable listings.
    pub name: Option<String>,
    /// Torrent `source`, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    /// Tracker torrent id from the `comment` URL, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u32>,
    /// Tracker torrent URL from the `comment` field, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    /// Path problems found, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issues: Option<Vec<AuditIssue>>,
}

impl From<AuditIssueKind> for AuditItem {
    fn from(value: AuditIssueKind) -> Self {
        Self {
            issues: Some(vec![AuditIssue {
                kind: value,
                ..AuditIssue::default()
            }]),
            ..Self::default()
        }
    }
}

impl From<AuditTorrent> for AuditItem {
    fn from(torrent: AuditTorrent) -> Self {
        Self {
            name: Some(torrent.name.to_string()),
            source: torrent.source,
            id: torrent.id,
            url: torrent.url.clone(),
            ..AuditItem::default()
        }
    }
}

impl AuditItem {
    /// Human-readable one-line label for console output.
    ///
    /// - Renders the torrent name as a hyperlink when a URL is known
    /// - Falls back to the file name when the torrent name is absent
    pub fn render(&self, bb_code: bool) -> String {
        if bb_code && let Some(url) = &self.url {
            return url.dimmed().hyperlink(url).clone();
        }
        let path = self
            .path
            .file_name()
            .expect("should have a file name")
            .display()
            .to_string()
            .dimmed();
        let Some(name) = &self.name else {
            return format!("{path}");
        };
        let name = name.cyan().dimmed();
        let name = match &self.url {
            Some(url) => name.hyperlink(url),
            None => name.to_string(),
        };
        if let Some(source) = &self.source
            && let Some(id) = &self.id
        {
            format!("{} {} {name}", source.dimmed(), id.to_string().dimmed())
        } else {
            format!("{name} {path}")
        }
    }

    /// Get all issue kinds.
    #[cfg(test)]
    pub fn get_issue_kinds(&self) -> HashSet<AuditIssueKind> {
        self.issues
            .iter()
            .flatten()
            .map(|issue| issue.kind)
            .collect()
    }

    /// Are any issues of specified `kind`.
    #[cfg(test)]
    pub fn has_kind(&self, kind: AuditIssueKind) -> bool {
        self.issues.iter().flatten().any(|issue| issue.kind == kind)
    }

    /// Are any issues of specified `kind`.
    #[cfg(test)]
    pub fn has_path_kind(&self, kind: AuditPathIssueKind) -> bool {
        self.has_kind(AuditIssueKind::Path(kind))
    }
}