use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, BTreeSet};
use std::fs;
use std::path::Path;
use crate::build_context::BuildContext;
use crate::processor::ProcessorMap;
pub const LOCK_FILE: &str = "rsconstruct.lock";
pub const LEGACY_LOCK_FILE: &str = ".tools.versions";
const LOCK_VERSION: u32 = 1;
const LOCK_HEADER: &str = "\
# rsconstruct.lock: the exact tool versions this project builds with.
# Written by `rsconstruct tool lock`; move to newer releases with
# `rsconstruct tool lock --upgrade`. Commit this file; do not edit it by hand.
";
const VERSIONED_METHODS: [&str; 4] = ["cargo", "gem", "npm", "pip"];
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ToolLock {
pub version: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rsconstruct: Option<SelfPin>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub cargo: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub gem: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub npm: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub pip: BTreeMap<String, String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub binary: BTreeMap<String, BinaryPin>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SelfPin {
pub version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BinaryPin {
pub url: String,
pub sha256: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub executable_sha256: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deb_package: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deb_version: Option<String>,
}
impl ToolLock {
fn empty() -> Self {
Self {
version: LOCK_VERSION,
..Self::default()
}
}
fn versions(&self, method: &str) -> &BTreeMap<String, String> {
match method {
"cargo" => &self.cargo,
"gem" => &self.gem,
"npm" => &self.npm,
"pip" | "uv" => &self.pip,
other => unreachable!("not a versioned lock method: {other}"),
}
}
fn versions_mut(&mut self, method: &str) -> &mut BTreeMap<String, String> {
match method {
"cargo" => &mut self.cargo,
"gem" => &mut self.gem,
"npm" => &mut self.npm,
"pip" | "uv" => &mut self.pip,
other => unreachable!("not a versioned lock method: {other}"),
}
}
pub fn pinned(&self, method: &str, package: &str) -> String {
if !VERSIONED_METHODS.contains(&method) && method != "uv" {
return package.to_string();
}
if !is_bare(method, package) {
return package.to_string();
}
let Some(version) = self.versions(method).get(&lock_key(method, package)) else {
return package.to_string();
};
match method {
"pip" | "uv" => format!("{package}=={version}"),
"gem" => format!("{package}:{version}"),
_ => format!("{package}@{version}"),
}
}
}
fn lock_key(method: &str, package: &str) -> String {
match method {
"pip" | "uv" => crate::config::normalized_distribution_name(package),
_ => package.to_string(),
}
}
fn is_bare(method: &str, package: &str) -> bool {
match method {
"pip" | "uv" => !package.contains(['<', '>', '=', '!', '~', ';', '@', ' ']),
"npm" => package.rfind('@').is_none_or(|i| i == 0),
"gem" => !package.contains(':'),
"cargo" => !package.contains('@'),
_ => false,
}
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct Wanted {
pub cargo: BTreeSet<String>,
pub gem: BTreeSet<String>,
pub npm: BTreeSet<String>,
pub pip: BTreeSet<String>,
pub binary: BTreeSet<String>,
}
impl Wanted {
fn names(&self, method: &str) -> &BTreeSet<String> {
match method {
"cargo" => &self.cargo,
"gem" => &self.gem,
"npm" => &self.npm,
"pip" => &self.pip,
"binary" => &self.binary,
other => unreachable!("not a lock method: {other}"),
}
}
fn add(&mut self, method: &str, package: &str) -> bool {
let set = match method {
"cargo" => &mut self.cargo,
"gem" => &mut self.gem,
"npm" => &mut self.npm,
"pip" | "uv" => &mut self.pip,
"binary" => {
if !crate::tools::binary_is_pinnable(package) {
return false;
}
self.binary.insert(package.to_string());
return true;
}
_ => return false,
};
if !is_bare(method, package) {
return false;
}
set.insert(lock_key(method, package));
true
}
}
pub fn collect_wanted(
processors: &ProcessorMap,
enabled: &dyn Fn(&str) -> bool,
deps: &crate::config::DependenciesConfig,
root: &Path,
) -> Result<Wanted> {
let uv_owned: BTreeSet<String> = {
let uv_lock = root.join("uv.lock");
if deps.pip_source == crate::config::PipSource::UvLock && uv_lock.exists() {
crate::config::uv_lock_pinned_deps(&uv_lock)?
.iter()
.map(|req| crate::config::normalized_distribution_name(req))
.collect()
} else {
BTreeSet::new()
}
};
let npm_owned: BTreeSet<String> = {
let package_lock = root.join("package-lock.json");
if package_lock.exists() {
crate::config::package_lock_pins(&package_lock)?
.into_keys()
.collect()
} else {
BTreeSet::new()
}
};
let mut wanted = Wanted::default();
let mut names: Vec<&String> = processors.keys().collect();
names.sort();
for name in names {
if !enabled(name) {
continue;
}
for tool in processors[name].required_tools() {
if tool.contains('/') {
continue;
}
let Some(method) =
crate::tools::tool_info(&tool).and_then(|info| info.install_methods.first())
else {
continue;
};
let key = lock_key(method.method, method.package);
let owned = match method.method {
"pip" => uv_owned.contains(&key),
"npm" => npm_owned.contains(&key),
_ => false,
};
if !owned {
wanted.add(method.method, method.package);
}
}
}
for (method, list) in [
("cargo", &deps.cargo),
("gem", &deps.gem),
("npm", &deps.npm),
("pip", &deps.pip),
] {
for package in list {
wanted.add(method, package);
}
}
Ok(wanted)
}
fn reject_legacy_lock() -> Result<()> {
if Path::new(LEGACY_LOCK_FILE).exists() {
return Err(crate::exit_code::config_error(format!(
"{LEGACY_LOCK_FILE} is no longer read: rsconstruct.lock replaced it, and its \
machine-local tool paths cannot be converted. Delete {LEGACY_LOCK_FILE} and run \
`rsconstruct tool lock`."
)));
}
Ok(())
}
pub fn read_lock_file() -> Result<Option<ToolLock>> {
let path = Path::new(LOCK_FILE);
if !path.exists() {
return Ok(None);
}
let content =
fs::read_to_string(path).with_context(|| format!("Failed to read {}", path.display()))?;
parse_lock(&content).map(Some)
}
fn parse_lock(content: &str) -> Result<ToolLock> {
let lock: ToolLock = toml::from_str(content)
.map_err(|e| crate::exit_code::config_error(format!("Failed to parse {LOCK_FILE}: {e}")))?;
if lock.version != LOCK_VERSION {
return Err(crate::exit_code::config_error(format!(
"{LOCK_FILE} has format version {}, but this rsconstruct reads version \
{LOCK_VERSION}",
lock.version
)));
}
Ok(lock)
}
fn render_lock(lock: &ToolLock) -> Result<String> {
let body = toml::to_string(lock).context("Failed to serialize rsconstruct.lock")?;
Ok(format!("{LOCK_HEADER}\n{body}"))
}
fn write_lock_file(lock: &ToolLock) -> Result<()> {
let path = Path::new(LOCK_FILE);
let text = render_lock(lock)?;
let tmp = format!("{LOCK_FILE}.tmp-{}", std::process::id());
fs::write(&tmp, text).with_context(|| format!("Failed to write {tmp}"))?;
fs::rename(&tmp, path)
.with_context(|| format!("Failed to move {tmp} into place as {}", path.display()))?;
Ok(())
}
type Entries = Vec<(String, String)>;
fn diff(lock: &ToolLock, wanted: &Wanted) -> (Entries, Entries) {
let mut missing = Vec::new();
let mut stale = Vec::new();
for method in VERSIONED_METHODS {
let locked = lock.versions(method);
let names = wanted.names(method);
missing.extend(
names
.iter()
.filter(|n| !locked.contains_key(*n))
.map(|n| (method.to_string(), n.clone())),
);
stale.extend(
locked
.keys()
.filter(|n| !names.contains(*n))
.map(|n| (method.to_string(), n.clone())),
);
}
missing.extend(
wanted
.binary
.iter()
.filter(|n| !lock.binary.contains_key(*n))
.map(|n| ("binary".to_string(), n.clone())),
);
stale.extend(
lock.binary
.keys()
.filter(|n| !wanted.binary.contains(*n))
.map(|n| ("binary".to_string(), n.clone())),
);
(missing, stale)
}
fn resolve_version(method: &str, name: &str) -> Result<String> {
let (url, pointer) = match method {
"cargo" => (
format!("https://crates.io/api/v1/crates/{name}"),
"/crate/max_stable_version",
),
"gem" => (
format!("https://rubygems.org/api/v1/versions/{name}/latest.json"),
"/version",
),
"npm" => (
format!(
"https://registry.npmjs.org/{}/latest",
name.replace('/', "%2F")
),
"/version",
),
"pip" => (
format!("https://pypi.org/pypi/{name}/json"),
"/info/version",
),
other => unreachable!("not a versioned lock method: {other}"),
};
let json = crate::download::get_json(&url)?;
json.pointer(pointer)
.and_then(serde_json::Value::as_str)
.filter(|v| !v.is_empty() && *v != "unknown")
.map(str::to_string)
.with_context(|| format!("{url} names no released version of {method} package {name}"))
}
fn resolve_into(
ctx: &BuildContext,
lock: &mut ToolLock,
method: &str,
name: &str,
verbose: bool,
) -> Result<()> {
if verbose {
println!("Resolving {method} {name}");
}
if method == "binary" {
let pin = crate::tools::lock_binary(ctx, name, verbose)
.with_context(|| format!("Failed to lock binary {name}"))?;
lock.binary.insert(name.to_string(), pin);
} else {
let version = resolve_version(method, name)
.with_context(|| format!("Failed to lock {method} package {name}"))?;
lock.versions_mut(method).insert(name.to_string(), version);
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LockMode {
Locked,
Fill,
Upgrade,
}
impl LockMode {
pub fn for_environment() -> Self {
if crate::config::running_in_ci() {
Self::Locked
} else {
Self::Fill
}
}
}
pub struct Synced {
pub lock: ToolLock,
pub created: bool,
pub changes: Vec<String>,
}
impl Synced {
pub fn report(&self) {
if self.changes.is_empty() {
return;
}
for line in &self.changes {
println!(" {line}");
}
if self.created {
println!("Created {LOCK_FILE}; commit it.");
} else {
println!("Updated {LOCK_FILE}; commit it.");
}
}
}
fn entry_label(lock: &ToolLock, method: &str, name: &str) -> String {
if method == "binary" {
lock.binary
.get(name)
.map_or_else(String::new, |p| p.url.clone())
} else {
lock.versions(method).get(name).cloned().unwrap_or_default()
}
}
pub fn sync(ctx: &BuildContext, wanted: &Wanted, mode: LockMode, verbose: bool) -> Result<Synced> {
reject_legacy_lock()?;
let existing = read_lock_file()?;
if mode == LockMode::Locked {
let Some(lock) = existing else {
return Err(lock_error(format!(
"No {LOCK_FILE} found. Run `rsconstruct tool lock` outside CI and commit it."
)));
};
let (missing, stale) = diff(&lock, wanted);
let mut problems: Vec<String> = Vec::new();
problems.extend(
missing
.iter()
.map(|(m, n)| format!("{m} {n} — needed but not locked")),
);
problems.extend(
stale
.iter()
.map(|(m, n)| format!("{m} {n} — locked but no longer needed")),
);
if lock.rsconstruct.is_none() {
problems.push("rsconstruct — no [rsconstruct] version".to_string());
}
if !problems.is_empty() {
return Err(lock_error(format!(
"{LOCK_FILE} does not match this project (run `rsconstruct tool lock` \
outside CI and commit the result):\n{}",
problems.join("\n")
)));
}
return Ok(Synced {
lock,
created: false,
changes: Vec::new(),
});
}
let upgrade_all = mode == LockMode::Upgrade;
rewrite(
ctx,
wanted,
existing,
upgrade_all,
&[],
upgrade_all,
verbose,
)
}
pub fn upgrade_named(
ctx: &BuildContext,
wanted: &Wanted,
names: &[String],
verbose: bool,
) -> Result<Synced> {
reject_legacy_lock()?;
let (targets, bump_self) = select_entries(wanted, names)?;
let existing = read_lock_file()?;
rewrite(ctx, wanted, existing, false, &targets, bump_self, verbose)
}
fn select_entries(wanted: &Wanted, names: &[String]) -> Result<(Entries, bool)> {
let mut targets = Vec::new();
let mut bump_self = false;
let mut unknown = Vec::new();
for name in names {
if name == "rsconstruct" {
bump_self = true;
continue;
}
let before = targets.len();
for method in VERSIONED_METHODS.iter().copied().chain(["binary"]) {
let key = lock_key(method, name);
if wanted.names(method).contains(&key) {
targets.push((method.to_string(), key));
}
}
if targets.len() == before {
unknown.push(name.as_str());
}
}
if !unknown.is_empty() {
return Err(crate::exit_code::config_error(format!(
"not a tool this project locks: {} (see the entries in {LOCK_FILE})",
unknown.join(", ")
)));
}
Ok((targets, bump_self))
}
fn rewrite(
ctx: &BuildContext,
wanted: &Wanted,
existing: Option<ToolLock>,
fresh: bool,
reresolve: &[(String, String)],
bump_self: bool,
verbose: bool,
) -> Result<Synced> {
let running = env!("CARGO_PKG_VERSION");
let created = existing.is_none();
let before = existing.unwrap_or_else(ToolLock::empty);
let mut lock = if fresh {
ToolLock::empty()
} else {
before.clone()
};
for (method, name) in reresolve {
if method == "binary" {
lock.binary.remove(name);
} else {
lock.versions_mut(method).remove(name);
}
}
let (missing, stale) = diff(&lock, wanted);
for (method, name) in &stale {
if method == "binary" {
lock.binary.remove(name);
} else {
lock.versions_mut(method).remove(name);
}
}
for (method, name) in &missing {
resolve_into(ctx, &mut lock, method, name, verbose)?;
}
if bump_self || lock.rsconstruct.is_none() {
lock.rsconstruct = Some(SelfPin {
version: running.to_string(),
});
}
let changes = describe_changes(&before, &lock);
if created || lock != before {
write_lock_file(&lock)?;
}
Ok(Synced {
lock,
created,
changes,
})
}
fn describe_changes(before: &ToolLock, after: &ToolLock) -> Vec<String> {
let mut changes = Vec::new();
let self_version = |l: &ToolLock| l.rsconstruct.as_ref().map(|p| p.version.clone());
match (self_version(before), self_version(after)) {
(None, Some(new)) => changes.push(format!("+ rsconstruct {new}")),
(Some(old), Some(new)) if old != new => {
changes.push(format!("~ rsconstruct {old} -> {new}"));
}
_ => {}
}
let methods = VERSIONED_METHODS.iter().copied().chain(["binary"]);
for method in methods {
let keys = |l: &ToolLock| -> BTreeSet<String> {
if method == "binary" {
l.binary.keys().cloned().collect()
} else {
l.versions(method).keys().cloned().collect()
}
};
let all: BTreeSet<String> = keys(before).union(&keys(after)).cloned().collect();
for name in all {
let old = entry_label(before, method, &name);
let new = entry_label(after, method, &name);
match (old.is_empty(), new.is_empty()) {
(true, false) => changes.push(format!("+ {method} {name} {new}")),
(false, true) => changes.push(format!("- {method} {name}")),
(false, false) if old != new => {
changes.push(format!("~ {method} {name} {old} -> {new}"));
}
_ => {}
}
}
}
changes
}
fn lock_error(msg: String) -> anyhow::Error {
crate::exit_code::RsconstructError::new(crate::exit_code::RsconstructExitCode::ToolError, msg)
.into()
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Mismatch {
pub method: String,
pub name: String,
pub locked: String,
pub installed: Option<String>,
}
impl std::fmt::Display for Mismatch {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.installed {
Some(found) => write!(
f,
"{} {} — locked {}, installed {found}",
self.method, self.name, self.locked
),
None => write!(
f,
"{} {} — locked {}, not installed",
self.method, self.name, self.locked
),
}
}
}
fn installed_pip_versions(ctx: &BuildContext, names: &[&str]) -> BTreeMap<String, String> {
const SCRIPT: &str = "\
import sys, importlib.metadata as m
for n in sys.argv[1:]:
try:
print(n, m.version(n))
except m.PackageNotFoundError:
pass
";
let mut cmd = std::process::Command::new("python3");
cmd.arg("-c").arg(SCRIPT).args(names);
let Ok(out) = crate::processor::run_command_capture(ctx, &cmd) else {
return BTreeMap::new();
};
String::from_utf8_lossy(&out.stdout)
.lines()
.filter_map(|l| l.split_once(' '))
.map(|(n, v)| (n.to_string(), v.trim().to_string()))
.collect()
}
fn installed_npm_globals(ctx: &BuildContext) -> BTreeMap<String, String> {
let mut cmd = std::process::Command::new("npm");
cmd.args(["ls", "-g", "--depth=0", "--json"]);
let Ok(out) = crate::processor::run_command_capture(ctx, &cmd) else {
return BTreeMap::new();
};
let Ok(json) = serde_json::from_slice::<serde_json::Value>(&out.stdout) else {
return BTreeMap::new();
};
json.get("dependencies")
.and_then(serde_json::Value::as_object)
.map(|deps| {
deps.iter()
.filter_map(|(name, entry)| {
entry
.get("version")
.and_then(serde_json::Value::as_str)
.map(|v| (name.clone(), v.to_string()))
})
.collect()
})
.unwrap_or_default()
}
fn installed_gem_versions(ctx: &BuildContext, name: &str) -> Vec<String> {
let mut cmd = std::process::Command::new("gem");
cmd.args(["list", "--local", "--exact", name]);
let Ok(out) = crate::processor::run_command_capture(ctx, &cmd) else {
return Vec::new();
};
parse_gem_list(&String::from_utf8_lossy(&out.stdout), name)
}
fn parse_gem_list(listing: &str, name: &str) -> Vec<String> {
listing
.lines()
.find_map(|line| line.strip_prefix(name)?.trim().strip_prefix('('))
.and_then(|rest| rest.strip_suffix(')'))
.map(|versions| {
versions
.split(',')
.map(|v| v.trim().trim_start_matches("default:").trim().to_string())
.filter(|v| !v.is_empty())
.collect()
})
.unwrap_or_default()
}
fn installed_binary_identity(ctx: &BuildContext, name: &str, pin: &BinaryPin) -> Option<String> {
if let Some(package) = &pin.deb_package {
let mut cmd = std::process::Command::new("dpkg-query");
cmd.args(["-W", "-f", "${Version}", package]);
let out = crate::processor::run_command_capture(ctx, &cmd).ok()?;
let version = String::from_utf8_lossy(&out.stdout).trim().to_string();
return (out.status.success() && !version.is_empty()).then_some(version);
}
let path = which::which(crate::tools::binary_dest(name)?).ok()?;
crate::tools::file_sha256(&path).ok()
}
pub fn mismatches(ctx: &BuildContext, lock: &ToolLock, wanted: &Wanted) -> Vec<Mismatch> {
let mut found = Vec::new();
let mut push = |method: &str, name: &str, locked: &str, installed: Option<String>| {
found.push(Mismatch {
method: method.to_string(),
name: name.to_string(),
locked: locked.to_string(),
installed,
});
};
if !wanted.cargo.is_empty() {
let installed = crate::tools::installed_cargo_crates(ctx).unwrap_or_default();
for name in &wanted.cargo {
if let Some(locked) = lock.cargo.get(name) {
let have = installed.get(name);
if have != Some(locked) {
push("cargo", name, locked, have.cloned());
}
}
}
}
if !wanted.pip.is_empty() {
let names: Vec<&str> = wanted.pip.iter().map(String::as_str).collect();
let installed = installed_pip_versions(ctx, &names);
for name in &wanted.pip {
if let Some(locked) = lock.pip.get(name) {
let have = installed.get(name);
if have != Some(locked) {
push("pip", name, locked, have.cloned());
}
}
}
}
if !wanted.npm.is_empty() {
let installed = installed_npm_globals(ctx);
for name in &wanted.npm {
if let Some(locked) = lock.npm.get(name) {
let have = installed.get(name);
if have != Some(locked) {
push("npm", name, locked, have.cloned());
}
}
}
}
for name in &wanted.gem {
if let Some(locked) = lock.gem.get(name) {
let have = installed_gem_versions(ctx, name);
if !have.contains(locked) {
push(
"gem",
name,
locked,
(!have.is_empty()).then(|| have.join(", ")),
);
}
}
}
for name in &wanted.binary {
if let Some(pin) = lock.binary.get(name) {
let (locked, have) = match (&pin.deb_version, &pin.executable_sha256) {
(Some(version), _) => (version.clone(), installed_binary_identity(ctx, name, pin)),
(None, Some(sha)) => (
format!("sha256 {sha}"),
installed_binary_identity(ctx, name, pin).map(|s| format!("sha256 {s}")),
),
(None, None) => continue,
};
if have.as_ref() != Some(&locked) {
push("binary", name, &locked, have);
}
}
}
found
}
pub fn verify(ctx: &BuildContext, wanted: &Wanted) -> Result<ToolLock> {
let lock = sync(ctx, wanted, LockMode::Locked, false)?.lock;
let found = mismatches(ctx, &lock, wanted);
if !found.is_empty() {
let lines: Vec<String> = found.iter().map(ToString::to_string).collect();
return Err(lock_error(format!(
"Installed tools do not match {LOCK_FILE} (run `rsconstruct tool install-deps` \
and `rsconstruct tool install`):\n{}",
lines.join("\n")
)));
}
Ok(lock)
}
fn tool_identity(tool: &str) -> Option<String> {
let path = which::which(tool).ok()?;
let meta = match fs::metadata(&path) {
Ok(m) => m,
Err(e) => {
crate::output::warn(&format!(
"Cannot stat tool '{tool}' at {}: {e} — excluding it from cache keys",
path.display()
));
return None;
}
};
let mtime = meta
.modified()
.ok()
.and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())
.map_or(0, |d| d.as_nanos());
Some(format!("{tool}@{}:{}:{mtime}", path.display(), meta.len()))
}
pub fn processor_tool_hashes(
processors: &ProcessorMap,
enabled: &dyn Fn(&str) -> bool,
) -> std::collections::HashMap<String, String> {
let mut result = std::collections::HashMap::new();
let mut names: Vec<&String> = processors.keys().collect();
names.sort();
let mut wanted: BTreeMap<String, Vec<String>> = BTreeMap::new();
for name in &names {
if !enabled(name) {
continue;
}
let tools = processors[*name].required_tools();
if tools.is_empty() {
continue;
}
wanted.insert((*name).clone(), tools);
}
let distinct: BTreeSet<String> = wanted.values().flatten().cloned().collect();
let identity_cache: BTreeMap<String, Option<String>> = distinct
.iter()
.map(|t| (t.clone(), tool_identity(t)))
.collect();
for name in names {
let Some(tools) = wanted.get(name) else {
continue;
};
let mut version_parts: Vec<String> = Vec::new();
for tool in tools {
if let Some(Some(identity)) = identity_cache.get(tool) {
version_parts.push(identity.clone());
}
}
if !version_parts.is_empty() {
version_parts.sort();
let parts: Vec<&str> = version_parts.iter().map(String::as_str).collect();
result.insert(name.clone(), crate::checksum::hash_parts(&parts));
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
fn sample_lock() -> ToolLock {
let mut lock = ToolLock::empty();
lock.rsconstruct = Some(SelfPin {
version: "0.9.138".to_string(),
});
lock.cargo
.insert("cargo-deny".to_string(), "0.18.3".to_string());
lock.pip.insert("ruff".to_string(), "0.14.0".to_string());
lock.pip
.insert("manim-voiceover".to_string(), "0.3.7".to_string());
lock.npm
.insert("@scope/tool".to_string(), "2.0.0".to_string());
lock.gem.insert("mdl".to_string(), "0.13.0".to_string());
lock.binary.insert(
"rumdl".to_string(),
BinaryPin {
url: "https://example.com/rumdl.tar.gz".to_string(),
sha256: "aa".to_string(),
executable_sha256: Some("bb".to_string()),
deb_package: None,
deb_version: None,
},
);
lock
}
#[test]
fn lock_round_trips_through_toml_with_header() {
let lock = sample_lock();
let text = render_lock(&lock).unwrap();
assert!(text.starts_with("# rsconstruct.lock"), "{text}");
assert!(
text.contains("[rsconstruct]\nversion = \"0.9.138\""),
"{text}"
);
assert_eq!(parse_lock(&text).unwrap(), lock);
}
#[test]
fn self_pin_renders_as_a_plain_table_line() {
let text = render_lock(&sample_lock()).unwrap();
let after = text.split("[rsconstruct]\n").nth(1).unwrap();
assert_eq!(after.lines().next(), Some("version = \"0.9.138\""));
}
#[test]
fn empty_sections_are_left_out() {
let text = render_lock(&ToolLock::empty()).unwrap();
assert!(!text.contains("[cargo]"), "{text}");
assert!(!text.contains("[binary"), "{text}");
}
#[test]
fn other_format_versions_and_unknown_keys_are_errors() {
assert!(parse_lock("version = 2\n").is_err());
assert!(parse_lock("version = 1\n[surprise]\n").is_err());
assert!(parse_lock("version = 1\n").is_ok());
}
#[test]
fn pinned_formats_each_package_manager() {
let lock = sample_lock();
assert_eq!(lock.pinned("cargo", "cargo-deny"), "cargo-deny@0.18.3");
assert_eq!(lock.pinned("pip", "ruff"), "ruff==0.14.0");
assert_eq!(lock.pinned("uv", "Ruff"), "Ruff==0.14.0");
assert_eq!(
lock.pinned("pip", "manim_voiceover[gtts]"),
"manim_voiceover[gtts]==0.3.7"
);
assert_eq!(lock.pinned("npm", "@scope/tool"), "@scope/tool@2.0.0");
assert_eq!(lock.pinned("gem", "mdl"), "mdl:0.13.0");
}
#[test]
fn pinned_leaves_other_requests_alone() {
let lock = sample_lock();
assert_eq!(lock.pinned("pip", "black"), "black");
assert_eq!(lock.pinned("pip", "ruff>=0.5"), "ruff>=0.5");
assert_eq!(lock.pinned("pip", "ruff==0.1.0"), "ruff==0.1.0");
assert_eq!(lock.pinned("cargo", "cargo-deny@0.1.0"), "cargo-deny@0.1.0");
assert_eq!(lock.pinned("apt", "ruff"), "ruff");
}
#[test]
fn wanted_skips_constrained_entries_and_normalizes_pip_names() {
let mut wanted = Wanted::default();
assert!(wanted.add("pip", "Types_PyYAML"));
assert!(!wanted.add("pip", "ruff>=0.5"));
assert!(wanted.add("npm", "@scope/tool"));
assert!(!wanted.add("npm", "@scope/tool@1.0.0"));
assert!(!wanted.add("apt", "aspell"));
assert!(!wanted.add("binary", "google-chrome-stable"));
assert!(wanted.add("binary", "rumdl"));
assert_eq!(wanted.pip.iter().collect::<Vec<_>>(), vec!["types-pyyaml"]);
assert_eq!(wanted.npm.len(), 1);
assert_eq!(wanted.binary.len(), 1);
}
#[test]
fn diff_reports_missing_and_stale_entries() {
let lock = sample_lock();
let mut wanted = Wanted::default();
wanted.add("cargo", "cargo-deny");
wanted.add("cargo", "cargo-nextest");
wanted.add("binary", "rumdl");
let (missing, stale) = diff(&lock, &wanted);
assert_eq!(
missing,
vec![("cargo".to_string(), "cargo-nextest".to_string())]
);
let stale: Vec<String> = stale.iter().map(|(m, n)| format!("{m} {n}")).collect();
assert_eq!(
stale,
vec![
"gem mdl",
"npm @scope/tool",
"pip manim-voiceover",
"pip ruff"
]
);
}
#[test]
fn select_entries_matches_names_across_methods() {
let mut wanted = Wanted::default();
wanted.add("cargo", "oxlint");
wanted.add("binary", "oxlint");
wanted.add("pip", "types-PyYAML");
let names = |list: &[&str]| list.iter().map(ToString::to_string).collect::<Vec<_>>();
let (targets, bump_self) =
select_entries(&wanted, &names(&["oxlint", "Types_PyYAML"])).unwrap();
let targets: Vec<String> = targets.iter().map(|(m, n)| format!("{m} {n}")).collect();
assert_eq!(
targets,
vec!["cargo oxlint", "binary oxlint", "pip types-pyyaml"]
);
assert!(!bump_self);
let (targets, bump_self) = select_entries(&wanted, &names(&["rsconstruct"])).unwrap();
assert_eq!(targets, Vec::new());
assert!(bump_self);
let err = select_entries(&wanted, &names(&["oxlint", "nosuch"])).unwrap_err();
assert!(err.to_string().contains("nosuch"), "{err}");
}
#[test]
fn describe_changes_lists_additions_removals_and_moves() {
let before = sample_lock();
let mut after = before.clone();
after
.cargo
.insert("cargo-deny".to_string(), "0.19.0".to_string());
after.gem.remove("mdl");
after
.cargo
.insert("mdbook".to_string(), "0.4.40".to_string());
assert_eq!(
describe_changes(&before, &after),
vec![
"~ cargo cargo-deny 0.18.3 -> 0.19.0",
"+ cargo mdbook 0.4.40",
"- gem mdl",
]
);
}
#[test]
fn gem_list_parses_plain_and_default_versions() {
assert_eq!(
parse_gem_list("mdl (0.13.0, default: 0.12.0)\n", "mdl"),
vec!["0.13.0", "0.12.0"]
);
assert_eq!(parse_gem_list("", "mdl"), Vec::<String>::new());
assert_eq!(parse_gem_list("mdlx (1.0)\n", "mdl"), Vec::<String>::new());
}
}