crate_seq_core/

check.rs

//! `check_crate`: diff local ledger state against the live crates.io registry.

#[cfg(test)]
#[path = "check_tests.rs"]
mod tests;

use std::path::{Path, PathBuf};

use crate_seq_ledger::{detect_tag_pattern, load, LedgerEntry, LedgerStatus, VersionSource};
use crate_seq_registry::CratesIoClient;

use crate::Error;

/// Orphaned entry: a `Pending` ledger entry whose backing ref is absent.
///
/// For `GitTag` entries the tag does not exist in git. For `Snapshot` entries
/// no tarball with the recorded SHA-256 exists in the snapshot store.
#[derive(Debug, Clone)]
pub struct OrphanedEntry {
    /// Version of the orphaned entry.
    pub version: semver::Version,
    /// The tag ref recorded in the ledger (which does not exist).
    pub recorded_ref: String,
}

/// Report from diffing the local ledger against the live crates.io state.
#[derive(Debug)]
pub struct CheckReport {
    /// Crate name.
    pub crate_name: String,
    /// The version currently published as latest on crates.io. `None` if never published.
    pub registry_latest: Option<semver::Version>,
    /// Pending versions (sorted ascending).
    pub pending: Vec<LedgerEntry>,
    /// Skipped versions.
    pub skipped: Vec<LedgerEntry>,
    /// Yanked versions.
    pub yanked: Vec<LedgerEntry>,
    /// Pending entries whose backing ref does not exist.
    pub orphaned: Vec<OrphanedEntry>,
}

/// Resolves the tag pattern from ledger settings or auto-detection.
fn resolve_tag_pattern(settings: &crate_seq_ledger::LedgerSettings, crate_name: &str) -> String {
    settings
        .tag_pattern
        .clone()
        .unwrap_or_else(|| detect_tag_pattern(crate_name, false))
}

/// Finds the highest non-yanked version from registry metadata.
fn registry_latest(
    metadata: Option<&crate_seq_registry::CrateMetadata>,
) -> Option<semver::Version> {
    metadata?
        .versions
        .iter()
        .filter(|v| !v.yanked)
        .map(|v| &v.version)
        .max()
        .cloned()
}

/// Collects entries filtered by status, sorted ascending.
fn entries_with_status(entries: &[LedgerEntry], status: LedgerStatus) -> Vec<LedgerEntry> {
    let mut out: Vec<LedgerEntry> = entries
        .iter()
        .filter(|e| e.status == status)
        .cloned()
        .collect();
    out.sort_by(|a, b| a.version.cmp(&b.version));
    out
}

/// Returns `true` if a tarball matching `sha256` exists in `snapshot_store`.
fn snapshot_hash_exists(sha256: &str, snapshot_store: &Path) -> bool {
    let Ok(entries) = std::fs::read_dir(snapshot_store) else {
        return false;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("gz") {
            continue;
        }
        if matches!(crate_seq_snapshot::hash_tarball(&path), Ok(h) if h == sha256) {
            return true;
        }
    }
    false
}

/// Identifies pending entries whose backing ref is absent.
///
/// `GitTag` entries are checked against `git_tag_names`. `Snapshot` entries are
/// checked by scanning `snapshot_store` for a matching SHA-256.
fn find_orphaned(
    pending: &[LedgerEntry],
    git_tag_names: &std::collections::HashSet<String>,
    snapshot_store: &Path,
) -> Vec<OrphanedEntry> {
    pending
        .iter()
        .filter(|e| match e.source {
            VersionSource::GitTag => !git_tag_names.contains(&e.ref_),
            VersionSource::Snapshot => !snapshot_hash_exists(&e.ref_, snapshot_store),
        })
        .map(|e| OrphanedEntry {
            version: e.version.clone(),
            recorded_ref: e.ref_.clone(),
        })
        .collect()
}

/// Returns the default snapshot store adjacent to the ledger file.
fn default_snapshot_store(ledger_path: &Path) -> PathBuf {
    ledger_path
        .parent()
        .unwrap_or_else(|| Path::new("."))
        .join(".crate-seq-snapshots")
}

/// Diffs the ledger at `ledger_path` against the live crates.io registry.
///
/// Queries crates.io and git; does not modify any state. `snapshot_store`
/// overrides the default `.crate-seq-snapshots/` directory used when checking
/// for orphaned snapshot entries.
///
/// # Errors
///
/// Returns [`Error::Ledger`] if the ledger cannot be loaded, [`Error::Registry`]
/// on crates.io HTTP failure, or [`Error::Git`] on git discovery failure.
pub fn check_crate(
    ledger_path: &Path,
    repo_path: &Path,
    crate_seq_version: &str,
    snapshot_store: Option<PathBuf>,
) -> Result<CheckReport, Error> {
    let client = CratesIoClient::new(crate_seq_version)?;
    check_crate_with_client(ledger_path, repo_path, &client, snapshot_store)
}

/// Inner implementation that accepts an injected `CratesIoClient`.
///
/// Separated from `check_crate` to allow tests to inject a mock registry client
/// without hitting the live crates.io API.
pub(crate) fn check_crate_with_client(
    ledger_path: &Path,
    repo_path: &Path,
    client: &CratesIoClient,
    snapshot_store: Option<PathBuf>,
) -> Result<CheckReport, Error> {
    let ledger = load(ledger_path)?;
    let crate_name = ledger.crate_config.name.clone();
    let tag_pattern = resolve_tag_pattern(&ledger.settings, &crate_name);

    let metadata = client.fetch_crate_metadata(&crate_name)?;

    let tags = crate_seq_git::discover_tags(repo_path, &tag_pattern)?;
    let tag_names: std::collections::HashSet<String> = tags.into_iter().map(|t| t.name).collect();

    let store = snapshot_store.unwrap_or_else(|| default_snapshot_store(ledger_path));

    let pending = entries_with_status(&ledger.entries, LedgerStatus::Pending);
    let skipped = entries_with_status(&ledger.entries, LedgerStatus::Skipped);
    let yanked = entries_with_status(&ledger.entries, LedgerStatus::Yanked);
    let orphaned = find_orphaned(&pending, &tag_names, &store);

    Ok(CheckReport {
        crate_name,
        registry_latest: registry_latest(metadata.as_ref()),
        pending,
        skipped,
        yanked,
        orphaned,
    })
}