Add kdl support for all toml related files.

Author: simi

Cargo.lock

@@ -28,6 +28,7 @@ env_logger = "0.11"
 semver = "1.0.26"
 which = "6.0"
 toml = "0.8"
+kdl = "6.0.0"
 serde = { version = "1.0", features = ["derive"] }
 
 [dev-dependencies]

crates/rb-cli/Cargo.toml

@@ -57,10 +57,13 @@ fn list_available_scripts(butler_runtime: ButlerRuntime, project_file: Option<Pa
             eprintln!();
             eprintln!("No project configuration detected in the current directory hierarchy.");
             eprintln!();
+            eprintln!("To define project scripts, create one of these files (in priority order):");
             eprintln!(
-                "To define project scripts, create an {} or {} file:",
-                "rbproject.toml".cyan(),
-                "gem.toml".cyan()
+                "  {} {} {} {}",
+                "gem.kdl".cyan(),
+                "gem.toml".cyan(),
+                "rbproject.kdl".cyan(),
+                "rbproject.toml".cyan()
             );
             eprintln!();
             eprintln!("  {}", "[scripts]".bright_black());
@@ -73,7 +76,7 @@ fn list_available_scripts(butler_runtime: ButlerRuntime, project_file: Option<Pa
             );
             eprintln!();
             eprintln!(
-                "Or specify a custom location: {} -P path/to/rbproject.toml run",
+                "Or specify a custom location: {} -P path/to/gem.kdl run",
                 "rb".green().bold()
             );
             std::process::exit(1);
@@ -238,9 +241,15 @@ pub fn run_command(
             eprintln!("No project configuration detected in the current directory hierarchy.");
             eprintln!();
             eprintln!(
-                "To use project scripts, please create an {} or {} file with script definitions:",
+                "To use project scripts, please create one of these files with script definitions:"
+            );
+            eprintln!(
+                "  {} {} {} {} {}",
                 "rbproject.toml".cyan(),
-                "gem.toml".cyan()
+                "rb.toml".cyan(),
+                "rb.kdl".cyan(),
+                "gem.toml".cyan(),
+                "gem.kdl".cyan()
             );
             eprintln!();
             eprintln!("  {}", "[scripts]".bright_black());
@@ -253,7 +262,7 @@ pub fn run_command(
             );
             eprintln!();
             eprintln!(
-                "Or specify a custom location with: {} -P path/to/rbproject.toml run {}",
+                "Or specify a custom location with: {} -P path/to/rb.toml run {}",
                 "rb".green().bold(),
                 script_name.cyan()
             );

crates/rb-cli/src/commands/run.rs

@@ -7,14 +7,24 @@ use std::path::PathBuf;
 /// Load configuration from file
 /// Returns default config if no file is found
 ///
+/// Supports both TOML and KDL formats (detected by file extension)
+///
 /// # Arguments
 /// * `override_path` - Optional path to explicitly load config from (for testing)
 pub fn load_config(override_path: Option<PathBuf>) -> Result<RbConfig, ConfigError> {
     if let Some(config_path) = locate_config_file(override_path.clone()) {
         info!("Loading configuration from: {}", config_path.display());
 
         let contents = fs::read_to_string(&config_path)?;
-        let config: RbConfig = toml::from_str(&contents)?;
+
+        // Determine format based on file extension
+        let config: RbConfig = if config_path.extension().and_then(|s| s.to_str()) == Some("kdl") {
+            debug!("Parsing configuration as KDL format");
+            parse_kdl_config(&contents)?
+        } else {
+            debug!("Parsing configuration as TOML format");
+            toml::from_str(&contents)?
+        };
 
         // Log what was loaded
         debug!("Configuration file contents parsed successfully");
@@ -39,6 +49,44 @@ pub fn load_config(override_path: Option<PathBuf>) -> Result<RbConfig, ConfigErr
     }
 }
 
+/// Parse KDL configuration into RbConfig
+fn parse_kdl_config(content: &str) -> Result<RbConfig, ConfigError> {
+    let doc: kdl::KdlDocument = content.parse().map_err(|e: kdl::KdlError| {
+        std::io::Error::new(
+            std::io::ErrorKind::InvalidData,
+            format!("Failed to parse KDL: {}", e),
+        )
+    })?;
+
+    let mut config = RbConfig::default();
+
+    // Parse rubies-dir
+    if let Some(node) = doc.get("rubies-dir")
+        && let Some(entry) = node.entries().first()
+        && let Some(value) = entry.value().as_string()
+    {
+        config.rubies_dir = Some(PathBuf::from(value));
+    }
+
+    // Parse ruby-version
+    if let Some(node) = doc.get("ruby-version")
+        && let Some(entry) = node.entries().first()
+        && let Some(value) = entry.value().as_string()
+    {
+        config.ruby_version = Some(value.to_string());
+    }
+
+    // Parse gem-home
+    if let Some(node) = doc.get("gem-home")
+        && let Some(entry) = node.entries().first()
+        && let Some(value) = entry.value().as_string()
+    {
+        config.gem_home = Some(PathBuf::from(value));
+    }
+
+    Ok(config)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -78,4 +126,32 @@ mod tests {
         // Cleanup
         let _ = fs::remove_file(&config_path);
     }
+
+    #[test]
+    fn test_load_kdl_config() {
+        use std::fs;
+
+        let temp_dir = std::env::temp_dir();
+        let config_path = temp_dir.join("test_rb_config.kdl");
+
+        // Create a test KDL config file
+        let kdl_content = r#"
+rubies-dir "/opt/rubies"
+ruby-version "3.3.0"
+gem-home "/opt/gems"
+"#;
+        fs::write(&config_path, kdl_content).expect("Failed to write KDL config");
+
+        // Load config from KDL path
+        let result = load_config(Some(config_path.clone()));
+        assert!(result.is_ok());
+
+        let config = result.unwrap();
+        assert_eq!(config.rubies_dir, Some(PathBuf::from("/opt/rubies")));
+        assert_eq!(config.ruby_version, Some("3.3.0".to_string()));
+        assert_eq!(config.gem_home, Some(PathBuf::from("/opt/gems")));
+
+        // Cleanup
+        let _ = fs::remove_file(&config_path);
+    }
 }

crates/rb-cli/src/config/loader.rs

@@ -3,13 +3,15 @@ use std::path::PathBuf;
 
 /// Locate the configuration file following XDG Base Directory specification
 ///
+/// Supports both rb.kdl and rb.toml (preferring .kdl)
+///
 /// Priority order:
 /// 1. Explicit override path (if provided)
 /// 2. $RB_CONFIG environment variable
-/// 3. $XDG_CONFIG_HOME/rb/rb.toml (Unix/Linux)
-/// 4. ~/.config/rb/rb.toml (Unix/Linux fallback)
-/// 5. %APPDATA%/rb/rb.toml (Windows)
-/// 6. ~/.rb.toml (cross-platform fallback)
+/// 3. $XDG_CONFIG_HOME/rb/rb.kdl or rb.toml (Unix/Linux)
+/// 4. ~/.config/rb/rb.kdl or rb.toml (Unix/Linux fallback)
+/// 5. %APPDATA%/rb/rb.kdl or rb.toml (Windows)
+/// 6. ~/.rb.kdl or ~/.rb.toml (cross-platform fallback)
 pub fn locate_config_file(override_path: Option<PathBuf>) -> Option<PathBuf> {
     debug!("Searching for configuration file...");
 
@@ -34,49 +36,58 @@ pub fn locate_config_file(override_path: Option<PathBuf>) -> Option<PathBuf> {
 
     // 3. Try XDG_CONFIG_HOME (Unix/Linux)
     if let Ok(xdg_config) = std::env::var("XDG_CONFIG_HOME") {
-        let config_path = PathBuf::from(xdg_config).join("rb").join("rb.toml");
-        debug!("  Checking XDG_CONFIG_HOME: {}", config_path.display());
-        if config_path.exists() {
-            debug!("  Found configuration file in XDG_CONFIG_HOME");
-            return Some(config_path);
+        let base_path = PathBuf::from(xdg_config).join("rb");
+        // Try .kdl first, then .toml
+        for ext in &["rb.kdl", "rb.toml"] {
+            let config_path = base_path.join(ext);
+            debug!("  Checking XDG_CONFIG_HOME: {}", config_path.display());
+            if config_path.exists() {
+                debug!("  Found configuration file in XDG_CONFIG_HOME");
+                return Some(config_path);
+            }
         }
     }
 
     // Try home directory based paths
     if let Some(home_dir) = home::home_dir() {
-        // Unix/Linux: ~/.config/rb/rb.toml
+        // Unix/Linux: ~/.config/rb/rb.kdl or rb.toml
         #[cfg(not(target_os = "windows"))]
         {
-            let config_path = home_dir.join(".config").join("rb").join("rb.toml");
-            debug!("  Checking ~/.config/rb/rb.toml: {}", config_path.display());
-            if config_path.exists() {
-                debug!("  Found configuration file in ~/.config/rb/");
-                return Some(config_path);
+            let base_path = home_dir.join(".config").join("rb");
+            for ext in &["rb.kdl", "rb.toml"] {
+                let config_path = base_path.join(ext);
+                debug!("  Checking ~/.config/rb/{}: {}", ext, config_path.display());
+                if config_path.exists() {
+                    debug!("  Found configuration file in ~/.config/rb/");
+                    return Some(config_path);
+                }
             }
         }
 
-        // Windows: %APPDATA%/rb/rb.toml
+        // Windows: %APPDATA%/rb/rb.kdl or rb.toml
         #[cfg(target_os = "windows")]
         {
             if let Ok(appdata) = std::env::var("APPDATA") {
-                let config_path = PathBuf::from(appdata).join("rb").join("rb.toml");
-                debug!("  Checking %APPDATA%/rb/rb.toml: {}", config_path.display());
-                if config_path.exists() {
-                    debug!("  Found configuration file in %APPDATA%/rb/");
-                    return Some(config_path);
+                let base_path = PathBuf::from(appdata).join("rb");
+                for ext in &["rb.kdl", "rb.toml"] {
+                    let config_path = base_path.join(ext);
+                    debug!("  Checking %APPDATA%/rb/{}: {}", ext, config_path.display());
+                    if config_path.exists() {
+                        debug!("  Found configuration file in %APPDATA%/rb/");
+                        return Some(config_path);
+                    }
                 }
             }
         }
 
-        // Cross-platform fallback: ~/.rb.toml
-        let fallback_path = home_dir.join(".rb.toml");
-        debug!(
-            "  Checking fallback ~/.rb.toml: {}",
-            fallback_path.display()
-        );
-        if fallback_path.exists() {
-            debug!("  Found configuration file at ~/.rb.toml");
-            return Some(fallback_path);
+        // Cross-platform fallback: ~/.rb.kdl or ~/.rb.toml
+        for ext in &[".rb.kdl", ".rb.toml"] {
+            let fallback_path = home_dir.join(ext);
+            debug!("  Checking fallback ~/{}: {}", ext, fallback_path.display());
+            if fallback_path.exists() {
+                debug!("  Found configuration file at ~/{}", ext);
+                return Some(fallback_path);
+            }
         }
     }
 

crates/rb-cli/src/config/locator.rs

@@ -18,7 +18,9 @@ log = "0.4"
 colored = "2.1.0"
 which = "6.0"
 toml = "0.8"
+kdl = "6.0"
 serde = { version = "1.0", features = ["derive"] }
+miette = { version = "7.0", features = ["fancy"] }
 
 [dev-dependencies]
 tempfile = "3.21.0"

crates/rb-core/Cargo.toml

@@ -7,9 +7,11 @@ pub struct RbprojectDetector;
 
 impl RbprojectDetector {
     /// Supported project file names in order of preference
-    const PROJECT_FILENAMES: &'static [&'static str] = &["rbproject.toml", "gem.toml"];
+    /// Priority: gem.kdl > gem.toml > rbproject.kdl > rbproject.toml
+    const PROJECT_FILENAMES: &'static [&'static str] =
+        &["gem.kdl", "gem.toml", "rbproject.kdl", "rbproject.toml"];
 
-    /// Discover a ProjectRuntime by searching for project config files (rbproject.toml or gem.toml)
+    /// Discover a ProjectRuntime by searching for project config files
     /// in the current directory and walking up the directory tree until one is found or we reach the root.
     pub fn discover(start_dir: &Path) -> std::io::Result<Option<ProjectRuntime>> {
         debug!(
@@ -286,7 +288,7 @@ test = "rspec"
     }
 
     #[test]
-    fn discover_prefers_rbproject_toml_over_gem_toml() -> io::Result<()> {
+    fn discover_prefers_gem_toml_over_rbproject_toml() -> io::Result<()> {
         let temp_dir = TempDir::new()?;
         let project_dir = temp_dir.path();
 
@@ -309,10 +311,58 @@ test = "rspec from gem.toml"
         assert!(result.is_some());
         let project_runtime = result.unwrap();
         assert_eq!(project_runtime.root, project_dir);
-        assert_eq!(project_runtime.config_filename, "rbproject.toml");
+        assert_eq!(project_runtime.config_filename, "gem.toml");
+        assert_eq!(
+            project_runtime.get_script_command("test"),
+            Some("rspec from gem.toml")
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn discover_respects_priority_order() -> io::Result<()> {
+        let temp_dir = TempDir::new()?;
+        let project_dir = temp_dir.path();
+
+        // Create all supported project files
+        create_rbproject_toml(
+            project_dir,
+            r#"[scripts]
+test = "from rbproject.toml"
+"#,
+        )?;
+
+        fs::write(
+            project_dir.join("rbproject.kdl"),
+            r#"scripts {
+    test "from rbproject.kdl"
+}"#,
+        )?;
+
+        fs::write(
+            project_dir.join("gem.toml"),
+            r#"[scripts]
+test = "from gem.toml"
+"#,
+        )?;
+
+        fs::write(
+            project_dir.join("gem.kdl"),
+            r#"scripts {
+    test "from gem.kdl"
+}"#,
+        )?;
+
+        let result = RbprojectDetector::discover(project_dir)?;
+
+        assert!(result.is_some());
+        let project_runtime = result.unwrap();
+        // Should pick gem.kdl (highest priority)
+        assert_eq!(project_runtime.config_filename, "gem.kdl");
         assert_eq!(
             project_runtime.get_script_command("test"),
-            Some("rspec from rbproject.toml")
+            Some("from gem.kdl")
         );
 
         Ok(())