use quote::quote;
use crate::name::RustSafeName;
fn rust(name: &RustSafeName) -> String {
quote!(#name).to_string()
}
fn external(name: &RustSafeName) -> String {
format!("{name}")
}
fn name(external: &str) -> RustSafeName {
RustSafeName::new(external, proc_macro2::Span::call_site())
}
#[test]
fn an_identifier_is_its_own_rust_face() {
let name = name("bit_rate");
assert_eq!(rust(&name), "bit_rate");
assert_eq!(external(&name), "bit_rate");
}
#[test]
fn a_keyword_gains_a_trailing_underscore_and_keeps_its_external_name() {
for (declared, safe) in [
("type", "type_"),
("crate", "crate_"),
("self", "self_"),
("Self", "self_"),
("super", "super_"),
("match", "match_"),
("gen", "gen_"),
] {
let name = name(declared);
assert_eq!(rust(&name), safe, "`{declared}`");
assert_eq!(
external(&name),
declared,
"`{declared}` reaches SQL unchanged"
);
}
}
#[test]
fn the_rust_face_is_snake_case_and_the_external_face_is_not() {
for (declared, safe) in [
("bitRate", "bit_rate"),
("HTTPServer", "http_server"),
("VideoTrackID", "video_track_id"),
("streamIndex", "stream_index"),
("SELECT", "select"),
("XMLHttpRequest", "xml_http_request"),
("already_snake", "already_snake"),
] {
let name = name(declared);
assert_eq!(rust(&name), safe, "`{declared}`");
assert_eq!(
external(&name),
declared,
"`{declared}` is what a client sees, and it is never rewritten"
);
}
}
#[test]
fn normalising_an_already_idiomatic_name_changes_nothing() {
for declared in ["bit_rate", "id", "media_id", "a", "x2"] {
let name = name(declared);
assert_eq!(rust(&name), declared, "`{declared}`");
assert_eq!(external(&name), declared);
}
}
#[test]
fn a_non_identifier_character_becomes_an_underscore() {
for (declared, safe) in [
("my column", "my_column"),
("a-b", "a_b"),
("bit.rate", "bit_rate"),
("a\"b", "a_b"),
] {
let name = name(declared);
assert_eq!(rust(&name), safe, "`{declared}`");
assert_eq!(external(&name), declared, "`{declared}`");
}
}
#[test]
fn a_leading_digit_gains_a_prefix() {
let name = name("2fast");
assert_eq!(rust(&name), "_2fast");
assert_eq!(external(&name), "2fast");
syn::parse_str::<syn::Ident>(&rust(&name)).expect("the Rust face is an identifier");
}
#[test]
fn the_degenerate_names_still_produce_an_identifier() {
for declared in ["", "_", "-", " "] {
let name = name(declared);
syn::parse_str::<syn::Ident>(&rust(&name))
.unwrap_or_else(|e| panic!("`{declared}` produced `{}`: {e}", rust(&name)));
assert_eq!(external(&name), declared, "`{declared}`");
}
}
#[test]
fn every_name_has_a_spellable_rust_face_and_an_untouched_external_one() {
for declared in [
"bit_rate",
"type",
"crate",
"my column",
"2fast",
"a-b",
"",
"_",
"SELECT",
"r#type",
"__seq__",
"9",
] {
let name = name(declared);
syn::parse_str::<syn::Ident>(&rust(&name))
.unwrap_or_else(|e| panic!("`{declared}` produced `{}`: {e}", rust(&name)));
assert_eq!(external(&name), declared, "`{declared}` is never rewritten");
}
}
#[test]
fn a_field_ident_keeps_its_spelling_and_unraws_its_external_face() {
let plain =
RustSafeName::from_ident(&syn::Ident::new("bit_rate", proc_macro2::Span::call_site()));
assert_eq!(rust(&plain), "bit_rate");
assert_eq!(external(&plain), "bit_rate");
let raw = RustSafeName::from_ident(&syn::Ident::new_raw("type", proc_macro2::Span::call_site()));
assert_eq!(
rust(&raw),
"r#type",
"the field keeps the spelling it was declared with"
);
assert_eq!(external(&raw), "type", "and the column is called `type`");
}
#[test]
fn the_rust_face_can_be_quoted_into_a_struct_field() {
let names: Vec<RustSafeName> = ["type", "my column", "2fast"]
.iter()
.map(|n| name(n))
.collect();
let item: syn::ItemStruct = syn::parse2(quote! {
struct Row { #(#names: u64,)* }
})
.expect("every mangled name is a legal field name");
let fields: Vec<String> = match &item.fields {
syn::Fields::Named(named) => named
.named
.iter()
.map(|f| f.ident.as_ref().expect("named").to_string())
.collect(),
_ => panic!("named fields"),
};
assert_eq!(fields, ["type_", "my_column", "_2fast"]);
}