feat(config): config files are now kdl-based

Fixes: #153

crates/oro-config/Cargo.toml

@@ -12,7 +12,8 @@ rust-version = "1.67.1"
 
 [dependencies]
 clap = { workspace = true, features = ["string"] }
-config = { workspace = true, features = ["toml"] }
+config = { workspace = true, default-features = false }
+kdl = { workspace = true }
 miette = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

crates/oro-config/src/error.rs

@@ -0,0 +1,13 @@
+use miette::Diagnostic;
+use thiserror::Error;
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum OroConfigError {
+    #[error(transparent)]
+    #[diagnostic(code(config::error))]
+    ConfigError(#[from] config::ConfigError),
+
+    #[error(transparent)]
+    #[diagnostic(code(config::error))]
+    ConfigParseError(#[from] Box<dyn std::error::Error + Send + Sync>),
+}

crates/oro-config/src/kdl_source.rs

@@ -0,0 +1,63 @@
+use config::{ConfigError, FileStoredFormat, Format, Map, Source, Value, ValueKind};
+use kdl::{KdlDocument, KdlValue};
+
+#[derive(Clone, Debug)]
+pub(crate) struct KdlSource(KdlDocument);
+
+impl Source for KdlSource {
+    fn clone_into_box(&self) -> Box<dyn Source + Send + Sync> {
+        Box::new(self.clone())
+    }
+
+    fn collect(&self) -> Result<Map<String, Value>, ConfigError> {
+        let mut map = Map::new();
+        for node in self.0.nodes() {
+            let key = node.name().to_string();
+            if let Some(value) = node.get(0) {
+                let value = Value::new(
+                    Some(&if let Some(str) = value.as_string() {
+                        str.to_owned()
+                    } else {
+                        value.to_string()
+                    }),
+                    value_kind(value),
+                );
+                map.insert(key, value);
+            }
+        }
+        Ok(map)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct KdlFormat;
+
+impl Format for KdlFormat {
+    fn parse(
+        &self,
+        _uri: Option<&String>,
+        text: &str,
+    ) -> Result<Map<String, Value>, Box<dyn std::error::Error + Send + Sync>> {
+        Ok(KdlSource(text.parse()?).collect()?)
+    }
+}
+
+impl FileStoredFormat for KdlFormat {
+    fn file_extensions(&self) -> &'static [&'static str] {
+        &["kdl"]
+    }
+}
+
+fn value_kind(value: &KdlValue) -> ValueKind {
+    if let Some(str) = value.as_string() {
+        ValueKind::String(str.into())
+    } else if let Some(num) = value.as_i64() {
+        ValueKind::I64(num)
+    } else if let Some(float) = value.as_f64() {
+        ValueKind::Float(float)
+    } else if let Some(boolean) = value.as_bool() {
+        ValueKind::Boolean(boolean)
+    } else {
+        ValueKind::Nil
+    }
+}

crates/oro-config/src/lib.rs

@@ -2,14 +2,20 @@
 
 use std::{
     collections::{HashMap, HashSet},
-    path::PathBuf, ffi::OsString,
+    ffi::OsString,
+    path::PathBuf,
 };
 
 pub use clap::{ArgMatches, Command};
 pub use config::Config as OroConfig;
-use config::{builder::DefaultState, ConfigBuilder, ConfigError, Environment, File};
-use miette::{Diagnostic, Result};
-use thiserror::Error;
+use config::{builder::DefaultState, ConfigBuilder, Environment, File};
+use kdl_source::KdlFormat;
+use miette::Result;
+
+use error::OroConfigError;
+
+mod error;
+mod kdl_source;
 
 pub trait OroConfigLayerExt {
     fn with_negations(self) -> Self;
@@ -70,17 +76,6 @@ impl OroConfigLayerExt for Command {
     }
 }
 
-#[derive(Debug, Error, Diagnostic)]
-pub enum OroConfigError {
-    #[error(transparent)]
-    #[diagnostic(code(config::error))]
-    ConfigError(#[from] ConfigError),
-
-    #[error(transparent)]
-    #[diagnostic(code(config::error))]
-    ConfigParseError(#[from] Box<dyn std::error::Error + Send + Sync>),
-}
-
 #[derive(Debug, Clone)]
 pub struct OroConfigOptions {
     builder: ConfigBuilder<DefaultState>,
@@ -137,27 +132,16 @@ impl OroConfigOptions {
         if self.global {
             if let Some(config_file) = self.global_config_file {
                 let path = config_file.display().to_string();
-                builder = builder.add_source(File::with_name(&path[..]).required(false));
+                builder = builder.add_source(File::new(&path, KdlFormat).required(false));
             }
         }
         if self.env {
             builder = builder.add_source(Environment::with_prefix("oro_config"));
         }
         if let Some(root) = self.pkg_root {
-            builder = builder
-                .add_source(
-                    File::with_name(&root.join("ororc").display().to_string()).required(false),
-                )
-                .add_source(
-                    File::with_name(&root.join(".ororc").display().to_string()).required(false),
-                )
-                .add_source(
-                    File::with_name(&root.join("ororc.toml").display().to_string()).required(false),
-                )
-                .add_source(
-                    File::with_name(&root.join(".ororc.toml").display().to_string())
-                        .required(false),
-                );
+            builder = builder.add_source(
+                File::new(&root.join("oro.kdl").display().to_string(), KdlFormat).required(false),
+            );
         }
         Ok(builder.build().map_err(OroConfigError::ConfigError)?)
     }

src/lib.rs

@@ -269,7 +269,7 @@ impl Orogene {
             cfg_builder.global_config_file(Some(file.clone())).load()?
         } else {
             cfg_builder
-                .global_config_file(dirs.map(|d| d.config_dir().to_owned().join("ororc.toml")))
+                .global_config_file(dirs.map(|d| d.config_dir().to_owned().join("oro.kdl")))
                 .pkg_root(Some(self.root.clone()))
                 .load()?
         };