diskforge_core/

detector.rs

use std::path::Path;

use crate::types::ProjectType;

/// Marker file → project type mapping
const MARKERS: &[(&str, ProjectType)] = &[
    ("Cargo.toml", ProjectType::Rust),
    ("pubspec.yaml", ProjectType::Flutter),
    ("build.gradle", ProjectType::Gradle),
    ("build.gradle.kts", ProjectType::Gradle),
    ("pom.xml", ProjectType::Maven),
    ("Package.swift", ProjectType::Swift),
    ("CMakeLists.txt", ProjectType::CMake),
    ("build.zig", ProjectType::Zig),
    ("turbo.json", ProjectType::Turborepo),
];

/// Markers that need disambiguation (package.json can be Node, Next.js, or React Native)
const PACKAGE_JSON_MARKERS: &[(&str, ProjectType)] = &[
    ("next.config.js", ProjectType::NextJs),
    ("next.config.mjs", ProjectType::NextJs),
    ("next.config.ts", ProjectType::NextJs),
];

/// Detect project type from a directory by checking for marker files
pub fn detect_project_type(dir: &Path) -> Option<ProjectType> {
    let entries: Vec<String> = std::fs::read_dir(dir)
        .ok()?
        .filter_map(|e| e.ok())
        .filter_map(|e| e.file_name().into_string().ok())
        .collect();

    // Check specific markers first (higher priority)
    for (marker, project_type) in MARKERS {
        if entries.iter().any(|e| e == *marker) {
            return Some(project_type.clone());
        }
    }

    // Check for .csproj/.fsproj files (.NET)
    if entries
        .iter()
        .any(|e| e.ends_with(".csproj") || e.ends_with(".fsproj"))
    {
        return Some(ProjectType::DotNet);
    }

    // Check for Python projects
    if entries.iter().any(|e| {
        e == "pyproject.toml" || e == "setup.py" || e == "requirements.txt" || e == "Pipfile"
    }) {
        return Some(ProjectType::Python);
    }

    // Check for Go modules
    if entries.iter().any(|e| e == "go.mod") {
        return Some(ProjectType::Go);
    }

    // Disambiguate package.json projects
    if entries.iter().any(|e| e == "package.json") {
        // Check for Next.js
        for (marker, project_type) in PACKAGE_JSON_MARKERS {
            if entries.iter().any(|e| e == *marker) {
                return Some(project_type.clone());
            }
        }

        // Check for React Native
        if entries.iter().any(|e| e == "ios" || e == "android") {
            let has_ios_dir = dir.join("ios").is_dir();
            let has_android_dir = dir.join("android").is_dir();
            if has_ios_dir || has_android_dir {
                return Some(ProjectType::ReactNative);
            }
        }

        // Check for Podfile (CocoaPods, often inside ios/)
        if entries.iter().any(|e| e == "Podfile") {
            return Some(ProjectType::CocoaPods);
        }

        return Some(ProjectType::Node);
    }

    None
}

/// Get the artifact directories for a project type
pub fn artifact_dirs(project_type: &ProjectType) -> &'static [&'static str] {
    match project_type {
        ProjectType::Rust => &["target"],
        ProjectType::Node => &["node_modules", ".angular"],
        ProjectType::Flutter => &[".dart_tool", "build"],
        ProjectType::Gradle => &["build", ".gradle"],
        ProjectType::Maven => &["target"],
        ProjectType::Swift => &[".build"],
        ProjectType::CMake => &["build"],
        ProjectType::DotNet => &["bin", "obj"],
        ProjectType::Python => &[
            "__pycache__",
            ".venv",
            "venv",
            ".mypy_cache",
            ".pytest_cache",
            ".ruff_cache",
            ".tox",
        ],
        ProjectType::Go => &[],
        ProjectType::Zig => &["zig-cache", "zig-out"],
        ProjectType::Turborepo => &[".turbo"],
        ProjectType::NextJs => &["node_modules", ".next"],
        ProjectType::CocoaPods => &["Pods"],
        ProjectType::ReactNative => &["node_modules", "ios/Pods", "android/build", ".expo"],
    }
}

/// Get the rebuild command hint for a project type
pub fn rebuild_hint(project_type: &ProjectType) -> &'static str {
    match project_type {
        ProjectType::Rust => "cargo build",
        ProjectType::Node => "npm install",
        ProjectType::Flutter => "flutter pub get",
        ProjectType::Gradle => "gradle build",
        ProjectType::Maven => "mvn install",
        ProjectType::Swift => "swift build",
        ProjectType::CMake => "cmake --build .",
        ProjectType::DotNet => "dotnet restore",
        ProjectType::Python => "pip install -r requirements.txt",
        ProjectType::Go => "go mod download",
        ProjectType::Zig => "zig build",
        ProjectType::Turborepo => "turbo run build",
        ProjectType::NextJs => "npm install && npm run build",
        ProjectType::CocoaPods => "pod install",
        ProjectType::ReactNative => "npm install && cd ios && pod install",
    }
}

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

    fn temp_project(name: &str, markers: &[&str]) -> std::path::PathBuf {
        let dir = std::env::temp_dir().join(format!("diskforge_test_{name}"));
        let _ = fs::remove_dir_all(&dir);
        fs::create_dir_all(&dir).unwrap();
        for marker in markers {
            fs::write(dir.join(marker), "").unwrap();
        }
        dir
    }

    fn cleanup(dir: &std::path::Path) {
        let _ = fs::remove_dir_all(dir);
    }

    #[test]
    fn detect_rust() {
        let dir = temp_project("rust", &["Cargo.toml"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Rust));
        cleanup(&dir);
    }

    #[test]
    fn detect_flutter() {
        let dir = temp_project("flutter", &["pubspec.yaml"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Flutter));
        cleanup(&dir);
    }

    #[test]
    fn detect_gradle() {
        let dir = temp_project("gradle", &["build.gradle"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Gradle));
        cleanup(&dir);
    }

    #[test]
    fn detect_node() {
        let dir = temp_project("node", &["package.json"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Node));
        cleanup(&dir);
    }

    #[test]
    fn detect_nextjs() {
        let dir = temp_project("nextjs", &["package.json", "next.config.js"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::NextJs));
        cleanup(&dir);
    }

    #[test]
    fn detect_python() {
        let dir = temp_project("python", &["pyproject.toml"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Python));
        cleanup(&dir);
    }

    #[test]
    fn detect_go() {
        let dir = temp_project("go", &["go.mod"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::Go));
        cleanup(&dir);
    }

    #[test]
    fn detect_dotnet() {
        let dir = temp_project("dotnet", &["MyApp.csproj"]);
        assert_eq!(detect_project_type(&dir), Some(ProjectType::DotNet));
        cleanup(&dir);
    }

    #[test]
    fn detect_empty_dir() {
        let dir = temp_project("empty", &[]);
        assert_eq!(detect_project_type(&dir), None);
        cleanup(&dir);
    }

    #[test]
    fn artifact_dirs_and_hints_for_all_types() {
        let all = [
            ProjectType::Rust,
            ProjectType::Node,
            ProjectType::Flutter,
            ProjectType::Gradle,
            ProjectType::Maven,
            ProjectType::Swift,
            ProjectType::CMake,
            ProjectType::DotNet,
            ProjectType::Python,
            ProjectType::Go,
            ProjectType::Zig,
            ProjectType::Turborepo,
            ProjectType::NextJs,
            ProjectType::CocoaPods,
            ProjectType::ReactNative,
        ];
        for pt in &all {
            let dirs = artifact_dirs(pt);
            let hint = rebuild_hint(pt);
            assert!(!hint.is_empty(), "{pt:?} has empty rebuild hint");
            let _ = dirs;
        }
    }
}