//! Pure pending changes, version selection and dependency diagnostics for Manage.
use crate::{
Result,
local_mods::{LocalMod, ModSource},
mod_list::{ModList, ModListEntry, set_enabled},
store::Snapshot,
version::{Dependency, DependencyKind, compare_versions, satisfies},
};
use std::collections::BTreeMap;
pub type Pending = Vec<(String, bool)>;
pub type Pins = Vec<(String, Option<String>)>;
fn saved_enabled(snapshot: &Snapshot, name: &str) -> bool {
snapshot
.mod_list
.mods
.iter()
.find(|m| m.name == name)
.map_or_else(
|| {
snapshot
.mods
.iter()
.chain(&snapshot.builtin)
.any(|m| m.name == name)
},
|m| m.enabled,
)
}
pub fn enabled(snapshot: &Snapshot, pending: &Pending, name: &str) -> bool {
name == "base"
|| pending
.iter()
.rev()
.find(|(n, _)| n == name)
.map_or_else(|| saved_enabled(snapshot, name), |(_, value)| *value)
}
pub fn set_pending(snapshot: &Snapshot, pending: &Pending, name: &str, value: bool) -> Pending {
let mut result: Pending = pending.iter().filter(|(n, _)| n != name).cloned().collect();
if name != "base" && value != saved_enabled(snapshot, name) {
result.push((name.into(), value));
}
result
}
pub fn effective_list(snapshot: &Snapshot, pending: &Pending, pins: &Pins) -> ModList {
let mut list = snapshot.mod_list.clone();
for (name, value) in pending {
if name != "base" {
list = set_enabled(&list, name, *value);
}
}
for (name, version) in pins {
if !list.mods.iter().any(|entry| entry.name == *name) {
list.mods.push(ModListEntry {
name: name.clone(),
enabled: enabled(snapshot, pending, name),
version: None,
});
}
for entry in list.mods.iter_mut().filter(|entry| entry.name == *name) {
entry.version = version.clone();
}
}
set_enabled(&list, "base", true)
}
fn effective_pin<'a>(snapshot: &'a Snapshot, pins: &'a Pins, name: &str) -> Option<&'a str> {
if let Some((_, version)) = pins.iter().rev().find(|(n, _)| n == name) {
return version.as_deref();
}
snapshot
.mod_list
.mods
.iter()
.find(|entry| entry.name == name)
.and_then(|entry| entry.version.as_deref())
}
fn source_rank(source: ModSource) -> u8 {
match source {
ModSource::Builtin => 0,
ModSource::Folder => 1,
ModSource::Zip => 2,
}
}
/// One installed version per name, including disabled mods, in name order.
/// Equal numeric versions use the version text, then source and path to break ties.
pub fn loaded_mods<'a>(snapshot: &'a Snapshot, pins: &Pins) -> Vec<&'a LocalMod> {
let mut selected: BTreeMap<&str, &LocalMod> = BTreeMap::new();
for mod_ in snapshot.builtin.iter().chain(&snapshot.mods) {
if effective_pin(snapshot, pins, &mod_.name).is_some_and(|pin| pin != mod_.version) {
continue;
}
let replace = selected.get(mod_.name.as_str()).is_none_or(|old| {
compare_versions(&mod_.version, &old.version)
.then_with(|| mod_.version.cmp(&old.version))
.then_with(|| source_rank(old.source).cmp(&source_rank(mod_.source)))
.then_with(|| old.path.cmp(&mod_.path))
.is_gt()
});
if replace {
selected.insert(&mod_.name, mod_);
}
}
selected.into_values().collect()
}
pub fn installed_versions(snapshot: &Snapshot, name: &str) -> Vec<String> {
let mut versions: Vec<_> = snapshot
.builtin
.iter()
.chain(&snapshot.mods)
.filter(|mod_| mod_.name == name)
.map(|mod_| mod_.version.clone())
.collect();
versions.sort_by(|a, b| compare_versions(b, a).then_with(|| b.cmp(a)));
versions.dedup();
versions
}
pub fn set_pin(
snapshot: &Snapshot,
pins: &Pins,
name: &str,
version: Option<String>,
) -> Result<Pins> {
let versions = installed_versions(snapshot, name);
if versions.is_empty() {
return Err(format!("Mod is not installed: {name}").into());
}
if let Some(version) = &version
&& !versions.contains(version)
{
return Err(format!("Version is not installed: {name} {version}").into());
}
let saved = snapshot
.mod_list
.mods
.iter()
.find(|entry| entry.name == name)
.and_then(|entry| entry.version.as_ref());
let mut result: Pins = pins.iter().filter(|(n, _)| n != name).cloned().collect();
if version.as_ref() != saved {
result.push((name.into(), version));
}
Ok(result)
}
fn required(dep: &Dependency) -> bool {
matches!(
dep.kind,
DependencyKind::Required | DependencyKind::NoLoadOrder
)
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Issues {
pub missing: Vec<Dependency>,
pub install_missing: Vec<Dependency>,
pub incompatible: Vec<String>,
}
/// Only names with an issue are returned. Dependency lists retain declaration order;
/// incompatibility names are sorted and deduplicated, including the reverse mark.
pub fn diagnose(snapshot: &Snapshot, pending: &Pending, pins: &Pins) -> BTreeMap<String, Issues> {
let loaded: BTreeMap<_, _> = loaded_mods(snapshot, pins)
.into_iter()
.map(|mod_| (mod_.name.as_str(), mod_))
.collect();
let mut issues: BTreeMap<String, Issues> = BTreeMap::new();
for mod_ in loaded
.values()
.filter(|mod_| enabled(snapshot, pending, &mod_.name))
{
for dep in &mod_.dependencies {
let target = loaded.get(dep.name.as_str());
let satisfied = target.is_some_and(|target| satisfies(&target.version, dep));
let active = enabled(snapshot, pending, &dep.name);
if required(dep) && (!satisfied || !active) {
let issue = issues.entry(mod_.name.clone()).or_default();
issue.missing.push(dep.clone());
if !satisfied {
issue.install_missing.push(dep.clone());
}
} else if dep.kind == DependencyKind::Incompatible && satisfied && active {
issues
.entry(mod_.name.clone())
.or_default()
.incompatible
.push(dep.name.clone());
issues
.entry(dep.name.clone())
.or_default()
.incompatible
.push(mod_.name.clone());
}
}
}
for issue in issues.values_mut() {
issue.incompatible.sort();
issue.incompatible.dedup();
}
issues
}
/// Install missing must satisfy every active parent of the selected missing names.
pub fn install_requirements(
snapshot: &Snapshot,
pending: &Pending,
pins: &Pins,
name: &str,
) -> Vec<Dependency> {
let mut requirements = diagnose(snapshot, pending, pins)
.remove(name)
.map(|issues| issues.install_missing)
.unwrap_or_default();
let names: Vec<_> = requirements.iter().map(|dep| dep.name.clone()).collect();
for mod_ in loaded_mods(snapshot, pins) {
if enabled(snapshot, pending, &mod_.name) {
for dep in &mod_.dependencies {
if required(dep) && names.contains(&dep.name) && !requirements.contains(dep) {
requirements.push(dep.clone());
}
}
}
}
requirements
}