use std::collections::BTreeMap;
use quote::ToTokens;
use super::{EnumModel, EnumVariant};
use crate::enumeration::{Escape, Namespace, StorageForm};
fn roster() -> EnumModel {
let mut model = closed();
model.variants.push(EnumVariant {
ident: ident("Other"),
rename: None,
names: BTreeMap::new(),
upstream: None,
escape: Some(Escape::Total),
carrier: Some(syn::parse_quote!(::ingraph::Utf8Bytes)),
});
model
}
fn closed() -> EnumModel {
EnumModel {
krate: syn::parse_quote!(::ingraph),
vis: syn::parse_quote!(pub),
name: ident("BodyJoint"),
width: None,
variants: vec![variant("Nose", None), variant("LeftShoulder", None)],
forms: BTreeMap::new(),
wire_name: None,
error: None,
remote: None,
}
}
fn variant(name: &str, rename: Option<&str>) -> EnumVariant {
EnumVariant {
ident: ident(name),
rename: rename.map(ToOwned::to_owned),
names: BTreeMap::new(),
upstream: None,
escape: None,
carrier: None,
}
}
fn ident(name: &str) -> syn::Ident {
syn::parse_str(name).expect("an identifier")
}
fn emission(model: &EnumModel) -> syn::File {
syn::parse2(model.emit()).expect("the expansion parses")
}
fn squashed(model: &EnumModel) -> String {
model.emit().to_string().replace(' ', "")
}
fn squash(printable: &impl ToTokens) -> String {
printable.to_token_stream().to_string().replace(' ', "")
}
const CARRIES: &str = "__IngraphCarriesAWord";
fn split_off_the_key_row(model: &EnumModel) -> (String, String) {
fn belongs_to_the_key_row(stmt: &syn::Stmt) -> bool {
match stmt {
syn::Stmt::Item(syn::Item::Impl(item)) => item.trait_.as_ref().is_some_and(|(path, _)| {
path
.segments
.last()
.is_some_and(|last| last.ident == "DelegatesId" || last.ident == CARRIES)
}),
syn::Stmt::Item(syn::Item::Trait(item)) => item.ident == CARRIES,
_ => false,
}
}
let (mut key, mut rest) = (String::new(), String::new());
for item in emission(model).items {
let syn::Item::Const(block) = &item else {
rest.push_str(&squash(&item));
continue;
};
let syn::Expr::Block(body) = &*block.expr else {
rest.push_str(&squash(&item));
continue;
};
for stmt in &body.block.stmts {
if belongs_to_the_key_row(stmt) {
key.push_str(&squash(stmt));
} else {
rest.push_str(&squash(stmt));
}
}
}
(key, rest)
}
#[test]
fn a_declared_open_word_defaults_to_the_lower_case_household() {
assert_eq!(variant("LeftShoulder", None).folded(), "left_shoulder");
assert_eq!(
variant("Gs1DataBarExpanded", None).folded(),
"gs1_data_bar_expanded"
);
assert_eq!(variant("Code39Checksum", None).folded(), "code39_checksum");
assert_eq!(variant("Qr", None).folded(), "qr");
assert_eq!(variant("Code93i", None).folded(), "code93i");
}
#[test]
fn a_rename_is_the_word_and_the_fold_is_not_applied_to_it() {
assert_eq!(variant("Code93i", Some("code_93i")).folded(), "code_93i");
assert_eq!(variant("Nose", Some("NOSE")).folded(), "NOSE");
}
#[test]
fn the_closed_cell_still_spells_its_variants_verbatim() {
let rendered = squashed(&closed());
assert!(rendered.contains(r#""LeftShoulder""#), "{rendered}");
assert!(
rendered.contains(r#""LEFT_SHOULDER""#),
"and SHOUTS on the wire: {rendered}"
);
assert!(!rendered.contains(r#""left_shoulder""#), "{rendered}");
assert!(rendered.contains("BodyJointParseError"), "{rendered}");
}
#[test]
fn the_emitted_door_calls_the_one_fold_and_carries_no_copy_of_it() {
let rendered = squashed(&roster());
assert!(
rendered.contains("::ingraph::__private::name::folds_to(__ingraph_word,\"nose\")"),
"{rendered}"
);
assert!(
rendered.contains("::ingraph::__private::name::folds_to(__ingraph_word,\"left_shoulder\")"),
"{rendered}"
);
assert!(
rendered.contains("::ingraph::__private::name::folded(__ingraph_word)"),
"the escape carries a FOLDED word: {rendered}"
);
assert!(
!rendered.contains("eq_ignore_ascii_case"),
"and the relation itself is nowhere in the expansion: {rendered}"
);
}
#[test]
fn the_roster_is_walked_in_order_and_the_escape_is_what_is_left() {
let rendered = squashed(&roster());
let nose = rendered
.find(r#"folds_to(__ingraph_word,"nose")"#)
.expect("the first member");
let shoulder = rendered
.find(r#"folds_to(__ingraph_word,"left_shoulder")"#)
.expect("the second member");
let escape = rendered
.find("Self::Other(::core::convert::Into::into")
.expect("the escape");
assert!(nose < shoulder, "{rendered}");
assert!(shoulder < escape, "{rendered}");
}
#[test]
fn the_carrier_is_reached_through_the_conversion_pair_and_spelled_only_by_the_key_row() {
let (key, rest) = split_off_the_key_row(&roster());
assert!(rest.contains("::core::convert::Into::into("), "{rest}");
assert!(
rest.contains("::core::convert::AsRef::<::core::primitive::str>::as_ref(__ingraph_word)"),
"{rest}"
);
assert!(!rest.contains("Utf8Bytes"), "{rest}");
assert!(!rest.contains("SmolStr"), "{rest}");
assert!(
key.contains("typeInner=::ingraph::Utf8Bytes;"),
"the one row that names the carrier names the DECLARATION's own type: {key}"
);
}
#[test]
fn the_open_vocabulary_delegates_the_face_word_and_the_carried_one() {
let (key, _) = split_off_the_key_row(&roster());
assert!(
key.contains("unsafeimpl::ingraph::__private::id::DelegatesIdforBodyJoint"),
"{key}"
);
assert!(key.contains("typeInner=::ingraph::Utf8Bytes;"), "{key}");
for word in ["\"nose\"", "\"left_shoulder\""] {
assert!(
key.contains(&format!(
"<::ingraph::Utf8Bytesas__IngraphCarriesAWord>::__ingraph_word({word})"
)),
"{word}: {key}"
);
}
assert!(
key.contains("Self::Other(__ingraph_word)=>__ingraph_word,"),
"the escape delegates the word it CARRIES, borrowed rather than rebuilt: {key}"
);
}
#[test]
fn the_carrier_obligation_is_declared_beside_the_row_that_spends_it() {
let (key, rest) = split_off_the_key_row(&roster());
assert!(key.contains("trait__IngraphCarriesAWord"), "{key}");
assert!(key.contains("#[diagnostic::do_not_recommend]"), "{key}");
assert!(
key.contains("cannotcarryan`#[ingraph(other)]`escape'sword"),
"{key}"
);
assert!(
key.contains(
"impl<T:::core::convert::From<&'static::core::primitive::str>>__IngraphCarriesAWordforT"
),
"the obligation IS the door's own conversion, wearing a name: {key}"
);
assert!(
!rest.contains("__IngraphCarriesAWord"),
"and nothing outside the key row spends it: {rest}"
);
}
#[test]
fn an_escape_only_vocabulary_keys_by_its_word_and_asks_for_no_obligation() {
let mut model = roster();
model.variants.retain(|variant| variant.escape.is_some());
let (key, _) = split_off_the_key_row(&model);
assert!(
key.contains("Self::Other(__ingraph_word)=>__ingraph_word,"),
"{key}"
);
assert!(!key.contains("__IngraphCarriesAWord"), "{key}");
assert!(!key.contains("LazyLock"), "{key}");
}
#[test]
fn an_escape_with_no_recorded_carrier_costs_the_key_row_and_nothing_else() {
let mut model = roster();
model
.variants
.last_mut()
.expect("the escape")
.carrier
.take();
let (key, rest) = split_off_the_key_row(&model);
assert!(key.is_empty(), "{key}");
let (_, whole) = split_off_the_key_row(&roster());
assert_eq!(rest, whole, "every other row stands as it stood");
}
#[test]
fn an_open_vocabulary_declares_no_refusal_type() {
let model = roster();
assert!(!model.refuses());
let rendered = squashed(&model);
assert!(
rendered.contains("typeErr=::core::convert::Infallible;"),
"{rendered}"
);
assert!(!rendered.contains("ParseError"), "{rendered}");
assert!(
!emission(&model)
.items
.iter()
.any(|item| matches!(item, syn::Item::Struct(_))),
"nothing at all stands beside the enum: {rendered}"
);
}
#[test]
fn variants_lists_the_named_members_alone() {
let rendered = squashed(&roster());
assert!(
rendered.contains("VARIANTS:&'static[Self]=&[Self::Nose,Self::LeftShoulder]"),
"{rendered}"
);
assert!(
rendered.contains("fnis_other(&self)"),
"and the escape still has its predicate: {rendered}"
);
assert!(rendered.contains("Self::Other(..)"), "{rendered}");
}
#[test]
fn an_open_vocabulary_publishes_a_scalar_and_a_closed_one_an_enum() {
let open = squashed(&roster());
assert!(open.contains("Scalar(crate="), "{open}");
assert!(open.contains("name=\"BodyJoint\""), "{open}");
assert!(!open.contains("MetaTypeId::Enum"), "{open}");
assert!(!open.contains("EnumItem"), "{open}");
let closed = squashed(&closed());
assert!(closed.contains("MetaTypeId::Enum"), "{closed}");
assert!(closed.contains("EnumItem"), "{closed}");
assert!(!closed.contains("Scalar(crate="), "{closed}");
}
#[test]
fn an_open_vocabulary_stores_its_word_and_reads_a_stranger_s_spelling_back() {
let rendered = squashed(&roster());
assert!(
rendered.contains("::std::string::String::from(BodyJoint::as_str(self))"),
"{rendered}"
);
assert!(
rendered.contains("::core::option::Option::Some(BodyJoint::new(stored))"),
"{rendered}"
);
assert!(
!rendered.contains("__ingraph_sqlite_stored"),
"and no discriminant is stored anywhere: {rendered}"
);
}
#[test]
fn the_cursor_carries_the_canonical_word_and_reads_it_through_the_door() {
let rendered = squashed(&roster());
assert!(
rendered.contains("::core::primitive::str::as_bytes(BodyJoint::as_str(self))"),
"{rendered}"
);
assert!(
rendered.contains("::core::option::Option::Some(BodyJoint::new(text))"),
"{rendered}"
);
}
#[test]
fn the_three_interpretation_rows_are_the_same_ones_every_mode_earns() {
let rendered = squashed(&roster());
for row in [
"EnumFilterMarker",
"DefaultMarker",
"DefaultVecMarker",
"ColumnKind",
"Assemble",
"CursorValue",
] {
assert!(rendered.contains(row), "{row}: {rendered}");
}
}
#[test]
fn an_open_vocabulary_has_one_word_and_therefore_one_accessor() {
let rendered = squashed(&roster());
assert!(rendered.contains("fnas_str(&self)"), "{rendered}");
for absent in [
"as_sqlite_str",
"as_graphql_str",
"GraphqlName",
"TryFrom<&",
] {
assert!(!rendered.contains(absent), "{absent}: {rendered}");
}
}
#[test]
fn a_form_in_the_model_moves_no_token_of_an_open_expansion() {
let mut declared = roster();
declared
.forms
.insert(Namespace::Sqlite, StorageForm::Integer);
declared
.forms
.insert(Namespace::Graphql, StorageForm::Integer);
assert_eq!(squashed(&declared), squashed(&roster()));
}