use crate::{EntitySchema, Schema};
use std::{fmt::Write, sync::Mutex};
#[doc(hidden)]
pub use ctor as __ctor;
#[derive(Debug)]
pub enum Error {
Poisoned,
LateRegistration,
DuplicatePath(&'static str),
InvalidModule,
EmptyModule,
Schema(crate::Error),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{self:?}")
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Schema(error) => Some(error),
_ => None,
}
}
}
#[derive(Default)]
struct Registry {
nodes: Vec<(&'static str, &'static EntitySchema)>,
sealed: bool,
late: bool,
}
impl Registry {
fn register(&mut self, path: &'static str, schema: &'static EntitySchema) {
if self.sealed {
self.late = true;
} else {
self.nodes.push((path, schema));
}
}
fn generate(&mut self, source: &str, target: &str) -> Result<String, Error> {
if self.late {
return Err(Error::LateRegistration);
}
if source.is_empty() || target.is_empty() {
return Err(Error::InvalidModule);
}
self.nodes.sort_by_key(|(path, _)| *path);
if let Some(pair) = self.nodes.windows(2).find(|pair| pair[0].0 == pair[1].0) {
return Err(Error::DuplicatePath(pair[0].0));
}
let prefix = format!("{source}::");
let mut selected: Vec<_> = self
.nodes
.iter()
.filter_map(|(path, schema)| path.strip_prefix(&prefix).map(|suffix| (suffix, *schema)))
.collect();
if selected.is_empty() {
return Err(Error::EmptyModule);
}
selected.sort_by_key(|(_, schema)| schema.name);
let schema = Schema::new(
&selected
.iter()
.map(|(_, schema)| *schema)
.collect::<Vec<_>>(),
)
.map_err(Error::Schema)?;
let mut code = String::from(
"// Generated from the validated host schema; do not edit.\n\
fn compiled() -> ::ic_db::Schema {\n\
::std::thread_local! { static SCHEMA: ::ic_db::Schema = {\n\
let schema = ::ic_db::Schema::new(&[\n",
);
for (path, _) in selected {
writeln!(code, "<{target}::{path} as ::ic_db::Entity>::SCHEMA,").unwrap();
}
code.push_str("] ).expect(\"generated schema admission failed\");\n");
writeln!(
code,
"assert_eq!(schema.fingerprint(), {:?}, \"host/target schema mismatch\");",
schema.fingerprint()
)
.unwrap();
code.push_str("schema\n}; }\nSCHEMA.with(::std::clone::Clone::clone)\n}\n");
self.sealed = true;
Ok(code)
}
}
static REGISTRY: Mutex<Registry> = Mutex::new(Registry {
nodes: Vec::new(),
sealed: false,
late: false,
});
#[doc(hidden)]
pub fn __register(path: &'static str, schema: &'static EntitySchema) {
REGISTRY
.lock()
.expect("schema registration lock poisoned")
.register(path, schema);
}
pub fn generate(source_module: &str, target_module: &str) -> Result<String, Error> {
REGISTRY
.lock()
.map_err(|_| Error::Poisoned)?
.generate(source_module, target_module)
}
#[macro_export]
macro_rules! build_schema {
(src::$schema:ident) => {
$crate::build_schema!(src::$schema => main);
};
(src::$schema:ident => $function:ident) => {
mod src {
pub mod $schema;
}
pub use self::src::$schema;
$crate::build_schema!(@function $function, "::src::", $schema);
};
($schema:ident) => {
mod $schema;
$crate::build_schema!(@function main, "::", $schema);
};
(@function $function:ident, $prefix:literal, $schema:ident) => {
fn $function() -> ::std::result::Result<(), ::std::boxed::Box<dyn ::std::error::Error>> {
$crate::build::write_schema(
::std::concat!(::std::module_path!(), $prefix, ::std::stringify!($schema)),
::std::concat!("crate::", ::std::stringify!($schema)),
)
}
};
}
pub fn write_schema(
source_module: &str,
target_module: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let assembly = generate(source_module, target_module)?;
let out = std::env::var_os("OUT_DIR").ok_or_else(|| {
std::io::Error::new(std::io::ErrorKind::NotFound, "Cargo did not set OUT_DIR")
})?;
std::fs::write(std::path::PathBuf::from(out).join("schema.rs"), assembly)?;
Ok(())
}
#[cfg(test)]
mod tests;