Clean up config.rs

Some refactoring to `config.rs` with the aim to:

* Increase type safety
* Reduce duplication
* Leverage `std::result::Result` & `std::path::PathBuf` APIs

To achieve these goals, the following was done:

* `get_config_file` propagates an `FF2MpvError` if the config file doesn't exist/is invalid
* Always type check `unix` & `windows` code by using `cfg!` expressions over
`#[cfg()]` attributes. This also removed some duplicated lines of code
* Move `#[serde(default)]` to `Config` struct instead of every struct
member: https://serde.rs/container-attrs.html#default

src/config.rs

@@ -1,81 +1,67 @@
+use serde::Deserialize;
 use std::env;
 use std::fs;
 use std::path::PathBuf;
-use serde::Deserialize;
 
 use crate::error::FF2MpvError;
 
 #[derive(Deserialize)]
+#[serde(default)]
 pub struct Config {
-    #[serde(default = "default_player_command")]
     pub player_command: String,
-
-    #[serde(default = "default_player_args")]
     pub player_args: Vec<String>,
 }
 
 impl Default for Config {
     fn default() -> Self {
         Self {
-            player_command: default_player_command(),
+            player_command: "mpv".to_owned(),
-            player_args: default_player_args(),
+            player_args: vec![],
         }
     }
 }
 
 impl Config {
+    pub const FILENAME: &str = "ff2mpv-rust.json";
+
     pub fn build() -> Self {
-        if let Ok(config) = Config::parse_config_file() {
+        Config::parse_config_file().unwrap_or_default()
-            config
-        } else {
-            Config::default()
-        }
     }
 
     pub fn parse_config_file() -> Result<Self, FF2MpvError> {
-        let config_path = Config::get_config_location();
+        let config_path = Config::get_config_location()?;
-        if !config_path.exists() {
-            return Err(FF2MpvError::NoConfig);
-        }
-
         let string = fs::read_to_string(config_path)?;
         let config = serde_json::from_str(&string)?;
 
         Ok(config)
     }
 
-    #[cfg(target_family = "unix")]
+    /// Returns a *valid* config path, i.e. it exists and is readable by the
-    fn get_config_location() -> PathBuf {
+    /// current user. If the config path is not valid, an [`FF2MpvError`] is
-        let mut path = PathBuf::new();
+    /// returned.
-
+    fn get_config_location() -> Result<PathBuf, FF2MpvError> {
-        if let Ok(home) = env::var("XDG_CONFIG_HOME") {
+        let config_dir = if cfg!(target_family = "unix") {
-            path.push(home);
+            if let Ok(home) = env::var("XDG_CONFIG_HOME") {
-        } else if let Ok(home) = env::var("HOME") {
+                PathBuf::from(home)
-            path.push(home);
+            } else if let Ok(home) = env::var("HOME") {
-            path.push(".config");
+                PathBuf::from(home).join(".config")
+            } else {
+                PathBuf::from("/etc")
+            }
+        } else if cfg!(target_family = "windows") {
+            env::var("APPDATA")
+                .map_err(|_| FF2MpvError::NoConfig)?
+                .into()
         } else {
-            path.push("/etc");
+            unimplemented!("This platform is not supported")
+        };
+
+        let path = config_dir.join(Config::FILENAME);
+        match path.try_exists() {
+            Ok(true) => Ok(path),
+            // Broken symbolic link to config file.
+            Ok(false) => Err(FF2MpvError::NoConfig),
+            Err(err) => Err(FF2MpvError::IOError(err)),
         }
-
-        path.push("ff2mpv-rust.json");
-        path
-    }
-
-    #[cfg(target_family = "windows")]
-    fn get_config_location() -> PathBuf {
-        let mut path = PathBuf::new();
-        let appdata = env::var("APPDATA").unwrap();
-
-        path.push(appdata);
-        path.push("ff2mpv-rust.json");
-        path
     }
 }
-
-fn default_player_command() -> String {
-    "mpv".to_owned()
-}
-
-fn default_player_args() -> Vec<String> {
-    vec![]
-}