crate_seq_core/

init.rs

//! `init` command orchestration: git tags + registry state → per-crate ledgers.

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

use std::collections::HashMap;
use std::path::PathBuf;

use crate_seq_ledger::{
    CrateConfig, CrateSeqLedger, LedgerAuth, LedgerEntry, LedgerSettings, LedgerStatus,
    VersionSource,
};
use crate_seq_registry::CratesIoClient;

use crate::{discover_members, Error, WorkspaceMember};

/// Configuration for the `init` command.
pub struct InitConfig {
    /// Root of the repository (for git tag discovery).
    pub repo_path: PathBuf,
    /// Root workspace `Cargo.toml` directory.
    pub workspace_root: PathBuf,
    /// If `Some`, initialise only the named crate. If `None`, initialise all members.
    pub crate_filter: Option<String>,
    /// Version of crate-seq itself, for the crates.io `User-Agent` header.
    pub crate_seq_version: String,
}

/// Result of initialising one crate's ledger.
#[derive(Debug)]
pub struct InitResult {
    /// The crate that was initialised.
    pub crate_name: String,
    /// Path of the written ledger file.
    pub ledger_path: PathBuf,
    /// Number of version entries written (pending + published + yanked).
    pub version_count: usize,
}

/// Resolves which members to process, applying the crate filter if set.
fn select_members(
    all: Vec<WorkspaceMember>,
    filter: Option<&str>,
) -> Result<Vec<WorkspaceMember>, Error> {
    match filter {
        None => Ok(all),
        Some(name) => {
            let found = all.into_iter().find(|m| m.name == name);
            found
                .map(|m| vec![m])
                .ok_or_else(|| Error::CrateNotFound(name.to_owned()))
        }
    }
}

/// Loads the tag pattern: from existing ledger if present, otherwise auto-detected.
fn resolve_tag_pattern(member: &WorkspaceMember, is_workspace: bool) -> String {
    let ledger_path = member.crate_dir.join(".crate-seq.toml");
    if ledger_path.exists() {
        if let Ok(existing) = crate_seq_ledger::load(&ledger_path) {
            if let Some(pattern) = existing.settings.tag_pattern {
                return pattern;
            }
        }
    }
    crate_seq_ledger::detect_tag_pattern(&member.name, is_workspace)
}

/// Builds a map from `semver::Version` to tag name for quick lookup.
fn tag_name_map(tags: &[crate_seq_git::TagRef]) -> HashMap<semver::Version, String> {
    tags.iter()
        .map(|t| (t.semver.clone(), t.name.clone()))
        .collect()
}

/// Constructs the fallback tag ref when no git tag exists for a registry version.
fn fallback_tag_ref(crate_name: &str, version: &semver::Version) -> String {
    format!("{crate_name}-v{version}")
}

/// Builds `LedgerEntry` values from registry versions and git tags.
fn build_entries(
    member: &WorkspaceMember,
    tags: &[crate_seq_git::TagRef],
    registry: Option<&crate_seq_registry::CrateMetadata>,
) -> Vec<LedgerEntry> {
    let tag_map = tag_name_map(tags);
    let mut entries: Vec<LedgerEntry> = Vec::new();

    if let Some(metadata) = registry {
        for v in &metadata.versions {
            let status = if v.yanked {
                LedgerStatus::Yanked
            } else {
                LedgerStatus::Published
            };
            let ref_ = tag_map
                .get(&v.version)
                .cloned()
                .unwrap_or_else(|| fallback_tag_ref(&member.name, &v.version));
            entries.push(LedgerEntry {
                version: v.version.clone(),
                source: VersionSource::GitTag,
                ref_,
                status,
            });
        }
    }

    let registry_versions: std::collections::HashSet<semver::Version> = registry
        .map(|m| m.versions.iter().map(|v| v.version.clone()).collect())
        .unwrap_or_default();

    for tag in tags {
        if !registry_versions.contains(&tag.semver) {
            entries.push(LedgerEntry {
                version: tag.semver.clone(),
                source: VersionSource::GitTag,
                ref_: tag.name.clone(),
                status: LedgerStatus::Pending,
            });
        }
    }

    entries.sort_by(|a, b| a.version.cmp(&b.version));
    entries
}

/// Initialises the ledger for a single workspace member.
fn init_member(
    member: &WorkspaceMember,
    is_workspace: bool,
    config: &InitConfig,
    client: &CratesIoClient,
) -> Result<InitResult, Error> {
    let tag_pattern = resolve_tag_pattern(member, is_workspace);
    let tags = crate_seq_git::discover_tags(&config.repo_path, &tag_pattern)?;
    let registry = client.fetch_crate_metadata(&member.name)?;
    let entries = build_entries(member, &tags, registry.as_ref());
    let version_count = entries.len();

    let ledger = CrateSeqLedger {
        crate_config: CrateConfig {
            name: member.name.clone(),
            registry: None,
        },
        settings: LedgerSettings {
            tag_pattern: Some(tag_pattern),
            ..Default::default()
        },
        auth: LedgerAuth::default(),
        entries,
    };

    let ledger_path = member.crate_dir.join(".crate-seq.toml");
    crate_seq_ledger::save(&ledger_path, &ledger)?;

    Ok(InitResult {
        crate_name: member.name.clone(),
        ledger_path,
        version_count,
    })
}

/// Initialises per-crate ledgers for the given workspace.
///
/// For each member: detects tag pattern, queries git tags and crates.io,
/// diffs them to build ledger entries (registry-published → `Published`/`Yanked`,
/// git-only → `Pending`), and writes the ledger alongside the crate's `Cargo.toml`.
///
/// # Errors
///
/// Returns [`Error::CrateNotFound`] if `config.crate_filter` names a crate that
/// is not a workspace member. Propagates [`Error::Git`], [`Error::Registry`], and
/// [`Error::Ledger`] from downstream operations.
pub fn init(config: &InitConfig) -> Result<Vec<InitResult>, Error> {
    let client = CratesIoClient::new(&config.crate_seq_version)?;
    init_with_client(config, &client)
}

/// Inner implementation that accepts an injected `CratesIoClient`.
///
/// Separated from `init` to allow tests to inject a mock registry client
/// without hitting the live crates.io API.
pub(crate) fn init_with_client(
    config: &InitConfig,
    client: &CratesIoClient,
) -> Result<Vec<InitResult>, Error> {
    let all_members = discover_members(&config.workspace_root)?;
    let members = select_members(all_members, config.crate_filter.as_deref())?;
    let is_workspace = members.len() > 1;

    let mut results = Vec::with_capacity(members.len());
    for member in &members {
        results.push(init_member(member, is_workspace, config, client)?);
    }

    Ok(results)
}