use super::{Block, BlockError, BlockField};
pub struct BlockRegistration {
pub factory: fn() -> Box<dyn Block>,
}
inventory::collect!(BlockRegistration);
#[macro_export]
macro_rules! register_block {
($ty:ty) => {
$crate::inventory::submit! {
$crate::block::BlockRegistration {
factory: || Box::new(<$ty>::default()),
}
}
};
($factory:expr) => {
$crate::inventory::submit! {
$crate::block::BlockRegistration {
factory: $factory,
}
}
};
}
pub fn registered_blocks() -> impl Iterator<Item = Box<dyn Block>> {
inventory::iter::<BlockRegistration>
.into_iter()
.map(|r| (r.factory)())
}
#[must_use]
pub fn find_block(type_name: &str) -> Option<Box<dyn Block>> {
registered_blocks().find(|b| b.type_name() == type_name)
}
#[must_use]
pub fn duplicate_block_names() -> Vec<&'static str> {
let mut seen = std::collections::HashSet::new();
let mut dups = Vec::new();
for b in registered_blocks() {
if !seen.insert(b.type_name()) {
dups.push(b.type_name());
}
}
dups
}
pub fn check_block_references() -> Result<(), BlockError> {
let names: std::collections::HashSet<&'static str> =
registered_blocks().map(|b| b.type_name()).collect();
for block in registered_blocks() {
let owner = block.type_name();
for field in block.fields() {
match field {
BlockField::Stream { allowed, .. } => {
for ref_name in &allowed {
if !names.contains(ref_name.as_str()) {
let leaked: &'static str = Box::leak(ref_name.clone().into_boxed_str());
return Err(BlockError::DanglingReference {
owner,
referred: leaked,
});
}
}
}
BlockField::Repeat { item_type, .. } => {
if !names.contains(item_type.as_str()) {
let leaked: &'static str = Box::leak(item_type.clone().into_boxed_str());
return Err(BlockError::DanglingReference {
owner,
referred: leaked,
});
}
}
_ => {}
}
}
}
Ok(())
}
pub fn validate_block_registry() {
let dups = duplicate_block_names();
assert!(
dups.is_empty(),
"rustango_cms: duplicate block registrations: {dups:?}",
);
if let Err(e) = check_block_references() {
panic!("rustango_cms: block registry has a dangling reference: {e}");
}
}