mecomp_core/
config.rs

1//! Handles the configuration of the daemon.
2//!
3//! this module is responsible for parsing the Config.toml file, parsing cli arguments, and
4//! setting up the logger.
5
6use config::{Config, ConfigError, Environment, File};
7use one_or_many::OneOrMany;
8use serde::Deserialize;
9
10use std::{path::PathBuf, str::FromStr};
11
12use mecomp_storage::util::MetadataConflictResolution;
13
14pub static DEFAULT_CONFIG: &str = include_str!("../Mecomp.toml");
15
16#[derive(Clone, Debug, Deserialize, Default, PartialEq, Eq)]
17pub struct Settings {
18    /// General Daemon Settings
19    #[serde(default)]
20    pub daemon: DaemonSettings,
21    /// Parameters for the reclustering algorithm.
22    #[serde(default)]
23    pub reclustering: ReclusterSettings,
24    /// Settings for the TUI
25    #[serde(default)]
26    pub tui: TuiSettings,
27}
28
29impl Settings {
30    /// Load settings from the config file, environment variables, and CLI arguments.
31    ///
32    /// The config file is located at the path specified by the `--config` flag.
33    ///
34    /// The environment variables are prefixed with `MECOMP_`.
35    ///
36    /// # Arguments
37    ///
38    /// * `flags` - The parsed CLI arguments.
39    ///
40    /// # Errors
41    ///
42    /// This function will return an error if the config file is not found or if the config file is
43    /// invalid.
44    #[inline]
45    pub fn init(
46        config: PathBuf,
47        port: Option<u16>,
48        log_level: Option<log::LevelFilter>,
49    ) -> Result<Self, ConfigError> {
50        let s = Config::builder()
51            .add_source(File::from(config))
52            .add_source(Environment::with_prefix("MECOMP"))
53            .build()?;
54
55        let mut settings: Self = s.try_deserialize()?;
56
57        for path in &mut settings.daemon.library_paths {
58            *path = shellexpand::tilde(&path.to_string_lossy())
59                .into_owned()
60                .into();
61        }
62
63        if let Some(port) = port {
64            settings.daemon.rpc_port = port;
65        }
66
67        if let Some(log_level) = log_level {
68            settings.daemon.log_level = log_level;
69        }
70
71        Ok(settings)
72    }
73
74    /// Get the (default) path to the config file.
75    /// If the config file does not exist at this path, it will be created with the default config.
76    ///
77    /// See [`crate::get_config_dir`] for more information about where this default path is located.
78    ///
79    /// # Errors
80    ///
81    /// This function will return an error if the system config directory (e.g., `~/.config` on linux) could not be found, or if the config file was missing and could not be created.
82    #[inline]
83    pub fn get_config_path() -> Result<PathBuf, std::io::Error> {
84        match crate::get_config_dir() {
85            Ok(config_dir) => {
86                // if the config directory does not exist, create it
87                if !config_dir.exists() {
88                    std::fs::create_dir_all(&config_dir)?;
89                }
90                let config_file = config_dir.join("Mecomp.toml");
91
92                if !config_file.exists() {
93                    std::fs::write(&config_file, DEFAULT_CONFIG)?;
94                }
95
96                Ok(config_file)
97            }
98            Err(e) => {
99                eprintln!("Error: {e}");
100                Err(std::io::Error::new(
101                    std::io::ErrorKind::NotFound,
102                    "Unable to find the config directory for mecomp.",
103                ))
104            }
105        }
106    }
107}
108
109#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
110pub struct DaemonSettings {
111    /// The port to listen on for RPC requests.
112    /// Default is 6600.
113    #[serde(default = "default_port")]
114    pub rpc_port: u16,
115    /// The root paths of the music library.
116    #[serde(default = "default_library_paths")]
117    pub library_paths: Box<[PathBuf]>,
118    /// Separators for artist names in song metadata.
119    /// For example, "Foo, Bar, Baz" would be split into \["Foo", "Bar", "Baz"\]. if the separator is ", ".
120    /// If the separator is not found, the entire string is considered as a single artist.
121    /// If unset, will not split artists.
122    ///
123    /// Users can provide one or many separators, and must provide them as either a single string or an array of strings.
124    ///
125    /// ```toml
126    /// [daemon]
127    /// artist_separator = " & "
128    /// artist_separator = [" & ", "; "]
129    /// ...
130    /// ```
131    #[serde(default, deserialize_with = "de_artist_separator")]
132    pub artist_separator: OneOrMany<String>,
133    /// Exceptions for artist name separation, for example:
134    /// "Foo & Bar; Baz" would be split into \["Foo", "Bar", "Baz"\] if the separators are set to "&" and "; ".
135    ///
136    /// However, if the following exception is set:
137    /// ```toml
138    /// [daemon]
139    /// protected_artist_names = ["Foo & Bar"]
140    /// ```
141    /// Then the artist "Foo & Bar; Baz" would be split into \["Foo & Bar", "Baz"\].
142    ///
143    /// Note that the exception applies to the entire "name", so:
144    /// ```toml
145    /// [daemon]
146    /// protected_artist_names = ["Foo & Bar"]
147    /// ```
148    /// would split "Foo & Bar" into \["Foo & Bar"\],
149    /// but "Foo & Bar Baz" would still be split into \["Foo", "Bar Baz"\].
150    #[serde(default)]
151    pub protected_artist_names: OneOrMany<String>,
152    #[serde(default)]
153    pub genre_separator: Option<String>,
154    /// how conflicting metadata should be resolved
155    /// "overwrite" - overwrite the metadata with new metadata
156    /// "skip" - skip the file (keep old metadata)
157    #[serde(default)]
158    pub conflict_resolution: MetadataConflictResolution,
159    /// What level of logging to use.
160    /// Default is "info".
161    #[serde(default = "default_log_level")]
162    #[serde(deserialize_with = "de_log_level")]
163    pub log_level: log::LevelFilter,
164}
165
166fn de_artist_separator<'de, D>(deserializer: D) -> Result<OneOrMany<String>, D::Error>
167where
168    D: serde::Deserializer<'de>,
169{
170    let v = OneOrMany::<String>::deserialize(deserializer)?
171        .into_iter()
172        .filter(|s| !s.is_empty())
173        .collect::<OneOrMany<String>>();
174    if v.is_empty() {
175        Ok(OneOrMany::None)
176    } else {
177        Ok(v)
178    }
179}
180
181fn de_log_level<'de, D>(deserializer: D) -> Result<log::LevelFilter, D::Error>
182where
183    D: serde::Deserializer<'de>,
184{
185    let s = String::deserialize(deserializer)?;
186    Ok(log::LevelFilter::from_str(&s).unwrap_or_else(|_| default_log_level()))
187}
188
189const fn default_port() -> u16 {
190    6600
191}
192
193fn default_library_paths() -> Box<[PathBuf]> {
194    vec![shellexpand::tilde("~/Music/").into_owned().into()].into_boxed_slice()
195}
196
197const fn default_log_level() -> log::LevelFilter {
198    log::LevelFilter::Info
199}
200
201impl Default for DaemonSettings {
202    #[inline]
203    fn default() -> Self {
204        Self {
205            rpc_port: default_port(),
206            library_paths: default_library_paths(),
207            artist_separator: OneOrMany::None,
208            protected_artist_names: OneOrMany::None,
209            genre_separator: None,
210            conflict_resolution: MetadataConflictResolution::Overwrite,
211            log_level: default_log_level(),
212        }
213    }
214}
215
216#[derive(Clone, Copy, Debug, Deserialize, Default, PartialEq, Eq)]
217#[serde(rename_all = "lowercase")]
218pub enum ClusterAlgorithm {
219    KMeans,
220    #[default]
221    GMM,
222}
223
224#[cfg(feature = "analysis")]
225impl From<ClusterAlgorithm> for mecomp_analysis::clustering::ClusteringMethod {
226    #[inline]
227    fn from(algo: ClusterAlgorithm) -> Self {
228        match algo {
229            ClusterAlgorithm::KMeans => Self::KMeans,
230            ClusterAlgorithm::GMM => Self::GaussianMixtureModel,
231        }
232    }
233}
234
235#[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq)]
236#[serde(rename_all = "lowercase")]
237pub enum ProjectionMethod {
238    #[default]
239    None,
240    TSne,
241    Pca,
242}
243
244#[cfg(feature = "analysis")]
245impl From<ProjectionMethod> for mecomp_analysis::clustering::ProjectionMethod {
246    #[inline]
247    fn from(proj: ProjectionMethod) -> Self {
248        match proj {
249            ProjectionMethod::None => Self::None,
250            ProjectionMethod::TSne => Self::TSne,
251            ProjectionMethod::Pca => Self::Pca,
252        }
253    }
254}
255
256#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
257pub struct ReclusterSettings {
258    /// The number of reference datasets to use for the gap statistic.
259    /// (which is used to determine the optimal number of clusters)
260    /// 50 will give a decent estimate but for the best results use more,
261    /// 500 will give a very good estimate but be very slow.
262    /// We default to 250 in release mode.
263    #[serde(default = "default_gap_statistic_reference_datasets")]
264    pub gap_statistic_reference_datasets: usize,
265    /// The maximum number of clusters to create.
266    /// This is the upper bound on the number of clusters that can be created.
267    /// Increase if you're getting a "could not find optimal k" error.
268    /// Default is 24.
269    #[serde(default = "default_max_clusters")]
270    pub max_clusters: usize,
271    /// The clustering algorithm to use.
272    /// Either "kmeans" or "gmm".
273    #[serde(default)]
274    pub algorithm: ClusterAlgorithm,
275    /// The projection method to preprocess the data with before clustering.
276    /// Either "tsne", "pca", or "none".
277    /// Default is "none".
278    #[serde(default)]
279    pub projection_method: ProjectionMethod,
280}
281
282const fn default_gap_statistic_reference_datasets() -> usize {
283    50
284}
285
286const fn default_max_clusters() -> usize {
287    #[cfg(debug_assertions)]
288    return 16;
289    #[cfg(not(debug_assertions))]
290    return 24;
291}
292
293impl Default for ReclusterSettings {
294    #[inline]
295    fn default() -> Self {
296        Self {
297            gap_statistic_reference_datasets: default_gap_statistic_reference_datasets(),
298            max_clusters: default_max_clusters(),
299            algorithm: ClusterAlgorithm::default(),
300            projection_method: ProjectionMethod::default(),
301        }
302    }
303}
304
305#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
306pub struct TuiSettings {
307    /// How many songs should be queried for when starting a radio.
308    /// Default is 20.
309    #[serde(default = "default_radio_count")]
310    pub radio_count: u32,
311    /// The color scheme to use for the TUI.
312    /// Each color is either:
313    /// - a hex string in the format `#RRGGBB`.
314    ///   example: `#FFFFFF` for white.
315    /// - a material design color name in format "<COLOR>_<SHADE>".
316    ///   so "pink", `red-900`,  `light-blue_500`, `red900`, etc. are all invalid.
317    ///   but `PINK_900`, `RED_900`, `LIGHT_BLUE_500` are valid.
318    ///   - Exceptions are `WHITE` and `BLACK`, which are always valid.
319    #[serde(default)]
320    pub colors: TuiColorScheme,
321}
322
323const fn default_radio_count() -> u32 {
324    20
325}
326
327impl Default for TuiSettings {
328    #[inline]
329    fn default() -> Self {
330        Self {
331            radio_count: default_radio_count(),
332            colors: TuiColorScheme::default(),
333        }
334    }
335}
336
337#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Default)]
338pub struct TuiColorScheme {
339    /// app border colors
340    pub app_border: Option<String>,
341    pub app_border_text: Option<String>,
342    /// border colors
343    pub border_unfocused: Option<String>,
344    pub border_focused: Option<String>,
345    /// popup border color
346    pub popup_border: Option<String>,
347    /// text colors
348    pub text_normal: Option<String>,
349    pub text_highlight: Option<String>,
350    pub text_highlight_alt: Option<String>,
351    /// gauge colors, such as song progress bar
352    pub gauge_filled: Option<String>,
353    pub gauge_unfilled: Option<String>,
354}
355
356#[cfg(test)]
357mod tests {
358    use super::*;
359
360    use pretty_assertions::assert_eq;
361    use rstest::rstest;
362
363    #[derive(Debug, PartialEq, Eq, Deserialize)]
364    #[serde(transparent)]
365    struct ArtistSeparatorTest {
366        #[serde(deserialize_with = "de_artist_separator")]
367        artist_separator: OneOrMany<String>,
368    }
369
370    #[rstest]
371    #[case(Vec::<String>::new())]
372    #[case("")]
373    fn test_de_artist_separator_empty<'de, D>(#[case] input: D)
374    where
375        D: serde::de::IntoDeserializer<'de>,
376    {
377        let deserializer = input.into_deserializer();
378        let result: Result<OneOrMany<String>, _> = de_artist_separator(deserializer);
379        assert!(result.is_ok());
380        assert!(result.unwrap().is_empty());
381    }
382
383    #[rstest]
384    #[case(vec![" & "], String::from(" & ").into())]
385    #[case(" & ", String::from(" & ").into())]
386    #[case(vec![" & ", "; "], vec![String::from(" & "), String::from("; ")].into())]
387    #[case(vec!["", " & ", "", "; "], vec![String::from(" & "), String::from("; ")].into())]
388    fn test_de_artist_separator<'de, D>(#[case] input: D, #[case] expected: OneOrMany<String>)
389    where
390        D: serde::de::IntoDeserializer<'de>,
391    {
392        let deserializer = input.into_deserializer();
393        let result: Result<OneOrMany<String>, _> = de_artist_separator(deserializer);
394        assert!(result.is_ok());
395        assert_eq!(result.unwrap(), expected);
396    }
397
398    #[test]
399    fn test_init_config() {
400        let temp_dir = tempfile::tempdir().unwrap();
401        let config_path = temp_dir.path().join("config.toml");
402        std::fs::write(
403            &config_path,
404            r#"            
405[daemon]
406rpc_port = 6600
407library_paths = ["/Music"]
408artist_separator = ["; "]
409genre_separator = ", "
410conflict_resolution = "overwrite"
411log_level = "debug"
412
413[reclustering]
414gap_statistic_reference_datasets = 50
415max_clusters = 24
416algorithm = "gmm"
417
418[tui]
419radio_count = 21
420[tui.colors]
421app_border = "PINK_900"
422app_border_text = "PINK_300"
423border_unfocused = "RED_900"
424border_focused = "RED_200"
425popup_border = "LIGHT_BLUE_500"
426text_normal = "WHITE"
427text_highlight = "RED_600"
428text_highlight_alt = "RED_200"
429gauge_filled = "WHITE"
430gauge_unfilled = "BLACK"
431            "#,
432        )
433        .unwrap();
434
435        let expected = Settings {
436            daemon: DaemonSettings {
437                rpc_port: 6600,
438                library_paths: ["/Music".into()].into(),
439                artist_separator: vec!["; ".into()].into(),
440                protected_artist_names: OneOrMany::None,
441                genre_separator: Some(", ".into()),
442                conflict_resolution: MetadataConflictResolution::Overwrite,
443                log_level: log::LevelFilter::Debug,
444            },
445            reclustering: ReclusterSettings {
446                gap_statistic_reference_datasets: 50,
447                max_clusters: 24,
448                algorithm: ClusterAlgorithm::GMM,
449                projection_method: ProjectionMethod::None,
450            },
451            tui: TuiSettings {
452                radio_count: 21,
453                colors: TuiColorScheme {
454                    app_border: Some("PINK_900".into()),
455                    app_border_text: Some("PINK_300".into()),
456                    border_unfocused: Some("RED_900".into()),
457                    border_focused: Some("RED_200".into()),
458                    popup_border: Some("LIGHT_BLUE_500".into()),
459                    text_normal: Some("WHITE".into()),
460                    text_highlight: Some("RED_600".into()),
461                    text_highlight_alt: Some("RED_200".into()),
462                    gauge_filled: Some("WHITE".into()),
463                    gauge_unfilled: Some("BLACK".into()),
464                },
465            },
466        };
467
468        let settings = Settings::init(config_path, None, None).unwrap();
469
470        assert_eq!(settings, expected);
471    }
472
473    #[test]
474    fn test_tui_colors_unset() {
475        let temp_dir = tempfile::tempdir().unwrap();
476        let config_path = temp_dir.path().join("config.toml");
477        std::fs::write(
478            &config_path,
479            r#"            
480[daemon]
481rpc_port = 6600
482library_paths = ["/Music"]
483artist_separator = ["; "]
484protected_artist_names = ["Foo & Bar"]
485genre_separator = ", "
486conflict_resolution = "overwrite"
487log_level = "debug"
488
489[reclustering]
490gap_statistic_reference_datasets = 50
491max_clusters = 24
492algorithm = "gmm"
493
494[tui]
495radio_count = 21
496            "#,
497        )
498        .unwrap();
499
500        let expected = Settings {
501            daemon: DaemonSettings {
502                rpc_port: 6600,
503                library_paths: ["/Music".into()].into(),
504                artist_separator: vec!["; ".into()].into(),
505                protected_artist_names: "Foo & Bar".to_string().into(),
506                genre_separator: Some(", ".into()),
507                conflict_resolution: MetadataConflictResolution::Overwrite,
508                log_level: log::LevelFilter::Debug,
509            },
510            reclustering: ReclusterSettings {
511                gap_statistic_reference_datasets: 50,
512                max_clusters: 24,
513                algorithm: ClusterAlgorithm::GMM,
514                projection_method: ProjectionMethod::None,
515            },
516            tui: TuiSettings {
517                radio_count: 21,
518                colors: TuiColorScheme::default(),
519            },
520        };
521
522        let settings = Settings::init(config_path, None, None).unwrap();
523
524        assert_eq!(settings, expected);
525    }
526
527    #[test]
528    fn test_artist_names_to_not_split() {
529        let temp_dir = tempfile::tempdir().unwrap();
530        let config_path = temp_dir.path().join("config.toml");
531        std::fs::write(
532            &config_path,
533            r#"            
534[daemon]
535rpc_port = 6600
536library_paths = ["/Music"]
537artist_separator = ["; "]
538protected_artist_names = ["Foo & Bar"]
539genre_separator = ", "
540conflict_resolution = "overwrite"
541log_level = "debug"
542
543[reclustering]
544gap_statistic_reference_datasets = 50
545max_clusters = 24
546algorithm = "gmm"
547
548[tui]
549radio_count = 21
550            "#,
551        )
552        .unwrap();
553
554        let expected = Settings {
555            daemon: DaemonSettings {
556                rpc_port: 6600,
557                library_paths: ["/Music".into()].into(),
558                artist_separator: vec!["; ".into()].into(),
559                protected_artist_names: "Foo & Bar".to_string().into(),
560                genre_separator: Some(", ".into()),
561                conflict_resolution: MetadataConflictResolution::Overwrite,
562                log_level: log::LevelFilter::Debug,
563            },
564            reclustering: ReclusterSettings {
565                gap_statistic_reference_datasets: 50,
566                max_clusters: 24,
567                algorithm: ClusterAlgorithm::GMM,
568                projection_method: ProjectionMethod::None,
569            },
570            tui: TuiSettings {
571                radio_count: 21,
572                colors: TuiColorScheme::default(),
573            },
574        };
575
576        let settings = Settings::init(config_path, None, None).unwrap();
577
578        assert_eq!(settings, expected);
579    }
580
581    #[test]
582    fn test_default_config_works() {
583        let temp_dir = tempfile::tempdir().unwrap();
584        let config_path = temp_dir.path().join("config.toml");
585        std::fs::write(&config_path, DEFAULT_CONFIG).unwrap();
586
587        let settings = Settings::init(config_path, None, None);
588
589        assert!(settings.is_ok(), "Error: {:?}", settings.err());
590    }
591}
mecomp_core/config.rs

mecomp_core/
config.rs
