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

use crate::error::{Error, WithContext};
use configparser::ini::Ini;
use std::collections::HashMap;
use std::env;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;

static DEFAULT_TAGS: &[&str] = &[
    "Composer",
    "Work",
    "Conductor",
    "Ensemble",
    "Performer",
    "Location",
    "Label",
];

pub struct Config {
    pub hosts: Vec<Host>,
    pub tags: Vec<Tag>,
}

impl Config {
    pub fn default_mpd_host(&self) -> String {
        if self.hosts.is_empty() {
            log::trace!("Found no host in config file, defaulting to 127.0.0.1.");
            "127.0.0.1".to_string()
        } else if let Some(host) = self.hosts.iter().find(|h| &*h.label == "default") {
            log::trace!("Using default host from config: {}", host.host);
            host.host.clone()
        } else {
            log::trace!(
                "No default host configured, using random host from config: {}",
                self.hosts[0].host
            );
            self.hosts[0].host.clone()
        }
    }
}

pub struct Tag {
    pub tag: String,
    pub label: Option<String>,
}

pub struct Host {
    pub host: String,
    pub label: String,
}

impl Default for Config {
    fn default() -> Self {
        Config {
            hosts: Vec::new(),
            tags: DEFAULT_TAGS
                .iter()
                .map(|t| Tag {
                    tag: (*t).to_string(),
                    label: None,
                })
                .collect(),
        }
    }
}

pub fn get() -> Config {
    let home = env::var("HOME").expect("$HOME was not set!");
    let home_config_path: PathBuf = [&*home, ".config", "davis", "davis.conf"].iter().collect();
    let etc_config_path: PathBuf = ["/", "etc", "davis", "davis.conf"].iter().collect();

    let mut conf = Config::default();

    match File::open(&home_config_path)
        .or_else(|_| File::open(&etc_config_path))
        .context("opening config file")
        .and_then(|mut f| {
            log::trace!("Read config from {:?}", f);
            let mut buf = String::new();
            f.read_to_string(&mut buf).context("reading config file")?;
            parse_config(&Ini::new_cs().read(buf).map_err(Error::Config)?)
        }) {
        Ok(f) => {
            conf = f;
        }
        Err(e) if etc_config_path.exists() || home_config_path.exists() => {
            log::warn!(
                "Failed to read config file, will use default instead: {}",
                e
            );
        }
        _ => log::trace!("No config file found, using default."),
    }

    conf
}

fn parse_config(map: &HashMap<String, HashMap<String, Option<String>>>) -> Result<Config, Error> {
    let hosts = map.get("hosts").map_or_else(|| Ok(vec![]), parse_hosts)?;

    let tags = map
        .get("tags")
        .and_then(parse_tags)
        .unwrap_or_else(|| Config::default().tags);

    Ok(Config { hosts, tags })
}

fn parse_hosts(map: &HashMap<String, Option<String>>) -> Result<Vec<Host>, Error> {
    map.iter()
        .map(|(label, host)| {
            Ok(Host {
                host: host.clone().ok_or_else(|| {
                    Error::Config(format!("Missing hostname for host {}.", label))
                })?,
                label: label.clone(),
            })
        })
        .collect::<Result<Vec<Host>, Error>>()
}

fn parse_tags(map: &HashMap<String, Option<String>>) -> Option<Vec<Tag>> {
    map.get("enabled")
        .and_then(Option::as_ref)
        .map(|e| e.split(','))
        .map(|ts| {
            ts.map(|t| Tag {
                tag: t.into(),
                label: map.get(t).and_then(Clone::clone),
            })
            .collect()
        })
}

pub fn mpd_host_env_var() -> Option<String> {
    std::env::var("MPD_HOST").ok()
}