refactor(file): Minor clean up to file discovery (#688)

Author: epage

src/file/format/mod.rs

@@ -1,6 +1,4 @@
-use std::collections::HashMap;
 use std::error::Error;
-use std::sync::OnceLock;
 
 use crate::map::Map;
 use crate::{file::FileStoredFormat, value::Value, Format};
@@ -54,41 +52,54 @@ pub enum FileFormat {
     Json5,
 }
 
-pub(crate) fn all_extensions() -> &'static HashMap<FileFormat, Vec<&'static str>> {
-    #![allow(unused_mut)] // If no features are used, there is an "unused mut" warning in `all_extensions`
-
-    static ALL_EXTENSIONS: OnceLock<HashMap<FileFormat, Vec<&'static str>>> = OnceLock::new();
-    ALL_EXTENSIONS.get_or_init(|| {
-        let mut formats: HashMap<FileFormat, Vec<_>> = HashMap::new();
-
-        #[cfg(feature = "toml")]
-        formats.insert(FileFormat::Toml, vec!["toml"]);
+impl FileFormat {
+    pub(crate) fn all() -> &'static [FileFormat] {
+        &[
+            #[cfg(feature = "toml")]
+            FileFormat::Toml,
+            #[cfg(feature = "json")]
+            FileFormat::Json,
+            #[cfg(feature = "yaml")]
+            FileFormat::Yaml,
+            #[cfg(feature = "ini")]
+            FileFormat::Ini,
+            #[cfg(feature = "ron")]
+            FileFormat::Ron,
+            #[cfg(feature = "json5")]
+            FileFormat::Json5,
+        ]
+    }
 
-        #[cfg(feature = "json")]
-        formats.insert(FileFormat::Json, vec!["json"]);
+    pub(crate) fn extensions(&self) -> &'static [&'static str] {
+        match self {
+            #[cfg(feature = "toml")]
+            FileFormat::Toml => &["toml"],
 
-        #[cfg(feature = "yaml")]
-        formats.insert(FileFormat::Yaml, vec!["yaml", "yml"]);
+            #[cfg(feature = "json")]
+            FileFormat::Json => &["json"],
 
-        #[cfg(feature = "ini")]
-        formats.insert(FileFormat::Ini, vec!["ini"]);
+            #[cfg(feature = "yaml")]
+            FileFormat::Yaml => &["yaml", "yml"],
 
-        #[cfg(feature = "ron")]
-        formats.insert(FileFormat::Ron, vec!["ron"]);
+            #[cfg(feature = "ini")]
+            FileFormat::Ini => &["ini"],
 
-        #[cfg(feature = "json5")]
-        formats.insert(FileFormat::Json5, vec!["json5"]);
+            #[cfg(feature = "ron")]
+            FileFormat::Ron => &["ron"],
 
-        formats
-    })
-}
+            #[cfg(feature = "json5")]
+            FileFormat::Json5 => &["json5"],
 
-impl FileFormat {
-    pub(crate) fn extensions(&self) -> &'static [&'static str] {
-        // It should not be possible for this to fail
-        // A FileFormat would need to be declared without being added to the
-        // all_extensions map.
-        all_extensions().get(self).unwrap()
+            #[cfg(all(
+                not(feature = "toml"),
+                not(feature = "json"),
+                not(feature = "yaml"),
+                not(feature = "ini"),
+                not(feature = "ron"),
+                not(feature = "json5"),
+            ))]
+            _ => unreachable!("No features are enabled, this library won't work without features"),
+        }
     }
 
     pub(crate) fn parse(

src/file/source/file.rs

@@ -4,9 +4,7 @@ use std::fs;
 use std::io;
 use std::path::PathBuf;
 
-use crate::file::{
-    format::all_extensions, source::FileSourceResult, FileSource, FileStoredFormat, Format,
-};
+use crate::file::{source::FileSourceResult, FileFormat, FileSource, FileStoredFormat, Format};
 
 /// Describes a file sourced from a file
 #[derive(Clone, Debug)]
@@ -27,70 +25,61 @@ impl FileSourceFile {
     where
         F: FileStoredFormat + Format + 'static,
     {
-        let filename = if self.name.is_absolute() {
+        let path = if self.name.is_absolute() {
             self.name.clone()
         } else {
             env::current_dir()?.as_path().join(&self.name)
         };
 
         // First check for an _exact_ match
-        if filename.is_file() {
-            return if let Some(format) = format_hint {
-                Ok((filename, Box::new(format)))
+        if path.is_file() {
+            if let Some(format) = format_hint {
+                return Ok((path, Box::new(format)));
             } else {
-                for (format, extensions) in all_extensions().iter() {
-                    if extensions.contains(
-                        &filename
-                            .extension()
-                            .unwrap_or_default()
-                            .to_string_lossy()
-                            .as_ref(),
-                    ) {
-                        return Ok((filename, Box::new(*format)));
+                let ext = path.extension().unwrap_or_default().to_string_lossy();
+                for format in FileFormat::all() {
+                    if format.extensions().contains(&ext.as_ref()) {
+                        return Ok((path, Box::new(*format)));
                     }
                 }
-
-                Err(Box::new(io::Error::new(
+                return Err(Box::new(io::Error::new(
                     io::ErrorKind::NotFound,
                     format!(
-                        "configuration file \"{}\" is not of a registered file format",
-                        filename.to_string_lossy()
+                        "configuration file \"{}\" is not of a supported file format",
+                        path.to_string_lossy()
                     ),
-                )))
+                )));
             };
         }
 
-        let mut filename = filename;
+        let mut path = path;
         // Preserve any extension-like text within the provided file stem by appending a fake extension
         // which will be replaced by `set_extension()` calls (e.g.  `file.local.placeholder` => `file.local.json`)
-        if filename.extension().is_some() {
-            filename.as_mut_os_string().push(".placeholder");
+        if path.extension().is_some() {
+            path.as_mut_os_string().push(".placeholder");
         }
-
         match format_hint {
             Some(format) => {
                 for ext in format.file_extensions() {
-                    filename.set_extension(ext);
+                    path.set_extension(ext);
 
-                    if filename.is_file() {
-                        return Ok((filename, Box::new(format)));
+                    if path.is_file() {
+                        return Ok((path, Box::new(format)));
                     }
                 }
             }
-
             None => {
-                for format in all_extensions().keys() {
+                for format in FileFormat::all() {
                     for ext in format.extensions() {
-                        filename.set_extension(ext);
+                        path.set_extension(ext);
 
-                        if filename.is_file() {
-                            return Ok((filename, Box::new(*format)));
+                        if path.is_file() {
+                            return Ok((path, Box::new(*format)));
                         }
                     }
                 }
             }
         }
-
         Err(Box::new(io::Error::new(
             io::ErrorKind::NotFound,
             format!(