use std::collections::BTreeMap;
use quote::ToTokens as _;
use super::{EnumModel, EnumVariant, IntegerWidth, Namespace, StorageForm};
fn codec() -> EnumModel {
EnumModel {
krate: syn::parse_quote!(::ingraph),
vis: syn::parse_quote!(pub),
name: ident("Codec"),
width: None,
variants: vec![variant("H264"), variant("Vp9"), variant("Tape")],
forms: BTreeMap::new(),
wire_name: None,
error: None,
remote: None,
}
}
fn variant(name: &str) -> EnumVariant {
EnumVariant {
ident: ident(name),
rename: None,
names: BTreeMap::new(),
upstream: None,
escape: None,
carrier: None,
}
}
fn ident(name: &str) -> syn::Ident {
syn::Ident::new(name, proc_macro2::Span::call_site())
}
fn emission(model: &EnumModel) -> syn::File {
syn::parse2(model.emit()).expect("the expansion parses")
}
fn rendered(model: &EnumModel) -> String {
prettyplease::unparse(&emission(model))
}
fn is_gate(path: &syn::Path) -> bool {
path
.segments
.iter()
.skip_while(|segment| segment.ident != "__private")
.nth(1)
.is_some_and(|segment| segment.ident == "gate")
}
fn blocks(file: &syn::File) -> Vec<Vec<syn::Stmt>> {
file
.items
.iter()
.filter_map(|item| match item {
syn::Item::Const(anonymous) if anonymous.ident == "_" => Some(&anonymous.expr),
_ => None,
})
.map(|block| {
let syn::Expr::Block(block) = block.as_ref() else {
panic!("the const's value is a block");
};
block.block.stmts.clone()
})
.collect()
}
fn body(file: &syn::File) -> Vec<syn::Stmt> {
blocks(file).swap_remove(0)
}
fn wire(file: &syn::File) -> Vec<syn::Stmt> {
let mut blocks = blocks(file);
assert_eq!(blocks.len(), 2, "the expansion is two anonymous consts");
blocks.swap_remove(1)
}
fn ungated_traits(model: &EnumModel) -> Vec<String> {
body(&emission(model))
.iter()
.filter_map(|stmt| match stmt {
syn::Stmt::Item(syn::Item::Impl(item)) => item.trait_.as_ref(),
_ => None,
})
.map(|(path, _)| tight(path))
.collect()
}
fn gated(model: &EnumModel) -> Vec<(String, Vec<String>)> {
body(&emission(model))
.iter()
.filter_map(|stmt| match stmt {
syn::Stmt::Macro(gate) if is_gate(&gate.mac.path) => Some(&gate.mac),
_ => None,
})
.map(|gate| {
let held: syn::File = syn::parse2(gate.tokens.clone()).expect("a gate holds parsable items");
let traits = held
.items
.iter()
.filter_map(|item| match item {
syn::Item::Impl(item) => item.trait_.as_ref().map(|(path, _)| tight(path)),
_ => None,
})
.collect();
(
gate
.path
.segments
.last()
.expect("a path has a last segment")
.ident
.to_string(),
traits,
)
})
.collect()
}
fn inside(model: &EnumModel, gate: &str) -> String {
body(&emission(model))
.iter()
.find_map(|stmt| match stmt {
syn::Stmt::Macro(item)
if is_gate(&item.mac.path)
&& item
.mac
.path
.segments
.last()
.is_some_and(|segment| segment.ident == gate) =>
{
Some(item.mac.tokens.to_string())
}
_ => None,
})
.unwrap_or_else(|| panic!("no `{gate}` group"))
}
fn methods(model: &EnumModel) -> Vec<String> {
body(&emission(model))
.iter()
.filter_map(|stmt| match stmt {
syn::Stmt::Item(syn::Item::Impl(item)) if item.trait_.is_none() => Some(&item.items),
_ => None,
})
.flatten()
.filter_map(|item| match item {
syn::ImplItem::Fn(item) => Some(item.sig.ident.to_string()),
syn::ImplItem::Const(item) => Some(item.ident.to_string()),
_ => None,
})
.collect()
}
fn tight(path: &syn::Path) -> String {
path
.segments
.last()
.expect("a path has a last segment")
.ident
.to_string()
}
#[test]
fn the_expansion_declares_only_the_refusal_a_parse_answers_with() {
let file = emission(&codec());
assert_eq!(
declared_structs(&file),
["CodecParseError"],
"{:?}",
file.to_token_stream()
);
assert_eq!(
file
.items
.iter()
.filter(|item| matches!(item, syn::Item::Const(_)))
.count(),
2,
"the storage block and the gated wire block"
);
}
fn declared_structs(file: &syn::File) -> Vec<String> {
file
.items
.iter()
.filter_map(|item| match item {
syn::Item::Struct(item) => Some(item.ident.to_string()),
_ => None,
})
.collect()
}
#[test]
fn the_declared_name_is_what_the_whole_expansion_calls_the_refusal() {
let mut model = codec();
model.forms.insert(Namespace::Sqlite, StorageForm::Text);
model.error = Some(ident("NoSuchCodec"));
assert_eq!(model.error(), "NoSuchCodec");
assert_eq!(declared_structs(&emission(&model)), ["NoSuchCodec"]);
let rendered = rendered(&model);
assert!(rendered.contains("type Err = NoSuchCodec;"), "{rendered}");
assert!(rendered.contains("type Error = NoSuchCodec;"), "{rendered}");
assert!(!rendered.contains("CodecParseError"), "{rendered}");
}
#[test]
fn a_renamed_refusal_still_names_the_vocabulary_in_its_message() {
const SENTENCE: &str = r#""`Codec`: no variant answers to this name""#;
assert!(rendered(&codec()).contains(SENTENCE));
let mut model = codec();
model.error = Some(ident("NoSuchCodec"));
assert!(rendered(&model).contains(SENTENCE), "{}", rendered(&model));
}
#[test]
fn a_declaration_that_says_nothing_stores_the_discriminant_everywhere() {
let model = codec();
assert_eq!(
gated(&model),
vec![
("if_sqlx".to_owned(), vec!["Assemble".to_owned()]),
(
"if_sqlite".to_owned(),
vec![
"Type".to_owned(),
"Encode".to_owned(),
"Decode".to_owned(),
"StoredAs".to_owned(),
"Carrier".to_owned()
]
),
(
"if_postgres".to_owned(),
vec![
"Type".to_owned(),
"Encode".to_owned(),
"Decode".to_owned(),
"StoredAs".to_owned(),
"Carrier".to_owned()
]
),
(
"if_mysql".to_owned(),
vec![
"Type".to_owned(),
"Encode".to_owned(),
"Decode".to_owned(),
"StoredAs".to_owned(),
"Carrier".to_owned()
]
),
]
);
for gate in ["if_sqlite", "if_postgres", "if_mysql"] {
assert!(inside(&model, gate).contains("i64"), "{gate}");
}
}
#[test]
fn the_reading_rows_and_the_parsing_face_are_ungated() {
assert_eq!(
ungated_traits(&codec()),
[
"EnumFilterMarker",
"DefaultMarker",
"DefaultVecMarker",
"CursorValue",
"FromStr",
"TryFrom",
"DelegatesId",
"ColumnKind",
"ColumnEq"
]
);
}
#[test]
fn the_vec_reading_serves_both_wire_positions() {
let rendered = rendered(&codec());
assert!(
rendered.contains("::marker::DefaultVecMarker for Codec"),
"the collection's reading:\n{rendered}"
);
assert!(
rendered.contains("::marker::ListMarker<") && rendered.contains("::std::vec::Vec<Codec>,"),
"a list of the vocabulary:\n{rendered}"
);
assert!(
rendered.contains("::marker::EnumMarker<Codec>,"),
"its element read as the vocabulary:\n{rendered}"
);
}
#[test]
fn the_width_follows_the_repr_and_only_postgres_widens() {
let mut model = codec();
model.width = Some(IntegerWidth::U8);
for gate in ["if_sqlite", "if_mysql"] {
let held = inside(&model, gate);
assert!(held.contains("u8"), "{gate}: {held}");
assert!(!held.contains("i16"), "{gate}: {held}");
}
let postgres = inside(&model, "if_postgres");
assert!(postgres.contains("i16"), "{postgres}");
assert!(!postgres.contains("u8"), "{postgres}");
}
#[test]
fn the_default_width_is_the_one_no_declaration_can_overflow() {
assert_eq!(codec().width(), IntegerWidth::I64);
assert_eq!(IntegerWidth::DEFAULT, IntegerWidth::I64);
assert!(inside(&codec(), "if_sqlite").contains("i64"));
}
#[test]
fn the_integer_map_casts_the_variant_rather_than_writing_a_number() {
let held = inside(&codec(), "if_sqlite").replace(' ', "");
assert!(
held.contains("Codec::Vp9as::core::primitive::i64"),
"{held}"
);
}
#[test]
fn one_backend_takes_the_text_form_without_moving_the_others() {
let mut model = codec();
model.forms.insert(Namespace::Postgres, StorageForm::Text);
model.variants[0]
.names
.insert(Namespace::Postgres, "avc".to_owned());
let postgres = inside(&model, "if_postgres");
assert!(postgres.contains("as_postgres_str"), "{postgres}");
assert!(!postgres.contains("i64"), "{postgres}");
assert!(inside(&model, "if_sqlite").contains("i64"));
assert!(rendered(&model).contains(r#""avc""#));
}
#[test]
fn the_form_decides_which_namespaces_have_a_face() {
let bare = codec();
assert_eq!(
methods(&bare),
[
"VARIANTS",
"as_str",
"as_graphql_str",
"is_h264",
"is_vp9",
"is_tape"
]
);
assert_eq!(
ungated_traits(&bare)
.iter()
.filter(|name| *name == "TryFrom")
.count(),
1,
"only the wire speaks text by default"
);
let mut model = codec();
model.forms.insert(Namespace::Sqlite, StorageForm::Text);
model.forms.insert(Namespace::Graphql, StorageForm::Integer);
assert_eq!(
methods(&model),
[
"VARIANTS",
"as_str",
"as_sqlite_str",
"is_h264",
"is_vp9",
"is_tape"
]
);
assert!(
!rendered(&model).contains("GraphqlName"),
"{}",
rendered(&model)
);
}
#[test]
fn the_wire_shouts_where_a_stored_word_is_verbatim() {
let mut model = codec();
model.forms.insert(Namespace::Mysql, StorageForm::Text);
let rendered = rendered(&model);
assert!(rendered.contains(r#""VP9""#), "{rendered}");
assert!(rendered.contains(r#""TAPE""#), "{rendered}");
assert!(rendered.contains(r#""Vp9""#), "{rendered}");
assert!(rendered.contains(r#""Tape""#), "{rendered}");
}
#[test]
fn a_global_rename_moves_every_face_that_did_not_state_its_own() {
let mut model = codec();
model.forms.insert(Namespace::Sqlite, StorageForm::Text);
model.variants[1].rename = Some("vp09".to_owned());
model.variants[1]
.names
.insert(Namespace::Graphql, "VP9".to_owned());
let rendered = rendered(&model);
assert!(
rendered.contains(r#""vp09""#),
"the canonical word, and SQLite's: {rendered}"
);
assert!(rendered.contains(r#""VP9""#), "the wire's own: {rendered}");
assert!(
!rendered.contains(r#""VP09""#),
"the wire stated its own: {rendered}"
);
}
#[test]
fn a_raw_variant_is_canonically_the_word_without_its_escape() {
let mut model = codec();
model.forms.insert(Namespace::Sqlite, StorageForm::Text);
model.variants[2].ident = syn::Ident::new_raw("type", proc_macro2::Span::call_site());
let rendered = rendered(&model);
assert!(rendered.contains(r#""type""#), "{rendered}");
assert!(!rendered.contains(r##""r#type""##), "{rendered}");
assert_eq!(model.variants[2].predicate(), "is_type");
}
#[test]
fn mongodb_gets_its_namespace_and_no_storage_row() {
let mut model = codec();
model.forms.insert(Namespace::Mongo, StorageForm::Text);
assert!(
gated(&model).iter().all(|(gate, _)| gate != "if_mongo"),
"{:?}",
gated(&model)
);
assert!(methods(&model).contains(&"as_mongo_str".to_owned()));
assert!(rendered(&model).contains("MongoName"));
}
#[test]
fn the_expansion_carries_no_backend_derive_and_no_backend_attribute() {
let rendered = rendered(&codec());
let held = body(&emission(&codec()));
let storage = quote::quote!(#(#held)*).to_string();
assert!(!storage.contains("async_graphql"), "{storage}");
for attrs in attributes(&emission(&codec())) {
assert_eq!(attrs, "#[automatically_derived]", "{rendered}");
}
}
#[test]
fn the_wire_face_is_one_gated_block() {
let emitted = emission(&codec());
let wire = wire(&emitted);
assert_eq!(wire.len(), 1, "the wire block is one statement: the gate");
let syn::Stmt::Macro(gate) = &wire[0] else {
panic!("the wire block's statement is a gate invocation");
};
assert!(is_gate(&gate.mac.path), "{:?}", tight(&gate.mac.path));
assert_eq!(
gate
.mac
.path
.segments
.last()
.expect("a path has a last segment")
.ident,
"if_async_graphql"
);
}
fn attributes(file: &syn::File) -> Vec<String> {
file
.items
.iter()
.filter_map(|item| match item {
syn::Item::Impl(item) => Some(&item.attrs),
_ => None,
})
.chain(body(file).iter().filter_map(|stmt| match stmt {
syn::Stmt::Item(syn::Item::Impl(item)) => Some(&item.attrs),
_ => None,
}))
.flatten()
.filter(|attr| !attr.path().is_ident("doc"))
.map(|attr| attr.to_token_stream().to_string().replace(' ', ""))
.collect()
}
#[test]
fn every_framework_path_goes_through_a_private_module() {
let mut model = codec();
for namespace in Namespace::ALL {
model.forms.insert(namespace, StorageForm::Text);
}
assert!(
ill_formed_shelf_paths(&model).is_empty(),
"{:?}",
ill_formed_shelf_paths(&model)
);
}
fn ill_formed_shelf_paths(model: &EnumModel) -> Vec<String> {
let root = model
.krate
.segments
.last()
.expect("a crate path has a last segment")
.ident
.to_string();
let tokens = flat_tokens(model.emit());
let colon = |at: usize| matches!(tokens.get(at), Some(proc_macro2::TokenTree::Punct(p)) if p.as_char() == ':');
let ident = |at: usize| matches!(tokens.get(at), Some(proc_macro2::TokenTree::Ident(_)));
let named = |at: usize, name: &str| matches!(tokens.get(at), Some(proc_macro2::TokenTree::Ident(id)) if id == name);
let well_formed = |at: usize| {
if !(colon(at + 1) && colon(at + 2) && named(at + 3, "__private")) {
return false;
}
let mut segments = 0;
let mut cursor = at + 3;
while colon(cursor + 1) && colon(cursor + 2) && ident(cursor + 3) {
segments += 1;
cursor += 3;
}
segments >= 2
};
(0..tokens.len())
.filter(|at| named(*at, &root))
.filter(|at| !well_formed(*at))
.map(|at| {
tokens[at..(at + 10).min(tokens.len())]
.iter()
.map(ToString::to_string)
.collect()
})
.collect()
}
fn flat_tokens(stream: proc_macro2::TokenStream) -> Vec<proc_macro2::TokenTree> {
stream
.into_iter()
.flat_map(|token| match token {
proc_macro2::TokenTree::Group(group) => flat_tokens(group.stream()),
other => vec![other],
})
.collect()
}