use std::collections::BTreeMap;
use super::{program::approved_base, GateError, GateSnapshot, Result};
use crate::config_store::{CommitKind, StoreBody};
pub(super) const REVIEWED_PROGRAMS: &str = "reviewed_programs";
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Rereview {
WaitingForProgram,
Ready,
}
pub(super) fn identity(snapshot: &GateSnapshot, module: &str) -> String {
approved_base(snapshot, module).as_str().to_owned()
}
pub(super) fn recorded(body: &StoreBody) -> Result<BTreeMap<String, String>> {
let Some(record) = body
.generations
.values()
.rev()
.find(|entry| entry.kind != CommitKind::Development)
.and_then(|entry| entry.generation.changeset.apply_plan.get(REVIEWED_PROGRAMS))
else {
return Ok(BTreeMap::new());
};
serde_json::from_value(record.clone()).map_err(GateError::invalid)
}
pub(super) fn active(body: &StoreBody, module: &str) -> Result<Option<String>> {
let Some(entry) = body
.versions
.iter()
.find(|(tuple, _)| tuple.module == module && tuple.project.is_none())
.and_then(|(_, versions)| versions.active)
.and_then(|id| body.generations.get(&id))
else {
return Ok(None);
};
let snapshot = GateSnapshot::from_store(&entry.configuration)?;
Ok(Some(identity(&snapshot, module)))
}
pub(super) fn pending<'a>(
body: &StoreBody,
modules: impl IntoIterator<Item = &'a String>,
) -> Result<BTreeMap<String, Rereview>> {
let approved = GateSnapshot::from_store(&body.approved)?;
let recorded = recorded(body)?;
let mut pending = BTreeMap::new();
for module in modules {
let program = identity(&approved, module);
if recorded.get(module) == Some(&program) {
continue;
}
let state = if active(body, module)?.as_ref() == Some(&program) {
Rereview::Ready
} else {
Rereview::WaitingForProgram
};
pending.insert(module.clone(), state);
}
Ok(pending)
}