rclean-cli 0.2.0

Find and safely clean rebuildable developer artifacts across local workspaces
use std::fs;
use std::path::Path;
use std::process::ExitCode;
use std::time::SystemTime;

use chrono::{DateTime, Utc};
use walkdir::WalkDir;

use crate::cli::StampArgs;
use crate::error::RcleanError;
use crate::model::{Candidate, ScanReport};
use crate::plan;

use super::{
    StampCommandReport, StampRecord, print_stamp_report, stamp_path, stampable_candidates,
    to_selected,
};

pub(super) fn run(args: StampArgs, report: ScanReport) -> Result<ExitCode, RcleanError> {
    let Some(plan_path) = args.common.write_plan.as_deref() else {
        return Err(RcleanError::from(
            "stamp --sweep requires --write-plan <path>".to_string(),
        ));
    };

    let mut warnings = Vec::new();
    let selected = select_unchanged_stamped_candidates(&report, &mut warnings);
    plan::write_selected_action_plan(&report, plan_path, &selected, "trash")?;

    let command_report = StampCommandReport {
        stamped: 0,
        swept: selected.len(),
        plan: Some(plan_path.display().to_string()),
        warnings,
    };
    print_stamp_report(&command_report, args.common.json)?;

    if selected.is_empty() {
        Ok(ExitCode::from(3))
    } else {
        Ok(ExitCode::SUCCESS)
    }
}

fn select_unchanged_stamped_candidates(
    report: &ScanReport,
    warnings: &mut Vec<String>,
) -> Vec<crate::clean::SelectedCandidate> {
    stampable_candidates(report)
        .filter_map(
            |candidate| match candidate_is_unchanged_since_stamp(candidate, warnings) {
                Some(true) => Some(to_selected(candidate)),
                Some(false) | None => None,
            },
        )
        .collect()
}

fn candidate_is_unchanged_since_stamp(
    candidate: &Candidate,
    warnings: &mut Vec<String>,
) -> Option<bool> {
    let candidate_path = Path::new(&candidate.path);
    let stamp_path = stamp_path(candidate_path);
    if !stamp_path.exists() {
        return None;
    }

    let record = match read_stamp(&stamp_path) {
        Ok(record) => record,
        Err(err) => {
            warnings.push(format!("skipped {}: {err}", candidate.path));
            return None;
        }
    };
    let stamp_time = match DateTime::parse_from_rfc3339(&record.timestamp) {
        Ok(timestamp) => SystemTime::from(timestamp.with_timezone(&Utc)),
        Err(err) => {
            warnings.push(format!(
                "skipped {}: invalid stamp timestamp: {err}",
                candidate.path
            ));
            return None;
        }
    };

    match latest_modified_excluding_stamp(candidate_path, &stamp_path) {
        Ok(Some(modified)) => Some(modified <= stamp_time),
        Ok(None) => Some(true),
        Err(err) => {
            warnings.push(format!("skipped {}: {err}", candidate.path));
            None
        }
    }
}

fn read_stamp(path: &Path) -> Result<StampRecord, String> {
    let raw = fs::read_to_string(path).map_err(|err| format!("cannot read stamp: {err}"))?;
    serde_json::from_str(&raw).map_err(|err| format!("invalid stamp json: {err}"))
}

fn latest_modified_excluding_stamp(
    candidate_path: &Path,
    stamp_path: &Path,
) -> Result<Option<SystemTime>, String> {
    let mut latest = None;
    for entry in WalkDir::new(candidate_path).follow_links(false) {
        let entry = entry.map_err(|err| format!("cannot walk candidate: {err}"))?;
        let path = entry.path();
        if path == candidate_path || path == stamp_path {
            continue;
        }
        let metadata = fs::symlink_metadata(path)
            .map_err(|err| format!("cannot read metadata for {}: {err}", path.display()))?;
        let modified = metadata
            .modified()
            .map_err(|err| format!("cannot read mtime for {}: {err}", path.display()))?;
        latest = Some(latest.map_or(modified, |current: SystemTime| current.max(modified)));
    }
    Ok(latest)
}