crate_seq_core/pipeline/

dry_run.rs

//! Dry-run publish pipeline: checkout, validate, package — no network writes.

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

use crate_seq_ledger::{detect_tag_pattern, load};

use crate::pipeline::patch::inject_workspace_patches;
use crate::pipeline::source::resolve_source;
use crate::validate::{run_cargo_check, validate_no_path_deps};
use crate::Error;

/// Outcome of a dry-run for a single version.
#[derive(Debug)]
pub enum DryRunOutcome {
    /// `cargo package --allow-dirty` succeeded.
    Pass,
    /// `cargo package` failed; contains stderr.
    PackageFailed(String),
    /// Path dependencies were found; lists dep names.
    PathDepsFound(Vec<String>),
    /// `cargo check` failed; contains stderr.
    CargoCheckFailed(String),
}

/// Result of a dry-run for a single version.
#[derive(Debug)]
pub struct DryRunVersionResult {
    /// The semantic version that was tested.
    pub version: semver::Version,
    /// The tag ref used for the checkout.
    pub tag_ref: String,
    /// The outcome of the dry-run for this version.
    pub outcome: DryRunOutcome,
}

/// Result of the dry-run for all pending versions.
#[derive(Debug)]
pub struct DryRunReport {
    /// Crate name from the ledger.
    pub crate_name: String,
    /// Per-version results in ascending version order.
    pub results: Vec<DryRunVersionResult>,
}

/// 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))
}

/// Runs `cargo package --allow-dirty` for the manifest at `manifest_path`.
///
/// Returns `Pass` on success or `PackageFailed(stderr)` on failure.
fn run_cargo_package(manifest_path: &Path) -> Result<DryRunOutcome, Error> {
    let output = Command::new("cargo")
        .args(["package", "--allow-dirty", "--manifest-path"])
        .arg(manifest_path)
        .output()
        .map_err(|e| Error::Subprocess(e.to_string()))?;

    if output.status.success() {
        Ok(DryRunOutcome::Pass)
    } else {
        let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
        Ok(DryRunOutcome::PackageFailed(stderr))
    }
}

/// Maps path-dep or cargo-check errors to soft outcomes; propagates infrastructure errors.
///
/// Returns `None` if both validations pass (pipeline should continue).
fn run_validations(manifest_path: &Path) -> Result<Option<DryRunOutcome>, Error> {
    match validate_no_path_deps(manifest_path) {
        Ok(()) => {}
        Err(Error::PathDependencies { deps, .. }) => {
            return Ok(Some(DryRunOutcome::PathDepsFound(deps)));
        }
        Err(e) => return Err(e),
    }

    match run_cargo_check(manifest_path) {
        Ok(()) => {}
        Err(Error::CargoCheck { stderr }) => {
            return Ok(Some(DryRunOutcome::CargoCheckFailed(stderr)));
        }
        Err(e) => return Err(e),
    }

    Ok(None)
}

/// Processes a single pending entry: resolve source → validate → rewrite → package.
fn process_entry(
    entry: &crate_seq_ledger::LedgerEntry,
    repo_path: &Path,
    crate_rel_path: &Path,
    snapshot_store: &Path,
) -> Result<DryRunVersionResult, Error> {
    let tag_ref = entry.ref_.clone();
    let checkout = resolve_source(entry, repo_path, snapshot_store)?;
    inject_workspace_patches(checkout.path())?; // inject before manifest ops
    let manifest_path = checkout.path().join(crate_rel_path).join("Cargo.toml");

    if let Some(failed_outcome) = run_validations(&manifest_path)? {
        return Ok(DryRunVersionResult {
            version: entry.version.clone(),
            tag_ref,
            outcome: failed_outcome,
        });
    }

    crate_seq_manifest::rewrite_version(&manifest_path, &entry.version)?;
    let outcome = run_cargo_package(&manifest_path)?;

    Ok(DryRunVersionResult {
        version: entry.version.clone(),
        tag_ref,
        outcome,
    })
}

/// 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")
}

/// Returns the crate directory's path relative to `repo_path`.
///
/// Strips `repo_path` from `ledger_path.parent()`. Falls back to an empty
/// relative path when the ledger sits directly at the repo root (single-crate repos).
fn crate_rel_path(ledger_path: &Path, repo_path: &Path) -> PathBuf {
    let crate_dir = ledger_path.parent().unwrap_or(repo_path);
    crate_dir
        .strip_prefix(repo_path)
        .unwrap_or(std::path::Path::new(""))
        .to_owned()
}

/// Dry-run: resolve each pending version, rewrite `Cargo.toml`, run `cargo package`.
///
/// `snapshot_store` overrides the default `.crate-seq-snapshots/` directory for
/// entries with `source = snapshot`. Git-tag entries ignore `snapshot_store`.
/// No network writes are performed. Does not modify the ledger.
///
/// # Errors
///
/// Returns [`Error::Ledger`] if the ledger cannot be loaded, [`Error::Git`] on
/// checkout failure, [`Error::SnapshotNotFound`] if a snapshot tarball is missing,
/// [`Error::Manifest`] on rewrite failure, or [`Error::Subprocess`] if `cargo
/// package` cannot be spawned.
pub fn publish_dry_run(
    ledger_path: &Path,
    repo_path: &Path,
    snapshot_store: Option<PathBuf>,
) -> Result<DryRunReport, 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 store = snapshot_store.unwrap_or_else(|| default_snapshot_store(ledger_path));
    let rel_path = crate_rel_path(ledger_path, repo_path);

    let pending: Vec<crate_seq_ledger::LedgerEntry> =
        ledger.pending_versions().into_iter().cloned().collect();

    let mut results = Vec::with_capacity(pending.len());
    for entry in &pending {
        results.push(process_entry(entry, repo_path, &rel_path, &store)?);
    }

    Ok(DryRunReport {
        crate_name,
        results,
    })
}