use std::collections::BTreeSet;
use std::sync::Arc;
use super::Registry;
use crate::plugin::{GraftCut, GraftPlan};
use crate::registry_core::declaration::FrameworkId;
use crate::registry_core::declaration::RegistrationSnapshot;
use crate::registry_core::diagnostic::RegistryResult;
use crate::registry_core::identity::NodeId;
use crate::registry_core::plugin::graft::GraftError;
use crate::registry_core::release::{CutTarget, StaticGraftCut};
#[derive(Clone, Copy)]
pub(super) enum GraftTargetRef<'a> {
Path(&'a str),
Id(NodeId),
}
impl GraftTargetRef<'_> {
pub(super) fn describe(self) -> String {
match self {
Self::Path(path) => path.to_owned(),
Self::Id(id) => id.to_string(),
}
}
}
#[derive(Clone, Copy)]
pub(super) struct GraftCutRef<'a> {
pub(super) cut: GraftTargetRef<'a>,
pub(super) graft: GraftTargetRef<'a>,
pub(super) end: Option<GraftTargetRef<'a>>,
pub(super) subtree: bool,
}
impl<'a> GraftCutRef<'a> {
pub(super) fn dynamic(cut: &'a GraftCut) -> Self {
Self {
cut: GraftTargetRef::Path(&cut.cut),
graft: GraftTargetRef::Path(&cut.graft),
end: cut.end.as_deref().map(GraftTargetRef::Path),
subtree: cut.subtree,
}
}
pub(super) fn static_cut(cut: &'a StaticGraftCut) -> Self {
fn borrow(target: CutTarget) -> GraftTargetRef<'static> {
match target {
CutTarget::Path(path) => GraftTargetRef::Path(path),
CutTarget::Id(id) => GraftTargetRef::Id(id),
}
}
Self {
cut: borrow(cut.cut()),
graft: borrow(cut.graft()),
end: cut.cut_end().map(borrow),
subtree: cut.is_full(),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(super) enum Resolution {
One(NodeId),
Missing,
Ambiguous(usize),
}
impl Registry {
pub fn overlay(&self, plan: &GraftPlan, external: &Registry) -> RegistryResult<Self> {
self.overlay_cuts(
plan.framework,
plan.cuts.iter().map(GraftCutRef::dynamic),
external,
)
}
pub fn overlay_static(
&self,
cuts: &[StaticGraftCut],
external: &Registry,
) -> RegistryResult<Self> {
self.overlay_cuts(
self.header.framework,
cuts.iter().map(GraftCutRef::static_cut),
external,
)
}
pub(super) fn overlay_cuts<'a>(
&self,
framework: FrameworkId,
cuts: impl IntoIterator<Item = GraftCutRef<'a>>,
external: &Registry,
) -> RegistryResult<Self> {
if framework != self.header.framework || external.header.framework != framework {
return Err(self.graft_error(self.header.id, GraftError::FrameworkMismatch(framework)));
}
let mut staged = self.clone();
let mut seen = BTreeSet::new();
for cut in cuts {
let replacement = match cut.graft {
GraftTargetRef::Path(value) => match external.resolve_node(value) {
Resolution::One(id) => Some(id),
Resolution::Missing => None,
Resolution::Ambiguous(matches) => {
return Err(staged.graft_error(
staged.header.id,
GraftError::AmbiguousReplacement {
selector: value.to_owned(),
matches,
},
));
}
},
GraftTargetRef::Id(id) => external.find_registry(id).map(|_| id),
}
.ok_or_else(|| {
staged.graft_selector_error(
staged.header.id,
GraftError::UnknownReplacement(staged.header.id),
format!(
"graft replacement `{}` is not registered",
cut.graft.describe()
),
)
})?;
let replacement = external
.find_registry(replacement)
.expect("resolve_node returned a registered external face");
for target in staged.resolve_cut_targets(cut)? {
if !seen.insert(target) {
return Err(
staged.graft_error(target, GraftError::DuplicateCut(cut.cut.describe()))
);
}
staged.apply_overlay_face(target, replacement, cut.subtree, external)?;
}
}
if let Some(error) = staged.connector_error_with_external(Some(external)) {
return Err(error.into());
}
Ok(staged)
}
fn apply_overlay_face(
&mut self,
target: NodeId,
replacement: &RegistrationSnapshot,
replace_subtree: bool,
external: &Registry,
) -> RegistryResult<()> {
let target_info = self
.find_registry(target)
.cloned()
.ok_or_else(|| self.graft_error(target, GraftError::UnknownTarget(target)))?;
if !replacement.flow.is_declared() || !target_info.flow.is_declared() {
return Err(self.graft_error(target, GraftError::ContractUndeclared));
}
if !replacement
.flow
.semantically_compatible_with(&target_info.flow)
{
return Err(self.graft_error(
target,
GraftError::ContractMismatch {
expected: target_info.flow.clone(),
received: replacement.flow.clone(),
},
));
}
let parent = self.registry(target_info.parent).ok_or_else(|| {
self.graft_error(target, GraftError::UnknownTarget(target_info.parent))
})?;
let parent_path = parent.header.path.clone();
let mut candidate = replacement.clone();
candidate.id = target_info.id;
candidate.parent = target_info.parent;
candidate.registry_name = target_info.registry_name.clone();
let failures = parent
.header
.registration_rule
.validate_owned_registration_rule(&candidate);
if !failures.is_empty() {
let mut error = self.graft_error(
target,
GraftError::ContractMismatch {
expected: target_info.flow.clone(),
received: replacement.flow.clone(),
},
);
*error.message_mut() = format!(
"graft overlay rejected by destination rule: {}",
failures.join("; ")
);
return Err(error);
}
let Some(owner) = self.registry_mut(target_info.parent) else {
return Err(self.graft_error(target, GraftError::UnknownTarget(target_info.parent)));
};
let Some(entry) = Arc::make_mut(&mut owner.entries).get_mut(&target) else {
return Err(self.graft_error(target, GraftError::UnknownTarget(target)));
};
let child = if replace_subtree {
let mut child = external
.entry_at(replacement.id)
.and_then(|entry| entry.child.clone());
if let Some(registry) = &mut child {
let old_path = registry.header.path.clone();
let new_path = format!("{}/{}", parent_path, target_info.registry_name);
let child = Arc::make_mut(registry);
child.reconfigure(&candidate);
child.rebase_parent_ids(replacement.id, target_info.id);
child.rebase_paths(&old_path, &new_path);
}
child
} else {
let mut kept = entry.child.clone();
if let Some(registry) = kept.as_ref()
&& !child_registry_can_survive(candidate.needs_registry, Some(registry))
{
let mut error = self.graft_error(
target,
GraftError::ContractMismatch {
expected: target_info.flow.clone(),
received: replacement.flow.clone(),
},
);
let child_path = ®istry.header.path;
*error.message_mut() = format!(
"graft overlay would leave a non-empty child registry on `{child_path}`, which declares no registry"
);
return Err(error);
}
if !candidate.needs_registry {
kept = None;
} else if let Some(registry) = &mut kept {
let registry = Arc::make_mut(registry);
registry.reconfigure(&candidate);
if let Some(violation) =
registry.child_violating(candidate.id, &candidate.registry_rule)
{
let mut error = self.graft_error(
target,
GraftError::ContractMismatch {
expected: target_info.flow.clone(),
received: replacement.flow.clone(),
},
);
*error.message_mut() = format!(
"graft overlay would leave an existing child violating the new rule: {violation}"
);
return Err(error);
}
}
kept
};
entry.info = Arc::new(candidate);
entry.child = child;
Ok(())
}
}
pub(super) fn child_registry_can_survive(
needs_registry: bool,
child: Option<&Arc<Registry>>,
) -> bool {
needs_registry || child.is_none_or(|registry| registry.entries.is_empty())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::registry_core::declaration::RegistrationRule;
use super::super::fixtures::{FRAMEWORK, face, flow};
#[test]
fn a_non_full_graft_does_not_install_a_rule_its_children_violate() {
let namespace = "rule-graft";
let mut root = Registry::root_for_namespace(FRAMEWORK, namespace);
let mut owner = face(namespace, "owner.rs", "Owner", "owner");
owner.needs_registry = true;
owner.id = NodeId::from_namespaced_path(namespace, "owner.rs", "Owner");
let mut child = face(namespace, "child.rs", "Child", "child");
child.parent = owner.id;
child.exports = vec!["x".to_owned()];
root.register_snapshot_batch([owner.clone(), child.clone()])
.unwrap();
let mut replacement = face("external", "replacement.rs", "Replacement", "replacement");
replacement.id = NodeId::from_namespaced_path("external", "replacement.rs", "Replacement");
replacement.needs_registry = true;
replacement.registry_rule = RegistrationRule {
required_exports: &["z"],
..RegistrationRule::ANY
}
.into_owned();
let mut external = Registry::root_for_namespace(FRAMEWORK, "external");
external
.register_snapshot_batch([replacement.clone()])
.unwrap();
let plan = GraftPlan::new(FRAMEWORK).cut("root/owner", "replacement");
let error = root
.overlay(&plan, &external)
.expect_err("a kept child that violates the new rule must refuse the graft");
let rendered = format!("{error}");
assert!(rendered.contains("violating the new rule"), "{rendered}");
}
#[test]
fn overlay_keeps_base_siblings_and_source_trees_untouched() {
let namespace = "overlay";
let mut root = Registry::root_for_namespace(FRAMEWORK, namespace);
let mut a = face(namespace, "a.rs", "A", "a");
a.needs_registry = true;
a.id = NodeId::from_namespaced_path(namespace, "a.rs", "A");
let mut a1 = face(namespace, "a1.rs", "A1", "a1");
a1.parent = a.id;
let a2 = {
let mut value = face(namespace, "a2.rs", "A2", "a2");
value.parent = a.id;
value
};
let mut original = face("external", "original.rs", "Original", "replacement");
original.id = NodeId::from_namespaced_path("external", "original.rs", "Original");
original.flow = flow("render.v1");
let mut external = Registry::root_for_namespace(FRAMEWORK, "external");
root.register_snapshot_batch([a.clone(), a1.clone(), a2.clone()])
.unwrap();
external
.register_snapshot_batch([original.clone()])
.unwrap();
let plan = GraftPlan::new(FRAMEWORK).cut("root/a/a1", "replacement");
let effective = root.overlay(&plan, &external).unwrap();
let effective_static = root
.overlay_static(
&[StaticGraftCut::new("root/a/a1", "replacement", false)],
&external,
)
.unwrap();
assert_eq!(effective.find_kind("Original").len(), 1);
assert_eq!(effective_static.find_kind("Original").len(), 1);
assert_eq!(effective.path_for(a2.id).as_deref(), Some("root/a/a2"));
assert_eq!(
root.find_registry(a1.id).map(|item| item.kind.as_str()),
Some("A1")
);
assert_eq!(
external
.find_registry(original.id)
.map(|item| item.kind.as_str()),
Some("Original")
);
assert_eq!(effective.path_for(a1.id).as_deref(), Some("root/a/a1"));
}
#[test]
fn an_unknown_replacement_names_the_selector() {
let namespace = "unknown-replacement";
let mut root = Registry::root_for_namespace(FRAMEWORK, namespace);
let mut target = face(namespace, "a.rs", "A", "a");
target.flow = flow("render.v1");
root.register_snapshot_batch([target]).unwrap();
let external = Registry::root_for_namespace(FRAMEWORK, "external");
let plan = GraftPlan::new(FRAMEWORK).cut("root/a", "absent_replacement");
let error = root
.overlay(&plan, &external)
.expect_err("an absent replacement must be refused");
let rendered = format!("{error}");
assert!(rendered.contains("absent_replacement"), "{rendered}");
assert!(rendered.contains("graft replacement"), "{rendered}");
}
#[test]
fn the_effective_tree_dumps_through_the_overlay_result() {
let namespace = "effective-dump";
let mut root = Registry::root_for_namespace(FRAMEWORK, namespace);
let mut target = face(namespace, "a.rs", "A", "a");
target.flow = flow("render.v1");
root.register_snapshot_batch([target]).unwrap();
let mut external = Registry::root_for_namespace(FRAMEWORK, "external");
let mut replacement = face("external", "b.rs", "B", "replacement");
replacement.flow = flow("render.v1");
external.register_snapshot_batch([replacement]).unwrap();
let dump = root
.dump_effective(
&[StaticGraftCut::new("root/a", "replacement", false)],
&external,
)
.expect("the overlay applies");
assert!(dump.contains("kind=B"), "{dump}");
assert!(dump.contains("path=root/a"), "{dump}");
assert!(root.dump().contains("kind=A"), "base tree untouched");
assert!(
external.dump().contains("kind=B"),
"external tree untouched"
);
}
}