diskforge_core/rules/

user_rules.rs

use std::path::PathBuf;

use serde::Deserialize;

use crate::sizing;
use crate::types::{Category, CleanableItem, Risk};

/// A single user-defined rule from `~/.config/diskforge/rules.toml`
#[derive(Debug, Deserialize)]
pub struct UserRule {
    pub name: String,
    pub path: String,
    #[serde(default)]
    pub category: String,
    #[serde(default = "default_risk")]
    pub risk: String,
    #[serde(default)]
    pub regenerates: bool,
    pub hint: Option<String>,
}

fn default_risk() -> String {
    "low".into()
}

#[derive(Debug, Deserialize)]
struct RulesFile {
    #[serde(default)]
    rules: Vec<UserRule>,
}

/// Load user rules from `~/.config/diskforge/rules.toml`.
/// Returns an empty vec if the file doesn't exist or can't be parsed.
pub fn load_user_rules(home: &str) -> Vec<UserRule> {
    let path = PathBuf::from(format!("{home}/.config/diskforge/rules.toml"));
    if !path.exists() {
        return Vec::new();
    }
    let content = match std::fs::read_to_string(&path) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("diskforge: warning: could not read rules.toml: {e}");
            return Vec::new();
        }
    };
    match toml::from_str::<RulesFile>(&content) {
        Ok(f) => f.rules,
        Err(e) => {
            eprintln!("diskforge: warning: could not parse rules.toml: {e}");
            Vec::new()
        }
    }
}

/// Convert loaded user rules into `CleanableItem`s (skipping paths that don't exist).
pub fn scan_user_rules(home: &str) -> Vec<CleanableItem> {
    load_user_rules(home)
        .into_iter()
        .filter_map(|rule| {
            let expanded = rule.path.replace('~', home);
            let path = PathBuf::from(&expanded);
            if !path.exists() {
                return None;
            }
            let stats = sizing::dir_stats(&path);
            if stats.size == 0 {
                return None;
            }
            let risk = parse_risk(&rule.risk);
            let category = parse_category(&rule.category, &rule.name);
            Some(CleanableItem {
                category,
                path,
                size: stats.size,
                risk,
                regenerates: rule.regenerates,
                regeneration_hint: rule.hint,
                last_modified: stats.last_modified,
                description: format!("{} (user rule)", rule.name),
                cleanup_command: None,
            })
        })
        .collect()
}

fn parse_risk(s: &str) -> Risk {
    match s.to_lowercase().as_str() {
        "none" => Risk::None,
        "low" => Risk::Low,
        "medium" => Risk::Medium,
        "high" => Risk::High,
        _ => Risk::Low,
    }
}

fn parse_category(category: &str, name: &str) -> Category {
    match category.to_lowercase().as_str() {
        "system" | "system cache" => Category::SystemCache,
        "docker" => Category::Docker,
        "simulator" | "ios" => Category::Simulator,
        "android" => Category::Android,
        "ide" => Category::IdeCache(name.into()),
        "browser" => Category::BrowserCache(name.into()),
        "pkg" | "package" | "packagemanager" => Category::PackageManager(name.into()),
        _ => Category::AppCache(name.into()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn risk_parsing() {
        assert_eq!(parse_risk("none"), Risk::None);
        assert_eq!(parse_risk("None"), Risk::None);
        assert_eq!(parse_risk("NONE"), Risk::None);
        assert_eq!(parse_risk("low"), Risk::Low);
        assert_eq!(parse_risk("medium"), Risk::Medium);
        assert_eq!(parse_risk("high"), Risk::High);
        assert_eq!(parse_risk("banana"), Risk::Low); // default
    }

    #[test]
    fn category_parsing() {
        assert_eq!(
            parse_category("ide", "VS Code"),
            Category::IdeCache("VS Code".into())
        );
        assert_eq!(
            parse_category("IDE", "Cursor"),
            Category::IdeCache("Cursor".into())
        );
        assert_eq!(parse_category("docker", "Docker"), Category::Docker);
        assert_eq!(parse_category("simulator", "Sim"), Category::Simulator);
        assert_eq!(parse_category("ios", "Sim"), Category::Simulator);
        assert_eq!(parse_category("android", "NDK"), Category::Android);
        assert_eq!(
            parse_category("browser", "Chrome"),
            Category::BrowserCache("Chrome".into())
        );
        assert_eq!(parse_category("system", "Logs"), Category::SystemCache);
        assert_eq!(
            parse_category("pkg", "npm"),
            Category::PackageManager("npm".into())
        );
        assert_eq!(
            parse_category("package", "pip"),
            Category::PackageManager("pip".into())
        );
        assert_eq!(
            parse_category("whatever", "Foo"),
            Category::AppCache("Foo".into())
        );
    }

    #[test]
    fn load_valid_toml() {
        let dir = std::env::temp_dir().join("diskforge_test_rules");
        let config_dir = dir.join(".config/diskforge");
        std::fs::create_dir_all(&config_dir).unwrap();
        std::fs::write(
            config_dir.join("rules.toml"),
            r#"
[[rules]]
name = "Test Cache"
path = "~/some/path"
category = "ide"
risk = "none"
regenerates = true
hint = "rebuild it"

[[rules]]
name = "Another"
path = "~/other"
"#,
        )
        .unwrap();
        let rules = load_user_rules(&dir.to_string_lossy());
        assert_eq!(rules.len(), 2);
        assert_eq!(rules[0].name, "Test Cache");
        assert_eq!(rules[0].risk, "none");
        assert!(rules[0].regenerates);
        assert_eq!(rules[0].hint.as_deref(), Some("rebuild it"));
        // Second rule uses defaults
        assert_eq!(rules[1].name, "Another");
        assert_eq!(rules[1].risk, "low"); // default
        assert!(!rules[1].regenerates); // default false
        std::fs::remove_dir_all(&dir).ok();
    }

    #[test]
    fn load_missing_file() {
        let rules = load_user_rules("/tmp/diskforge_nonexistent_xyz");
        assert!(rules.is_empty());
    }

    #[test]
    fn load_malformed_toml() {
        let dir = std::env::temp_dir().join("diskforge_test_bad_toml");
        let config_dir = dir.join(".config/diskforge");
        std::fs::create_dir_all(&config_dir).unwrap();
        std::fs::write(config_dir.join("rules.toml"), "this is not valid toml [[[").unwrap();
        let rules = load_user_rules(&dir.to_string_lossy());
        assert!(rules.is_empty());
        std::fs::remove_dir_all(&dir).ok();
    }
}