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
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

use crate::testing_prelude::*;

const MOCK_FILE_SIZE: i64 = 1024;

const MOCK_NAME: &str = "album";

/// Builds bencode-encoded test torrents, preserving entry order.
pub(crate) struct TorrentBuilder {
    /// Encoded dictionary entries in insertion order.
    entries: Vec<u8>,
}

impl TorrentBuilder {
    /// Create an empty [`TorrentBuilder`].
    pub fn new() -> Self {
        Self {
            entries: Vec::new(),
        }
    }

    /// Create a file [`TorrentBuilder`] with a fixed length and `path` of `components`.
    pub fn file<I>(components: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<RawString>,
    {
        Self::new()
            .with_integer("length", MOCK_FILE_SIZE)
            .with_list("path", components)
    }

    /// Append a byte-string entry encoded as `<len>:<bytes>`.
    pub fn with_string(mut self, key: &str, value: impl Into<RawString>) -> Self {
        self.push_bytes(key.as_bytes());
        self.push_bytes(value.into().as_bytes());
        self
    }

    /// Append an integer entry encoded as `i<value>e`.
    pub fn with_integer(mut self, key: &str, value: i64) -> Self {
        self.push_bytes(key.as_bytes());
        self.entries
            .extend_from_slice(format!("i{value}e").as_bytes());
        self
    }

    /// Append a list of byte-string entries encoded as `l<items>e`.
    pub fn with_list<I>(mut self, key: &str, items: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<RawString>,
    {
        self.push_bytes(key.as_bytes());
        self.entries.push(b'l');
        for item in items {
            self.push_bytes(item.into().as_bytes());
        }
        self.entries.push(b'e');
        self
    }

    /// Append a nested dictionary entry.
    pub fn with_dictionary(mut self, key: &str, dictionary: TorrentBuilder) -> Self {
        self.push_bytes(key.as_bytes());
        self.entries.extend_from_slice(&dictionary.build());
        self
    }

    /// Append a list of dictionaries encoded as `l<dictionaries>e`.
    pub fn with_dictionaries(mut self, key: &str, dictionaries: Vec<TorrentBuilder>) -> Self {
        self.push_bytes(key.as_bytes());
        self.entries.push(b'l');
        for dictionary in dictionaries {
            self.entries.extend_from_slice(&dictionary.build());
        }
        self.entries.push(b'e');
        self
    }

    /// Append an `info` dictionary for a multi-file torrent named `album`.
    ///
    /// - Adds one file with a fixed length and `path` of `components`
    pub fn with_multi_file<I>(self, components: I) -> Self
    where
        I: IntoIterator,
        I::Item: Into<RawString>,
    {
        self.with_dictionary(
            "info",
            TorrentBuilder::new()
                .with_dictionaries("files", vec![TorrentBuilder::file(components)])
                .with_string("name", MOCK_NAME),
        )
    }

    /// Encode the accumulated entries as a bencode dictionary (`d…e`).
    pub fn build(self) -> Vec<u8> {
        let mut bytes = vec![b'd'];
        bytes.extend_from_slice(&self.entries);
        bytes.push(b'e');
        bytes
    }

    /// Append a bencode byte string (`<len>:<bytes>`).
    fn push_bytes(&mut self, bytes: &[u8]) {
        self.entries
            .extend_from_slice(format!("{}:", bytes.len()).as_bytes());
        self.entries.extend_from_slice(bytes);
    }
}

#[cfg(test)]
mod tests {
    use crate::testing_prelude::*;

    /// A nested structure encodes to the expected bencode byte string.
    #[test]
    fn torrent_builder_build() {
        // Arrange
        let builder = TorrentBuilder::new().with_dictionary(
            "info",
            TorrentBuilder::new()
                .with_dictionaries("files", vec![TorrentBuilder::file(["song.flac"])])
                .with_string("name", "album"),
        );

        // Act
        let output = builder.build();

        // Assert
        assert_eq!(
            output,
            b"d4:infod5:filesld6:lengthi1024e4:pathl9:song.flaceee4:name5:albumee".to_vec()
        );
    }
}