use heck::ToUpperCamelCase as _;
use quote::{format_ident, quote};
use crate::model::{Derived, Field, RecordModel, Through};
impl RecordModel {
pub(crate) fn relations(&self) -> proc_macro2::TokenStream {
let equations = self.fields.iter().filter_map(|field| {
let reference = field.reference.as_ref()?;
let refers_to = self.framework(&["transform"], "refers_to");
let value = self.referring_value(field);
let target = &reference.target;
Some(quote!(const _: fn() = #refers_to::<#value, #target>;))
});
let pairs = self.pairs().into_iter().map(|(target, fields)| {
let record = &self.record;
let related = self.framework(&["transform"], "Related");
let marker = self.framework(&["transform"], "Reference");
let field_name = self.framework(&["field"], "FieldName");
let artifacts: Vec<syn::Ident> = fields
.iter()
.map(|field| self.artifact(&field.column.source))
.collect();
let names: Vec<String> = fields
.iter()
.map(|field| field.column.source.to_string())
.collect();
let vis = &self.vis;
quote! {
#(
#[derive(::core::fmt::Debug)]
#vis struct #artifacts(());
#[automatically_derived]
impl #marker for #artifacts {}
)*
#[automatically_derived]
impl #related<#target> for #record {
type Fields = (#(#artifacts,)*);
const COLUMNS: &'static [&'static #field_name] = &[#(#field_name::new(#names)),*];
}
}
});
let reverse = self.derived.iter().map(|entry| self.audit(entry));
let memberships = self.implements.iter().map(|interface| {
let record = &self.record;
let implements = self.framework(&["transform"], "Implements");
quote! {
#[automatically_derived]
impl #implements<#interface> for #record {}
}
});
quote! {
#(#equations)*
#(#pairs)*
#(#reverse)*
#(#memberships)*
}
}
fn pairs(&self) -> Vec<(&syn::Path, Vec<&Field>)> {
let mut pairs: Vec<(&syn::Path, Vec<&Field>)> = Vec::new();
for field in &self.fields {
let Some(reference) = &field.reference else {
continue;
};
let spelling = tight(&reference.target);
match pairs
.iter_mut()
.find(|(target, _)| tight(target) == spelling)
{
Some((_, fields)) => fields.push(field),
None => pairs.push((&reference.target, vec![field])),
}
}
pairs
}
fn referring_value(&self, field: &Field) -> proc_macro2::TokenStream {
let ty = &field.column.ty;
if field
.reference
.as_ref()
.is_none_or(|reference| reference.through == Through::Value)
{
return quote!(#ty);
}
let state = self.framework(&["state"], "State");
let extracted = self.framework(&["state"], "Extracted");
let inner = self.framework(&["state"], "Inner");
quote!(<#ty as #state<#extracted<#inner>>>::Output)
}
fn audit(&self, entry: &Derived) -> proc_macro2::TokenStream {
let record = &self.record;
let source = &entry.source;
let Some(field) = &entry.field else {
let one = self.framework(&["transform"], "one_field_points_back");
return quote!(const _: fn() = #one::<#source, #record>;);
};
let related = self.framework(&["transform"], "Related");
let refers_through = self.framework(&["transform"], "refers_through");
let named = field.value();
let why = format!(
"`{source}` declares no `ref` field called `{named}` naming `{record}` — \
`derived({position}(type = \"…\", field = \"…\"))` selects one of the SOURCE's own `ref` \
fields, and the source's declaration is where they are written",
source = tight(source),
position = entry.name,
);
quote::quote_spanned! {field.span()=>
const _: () = ::core::assert!(
#refers_through(<#source as #related<#record>>::COLUMNS, #named),
#why
);
}
}
pub(crate) fn artifact(&self, field: &syn::Ident) -> syn::Ident {
format_ident!(
"{record}{field}Ref",
record = self.record,
field = field.to_string().to_upper_camel_case(),
)
}
}
fn tight(path: &syn::Path) -> String {
quote!(#path).to_string().replace(' ', "")
}