Fix loading files from $XDG_DATA_HOME

Closes #11.

Author: mbrubeck

Cargo.lock

@@ -16,10 +16,11 @@ exclude = ["tests/*", "benches/*/"]
 edition = "2021"
 
 [dependencies]
+home = "0.5.0"
 petgraph = "0.6.0"
 nom = "7.0"
 fnv = "1.0"
-memchr = "2.7"
+memchr = "2.0"
 once_cell = "1.0"
 tree_magic_db = { version = "3.0", path = "./magic_db" , optional = true }
 

Cargo.toml

@@ -6,31 +6,19 @@ use fnv::FnvHashMap;
 use once_cell::sync::Lazy;
 use petgraph::prelude::*;
 
-/// Preload alias list
-static ALIASES: Lazy<FnvHashMap<Mime, Mime>> = Lazy::new(init::get_aliaslist);
-
-/// Load magic file before anything else.
-static ALL_RULES: Lazy<FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>>> = Lazy::new(rules);
-
 pub mod check;
 pub mod init;
 
 #[cfg(not(feature = "with-gpl-data"))]
 mod runtime;
 
-fn rules() -> FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>> {
+/// Preload alias list
+static ALIASES: Lazy<FnvHashMap<Mime, Mime>> = Lazy::new(init::get_aliaslist);
+
+/// Load magic file before anything else.
+static ALL_RULES: Lazy<FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>>> = Lazy::new(|| {
     #[cfg(feature = "with-gpl-data")]
-    return static_rules();
+    return super::ruleset::from_u8(tree_magic_db::magic()).unwrap_or_default();
     #[cfg(not(feature = "with-gpl-data"))]
-    return runtime_rules();
-}
-
-#[cfg(feature = "with-gpl-data")]
-fn static_rules() -> FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>> {
-    super::ruleset::from_u8(tree_magic_db::magic()).unwrap_or_default()
-}
-
-#[cfg(not(feature = "with-gpl-data"))]
-fn runtime_rules() -> FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>> {
-    runtime::rules().unwrap_or_default()
-}
+    return runtime::rules().unwrap_or_default();
+});

src/fdo_magic/builtin/mod.rs

@@ -1,7 +1,7 @@
 //! Enable loading the magic database files at runtime rather than embedding the GPLed database
 
-use std::fs::File;
-use std::io::Read;
+use std::fs::{read, read_to_string};
+use std::path::PathBuf;
 
 use fnv::FnvHashMap;
 use once_cell::sync::OnceCell;
@@ -11,83 +11,48 @@ use super::MagicRule;
 use crate::fdo_magic::ruleset;
 use crate::Mime;
 
-static RUNTIME_RULES: OnceCell<Vec<Vec<u8>>> = OnceCell::new();
-static ALIAS_STRING: OnceCell<String> = OnceCell::new();
-static SUBCLASS_STRING: OnceCell<String> = OnceCell::new();
-
-/// Load the magic database from the predefined locations in the XDG standard
-fn load_xdg_shared_magic() -> Result<Vec<Vec<u8>>, String> {
-    const SEARCH_PATHS: &[&str; 3] = &[
-        "/usr/share/mime/magic",
-        "/usr/local/share/mime/magic",
-        "$HOME/.local/share/mime/magic",
+fn search_paths(filename: &str) -> Vec<PathBuf> {
+    let mut search_paths = vec![
+        PathBuf::from("/usr/share/mime").join(filename),
+        PathBuf::from("/usr/local/share/mime").join(filename),
     ];
-
-    let files: Vec<Vec<u8>> = SEARCH_PATHS
-        .iter()
-        .filter_map(|p| File::open(p).ok())
-        .map(|mut f| {
-            let mut buf = vec![];
-            f.read_to_end(&mut buf)
-                .map_err(|e| format!("Failed to read magic file bytes: {:#?}", e))?;
-            Ok(buf)
-        })
-        .collect::<Result<_, String>>()?;
-
-    if files.is_empty() {
-        Err("No MIME magic files found in the XDG default paths".to_string())
-    } else {
-        Ok(files)
+    if let Some(home) = home::home_dir() {
+        search_paths.push(home.join(".local/share/mime").join(filename));
     }
+    dbg!(search_paths)
 }
 
-/// Load a number of files at `paths` and concatenate them together with a newline
-fn load_concat_strings(paths: &[&str]) -> String {
-    let strings: Vec<String> = paths
+/// Load the magic database from the predefined locations in the XDG standard
+fn load_xdg_shared_magic() -> Vec<Vec<u8>> {
+    search_paths("magic")
         .iter()
-        .filter_map(|p| File::open(p).ok())
-        .map(|mut f| {
-            let mut s = String::new();
-            f.read_to_string(&mut s)
-                .expect("Failed to read aliases from file");
-            s
-        })
-        .collect();
-
-    strings.join("\n")
+        .map(read)
+        .filter_map(Result::ok)
+        .collect()
 }
 
-/// Load the magic aliases from the XDG standard locations and concatenate them together
-fn load_aliases() -> String {
-    const SEARCH_PATHS: &[&str; 3] = &[
-        "/usr/share/mime/aliases",
-        "/usr/local/share/mime/aliases",
-        "$HOME/.local/share/mime/aliases",
-    ];
-
-    load_concat_strings(SEARCH_PATHS)
-}
-
-/// Load the subclass definitions from the XDG standard locations and concatenate them together
-fn load_subclasses() -> String {
-    const SEARCH_PATHS: &[&str; 3] = &[
-        "/usr/share/mime/subclasses",
-        "/usr/local/share/mime/subclasses",
-        "$HOME/.local/share/mime/subclasses",
-    ];
-
-    load_concat_strings(SEARCH_PATHS)
+/// Load a number of files at `paths` and concatenate them together with a newline
+fn load_concat_strings(filename: &str) -> String {
+    search_paths(filename)
+        .iter()
+        .map(read_to_string)
+        .filter_map(Result::ok)
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
-pub(crate) fn aliases() -> &'static str {
-    ALIAS_STRING.get_or_init(load_aliases)
+pub fn aliases() -> &'static str {
+    static ALIAS_STRING: OnceCell<String> = OnceCell::new();
+    ALIAS_STRING.get_or_init(|| load_concat_strings("aliases"))
 }
 
-pub(crate) fn subclasses() -> &'static str {
-    SUBCLASS_STRING.get_or_init(load_subclasses)
+pub fn subclasses() -> &'static str {
+    static SUBCLASS_STRING: OnceCell<String> = OnceCell::new();
+    SUBCLASS_STRING.get_or_init(|| load_concat_strings("subclasses"))
 }
 
-pub(crate) fn rules() -> Result<FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>>, String> {
-    let files = RUNTIME_RULES.get_or_try_init(load_xdg_shared_magic)?;
+pub fn rules() -> Result<FnvHashMap<Mime, DiGraph<MagicRule<'static>, u32>>, String> {
+    static RUNTIME_RULES: OnceCell<Vec<Vec<u8>>> = OnceCell::new();
+    let files = RUNTIME_RULES.get_or_init(load_xdg_shared_magic);
     ruleset::from_multiple(files)
 }