tagdex 1.0.0

An mp3 tag indexer written in Rust.
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

use crate::song::Song;
use itertools::Itertools;
use skim::{
  prelude::{SkimItemReader, SkimOptionsBuilder},
  Skim,
};
use std::io::Cursor;

// Get interactive user input as list of attributes.
fn get_choices(prompt: String, items: Vec<&String>) -> Vec<String> {
  let options = SkimOptionsBuilder::default()
    .height(String::from("100%"))
    .multi(true)
    .prompt(prompt)
    .build()
    .unwrap();

  let items = SkimItemReader::default().of_bufread(Cursor::new(items.iter().join("\n")));

  let result = Skim::run_with(&options, Some(items)).expect("No skim result.");

  match result.final_event {
    skim::prelude::Event::EvActAccept(_) => result
      .selected_items
      .iter()
      .map(|item| item.output().to_string())
      .collect(),
    _ => Vec::new(),
  }
}

// Filter by artist; this needs a special handler as checks require set intersection.
fn filter_artists(songs: &Vec<Song>) -> Vec<&str> {
  let artists: Vec<&String> = songs
    .iter()
    .map(|song| &song.artists)
    .flatten()
    .unique()
    .collect();

  let artists = get_choices(String::from("artist(s): "), artists);

  songs
    .iter()
    .filter(|song| song.artists.iter().any(|artist| artists.contains(artist)))
    .filter_map(|song| song.path.to_str())
    .collect()
}

// Filter by a string attribute retreived by the extractor.
fn filter_single<F>(songs: &Vec<Song>, extractor: F, prompt: String) -> Vec<&str>
where
  F: Fn(&Song) -> &String,
{
  let attrs: Vec<&String> = songs.iter().map(|song| extractor(song)).unique().collect();

  let attrs = get_choices(prompt, attrs);

  songs
    .iter()
    .filter(|song| attrs.contains(extractor(song)))
    .filter_map(|song| song.path.to_str())
    .collect()
}

// Filter by a predefined attribute.
pub fn filter<'a>(songs: &'a Vec<Song>, attr: &'a str) -> Option<Vec<&'a str>> {
  match attr {
    "title" => Some(filter_single(
      &songs,
      |song| &song.title,
      String::from("title: "),
    )),
    "album" => Some(filter_single(
      &songs,
      |song| &song.album,
      String::from("album: "),
    )),
    "artist" => Some(filter_artists(&songs)),
    "genre" => Some(filter_single(
      &songs,
      |song| &song.genre,
      String::from("genre: "),
    )),
    "year" => Some(filter_single(
      &songs,
      |song| &song.year,
      String::from("year: "),
    )),
    _ => None,
  }
}