rclean-cli 0.2.0

Find and safely clean rebuildable developer artifacts across local workspaces
mod sweep;

use std::fs;
use std::path::{Path, PathBuf};
use std::process::ExitCode;

use chrono::Utc;
use serde::{Deserialize, Serialize};

use crate::clean::SelectedCandidate;
use crate::cli::StampArgs;
use crate::error::RcleanError;
use crate::model::{Candidate, Safety, ScanReport};
use crate::{clean, scan};

const STAMP_FILE: &str = ".rclean-stamp";

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct StampCommandReport {
    stamped: usize,
    swept: usize,
    plan: Option<String>,
    warnings: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub(super) struct StampRecord {
    pub stamp_id: String,
    pub timestamp: String,
}

pub fn run(args: StampArgs) -> Result<ExitCode, RcleanError> {
    let roots = args.common.paths_or_current_dir();
    clean::check_broad_roots(&roots)?;

    let options = args.common.to_scan_options()?;
    let report = scan::scan(&roots, &options)?;

    if args.sweep {
        return sweep::run(args, report);
    }

    let mut warnings = Vec::new();
    let stamped = write_stamps(&report, &mut warnings)?;
    let command_report = StampCommandReport {
        stamped,
        swept: 0,
        plan: None,
        warnings,
    };
    print_stamp_report(&command_report, args.common.json)?;

    if stamped == 0 {
        Ok(ExitCode::from(3))
    } else {
        Ok(ExitCode::SUCCESS)
    }
}

fn write_stamps(report: &ScanReport, warnings: &mut Vec<String>) -> Result<usize, RcleanError> {
    let mut stamped = 0;
    for candidate in stampable_candidates(report) {
        let path = PathBuf::from(&candidate.path);
        match write_stamp(&path) {
            Ok(()) => stamped += 1,
            Err(err) => warnings.push(format!("skipped {}: {err}", path.display())),
        }
    }
    Ok(stamped)
}

fn write_stamp(path: &Path) -> Result<(), String> {
    let metadata = fs::symlink_metadata(path)
        .map_err(|err| format!("cannot read candidate metadata: {err}"))?;
    if metadata.file_type().is_symlink() {
        return Err("candidate is a symlink".to_string());
    }
    if !metadata.is_dir() {
        return Err("candidate is not a directory".to_string());
    }

    let record = StampRecord {
        stamp_id: new_stamp_id(),
        timestamp: Utc::now().to_rfc3339(),
    };
    let json = serde_json::to_vec_pretty(&record).map_err(|err| err.to_string())?;
    fs::write(path.join(STAMP_FILE), json).map_err(|err| format!("cannot write stamp: {err}"))
}

pub(super) fn stampable_candidates(report: &ScanReport) -> impl Iterator<Item = &Candidate> {
    report
        .projects
        .iter()
        .flat_map(|project| project.candidates.iter())
        .filter(|candidate| {
            matches!(candidate.safety, Safety::Safe | Safety::Caution) && !candidate.requires_sudo
        })
}

pub(super) fn to_selected(candidate: &Candidate) -> SelectedCandidate {
    SelectedCandidate {
        id: None,
        path: PathBuf::from(&candidate.path),
        bytes: candidate.bytes,
        rule_id: candidate.rule_id.clone(),
        category: candidate.category,
        safety: candidate.safety,
        requires_sudo: candidate.requires_sudo,
        risk_score: candidate.risk_score,
    }
}

pub(super) fn stamp_path(candidate_path: &Path) -> PathBuf {
    candidate_path.join(STAMP_FILE)
}

fn print_stamp_report(report: &StampCommandReport, json: bool) -> Result<(), RcleanError> {
    if json {
        let json = serde_json::to_string_pretty(report)?;
        println!("{json}");
    } else {
        println!("Stamped: {}", report.stamped);
        if report.swept > 0 {
            println!("Sweep candidates: {}", report.swept);
        }
        if let Some(plan) = &report.plan {
            eprintln!("wrote action plan: {plan}");
        }
        for warning in &report.warnings {
            eprintln!("warning: {warning}");
        }
    }
    Ok(())
}

fn new_stamp_id() -> String {
    let now = Utc::now();
    format!("stamp-{}-{}", now.timestamp_millis(), std::process::id())
}