use quote::quote;
use super::{DatabaseKind, EnumModel, EnumVariant};
#[cfg(test)]
mod tests;
impl EnumModel {
pub(super) fn emit_open(&self, escape: &EnumVariant) -> proc_macro2::TokenStream {
let markers = self.markers();
let face = self.open_face(escape);
let parsing = self.open_parsing();
let cursor = self.open_cursor();
let key = self.key_delegation();
let width = self.width_row();
let read = self.read_row();
let storage = DatabaseKind::ALL
.into_iter()
.map(|database| self.open_storage(database));
let wire = self.scalar_wire();
quote! {
const _: () = {
#markers
#face
#parsing
#cursor
#key
#width
#read
#(#storage)*
};
#wire
}
}
fn open_face(&self, escape: &EnumVariant) -> proc_macro2::TokenStream {
let vis = &self.vis;
let name = &self.name;
let escaped = &escape.ident;
let folds_to = self.framework(&["name"], "folds_to");
let folded = self.framework(&["name"], "folded");
let roster = self.restated().map(|variant| {
let ident = &variant.ident;
quote!(Self::#ident)
});
let doors = self.restated().map(|variant| {
let ident = &variant.ident;
let word = variant.folded();
quote! {
if #folds_to(__ingraph_word, #word) {
return Self::#ident;
}
}
});
let words = self.restated().map(|variant| {
let ident = &variant.ident;
let word = variant.folded();
quote!(Self::#ident => #word,)
});
let predicates = self.variants.iter().map(|variant| self.predicate(variant));
let roster_doc = format!(
"Every word [`{name}`] NAMES, in declaration order.\n\nThe escape is absent: it carries a \
word rather than a name, so it is no constant. This is the list a client reads to learn what \
it may ask for, and a word meaning *something else* is not one of them."
);
let door_doc = format!(
"Read a word in ANY spelling.\n\nTOTAL — there is no refusal, a word this roster does not \
name riding [`{name}::{escaped}`] with its FOLDED spelling. ASCII case and `_`, `-` and a \
space are ignored, so `leftShoulder`, `left_shoulder`, `LEFT-SHOULDER` and `Left Shoulder` \
are one value."
);
let word_doc = format!(
"This value's CANONICAL word — what a column holds, a cursor carries and a client \
reads.\n\nFor a named member it is the declaration's own spelling; for [`{name}::{escaped}`] \
it is the folded word that variant carries."
);
quote! {
#[automatically_derived]
impl #name {
#[doc = #roster_doc]
#vis const VARIANTS: &'static [Self] = &[#(#roster),*];
#[doc = #door_doc]
#[must_use]
#vis fn new(__ingraph_word: &::core::primitive::str) -> Self {
#(#doors)*
Self::#escaped(::core::convert::Into::into(
::std::string::String::as_str(&#folded(__ingraph_word)),
))
}
#[doc = #word_doc]
#[must_use]
#vis fn as_str(&self) -> &::core::primitive::str {
match self {
#(#words)*
Self::#escaped(__ingraph_word) => {
::core::convert::AsRef::<::core::primitive::str>::as_ref(__ingraph_word)
}
}
}
#(#predicates)*
}
}
}
fn open_parsing(&self) -> proc_macro2::TokenStream {
let name = &self.name;
quote! {
#[automatically_derived]
impl ::core::fmt::Display for #name {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, #name::as_str(self))
}
}
#[automatically_derived]
impl ::core::str::FromStr for #name {
type Err = ::core::convert::Infallible;
#[inline]
fn from_str(
text: &::core::primitive::str,
) -> ::core::result::Result<Self, Self::Err> {
::core::result::Result::Ok(#name::new(text))
}
}
}
}
fn open_cursor(&self) -> proc_macro2::TokenStream {
let name = &self.name;
self.word_cursor(
"e!(::core::primitive::str::as_bytes(#name::as_str(self))),
"e!(::core::option::Option::Some(#name::new(text))),
)
}
fn open_storage(&self, database: DatabaseKind) -> proc_macro2::TokenStream {
let name = &self.name;
self.text_storage(
database,
"e!(::std::string::String::from(#name::as_str(self))),
"e!(::core::option::Option::Some(#name::new(stored))),
)
}
}