davis 0.1.1

An CLI client for MPD.
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

pub struct Tags {
    native_mpd: Vec<(String, String)>,
    raw_comments: Vec<(String, String)>,
}

impl Tags {
    pub fn from_song(song: &mpdrs::Song) -> Tags {
        Tags {
            native_mpd: song.tags.clone(),
            raw_comments: vec![],
        }
    }

    pub fn from_song_and_raw_comments(
        song: &mpdrs::Song,
        raw_comments: Vec<(String, String)>,
    ) -> Tags {
        Tags {
            native_mpd: song.tags.clone(),
            raw_comments,
        }
    }

    pub fn get<'a>(&'a self, tag: &'a str) -> Vec<&'a str> {
        let mut tags = tag_filter(&*self.native_mpd, tag).collect::<Vec<_>>();
        if tags.is_empty() {
            tags.extend(tag_filter(&*self.raw_comments, tag));
        }
        tags.sort_unstable();
        tags.dedup();
        tags
    }

    pub fn get_option_joined<'a>(&'a self, tag: &'a str) -> Option<String> {
        let vals = self.get(tag);
        if vals.is_empty() {
            None
        } else {
            Some(vals.join(", "))
        }
    }

    pub fn joined(&self, keys: &[&str], sep: &str) -> Option<String> {
        keys.iter()
            .map(|k| self.get_option_joined(k))
            .collect::<Option<Vec<_>>>()
            .map(|v| v.join(sep))
    }
}

fn tag_filter<'a>(vals: &'a [(String, String)], tag: &'a str) -> impl Iterator<Item = &'a str> {
    vals.iter().filter_map(move |(k, v)| {
        if k.to_uppercase() == tag.to_uppercase() {
            Some(&**v)
        } else {
            None
        }
    })
}