ym 0.3.57

Yummy - A modern Java build tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use anyhow::Result;
use console::style;

use crate::config;

pub fn execute(all: bool, yes: bool) -> Result<()> {
    let (config_path, cfg) = config::load_or_find_config()?;
    let project = config::project_dir(&config_path);

    // Always clean out/ directory
    let out_dir = project.join(config::OUTPUT_DIR);
    if out_dir.exists() {
        std::fs::remove_dir_all(&out_dir)?;
        println!("  {} Removed {}", style("✓").green(), out_dir.display());
    }

    // In workspace root, also clean all modules' out/ directories
    if cfg.workspaces.is_some() {
        if let Ok(ws) = crate::workspace::graph::WorkspaceGraph::build(&project) {
            for name in ws.all_packages() {
                if let Some(pkg) = ws.get_package(&name) {
                    let pkg_out = pkg.path.join(config::OUTPUT_DIR);
                    if pkg_out.exists() {
                        let _ = std::fs::remove_dir_all(&pkg_out);
                        println!("  {} Removed {}", style("✓").green(), pkg_out.display());
                    }
                }
            }
        }
    }

    // Remove workspace build fingerprints and incremental compilation fingerprints
    let cache = config::cache_dir(&project);
    if cache.exists() {
        if let Ok(entries) = std::fs::read_dir(&cache) {
            for entry in entries.flatten() {
                let name = entry.file_name();
                let name_str = name.to_string_lossy();
                if name_str.starts_with("workspace-build-fingerprint-")
                    || name_str.starts_with("workspace-module-fps-")
                {
                    let _ = std::fs::remove_file(entry.path());
                }
            }
        }
        // Remove per-module incremental fingerprints (must be cleared when out/ is deleted,
        // otherwise incremental compiler sees stale fingerprints + empty out/classes
        // and incorrectly returns UpToDate without restoring from cache)
        let fp_dir = cache.join("fingerprints");
        if fp_dir.exists() {
            let _ = std::fs::remove_dir_all(&fp_dir);
        }
    }

    if all {
        // Confirm before deleting dependency cache
        if !yes {
            let maven_cache = config::maven_cache_dir(&project);
            if maven_cache.exists() {
                let size = dir_size(&maven_cache);
                let confirm = dialoguer::Confirm::new()
                    .with_prompt(format!(
                        "  Delete Maven dependency cache ({:.1} MB)?",
                        size as f64 / 1_048_576.0
                    ))
                    .default(false)
                    .interact()?;
                if !confirm {
                    println!("  {} Skipped cache deletion", style("!").yellow());
                    println!("  {} Clean complete", style("✓").green());
                    return Ok(());
                }
            }
        }

        // Remove .ym/cache/ (Maven dependency cache)
        let maven_cache = config::maven_cache_dir(&project);
        if maven_cache.exists() {
            let size = dir_size(&maven_cache);
            std::fs::remove_dir_all(&maven_cache)?;
            println!(
                "  {} Removed Maven cache ({:.1} MB)",
                style("✓").green(),
                size as f64 / 1_048_576.0
            );
        }

        // Remove resolved cache
        let resolved_path = config::cache_dir(&project).join(config::RESOLVED_FILE);
        if resolved_path.exists() {
            std::fs::remove_file(&resolved_path)?;
            println!("  {} Removed resolved cache", style("✓").green());
        }
    }

    println!("  {} Clean complete", style("✓").green());
    Ok(())
}

fn dir_size(path: &std::path::Path) -> u64 {
    walkdir::WalkDir::new(path)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().is_file())
        .filter_map(|e| e.metadata().ok())
        .map(|m| m.len())
        .sum()
}