use super::{
Dedup, Elected, ElectionLabel, IndexGraphql, IndexModel, IndexRename, Projected, RenamePiece,
Upstream,
};
use crate::{
engine::{Engine, FieldEngines},
model::{Column, GraphqlKind, NodeKind, Projection},
prefix::EmissionPrefix,
};
fn ident(name: &str) -> syn::Ident {
syn::Ident::new(name, proc_macro2::Span::call_site())
}
fn frames(rename: Option<IndexRename>) -> IndexModel {
let field = |name: &str| Column {
project: Projection::Borrowed,
ty: syn::parse_quote!(::ingraph::Embedding<f32, 4, Clip>),
source: ident(name),
name: ident(name),
};
let elected = |name: &str| {
Elected::new(
ident(name),
ElectionLabel::Embedding,
syn::parse_quote!(::ingraph::Embedding<f32, 4, Clip>),
None,
)
};
let engines = |name: &str| FieldEngines {
field: ident(name),
engines: vec![Engine::bare(ident("lance"))],
fanout: false,
};
IndexModel {
prefix: EmissionPrefix::default(),
numbers: crate::index::Numbers::default(),
field_numbers: Vec::new(),
index: ident("Frames"),
kind: NodeKind::Vector,
vis: syn::parse_quote!(pub),
krate: syn::parse_quote!(::ingraph),
source: Upstream {
node: syn::parse_quote!(Keyframe),
projections: vec![
Projected {
field: ident("clip"),
from: ident("clip"),
ty: syn::parse_quote!(::ingraph::Embedding<f32, 4, Clip>),
},
Projected {
field: ident("poster"),
from: ident("poster"),
ty: syn::parse_quote!(::ingraph::Embedding<f32, 4, Clip>),
},
],
},
dedup: Dedup::Hash,
embeddings: vec![elected("clip"), elected("poster")],
labelled: Vec::new(),
searchable: Vec::new(),
engines: vec![engines("clip"), engines("poster")],
stores: Vec::new(),
extension: None,
data: false,
keys: false,
subscribe: false,
graphql: None,
rename,
slot: None,
fields: vec![field("clip"), field("poster")],
}
}
fn landed(model: &IndexModel) -> Vec<String> {
let file: syn::File = syn::parse2(model.emit()).expect("the emission parses");
file
.items
.into_iter()
.filter_map(|item| match item {
syn::Item::Struct(declared) => Some(declared.ident.to_string()),
syn::Item::Enum(declared) => Some(declared.ident.to_string()),
_ => None,
})
.collect()
}
fn rostered(model: &IndexModel) -> Vec<String> {
model
.emitted_types()
.iter()
.map(|declared| declared.name.to_string())
.collect()
}
#[test]
fn a_base_rename_moves_every_minted_name_and_the_roster_with_it() {
let renamed = frames(Some(IndexRename::Base(ident("ShotSearch"))));
let plain = frames(None);
assert_eq!(landed(&renamed), rostered(&renamed));
assert_eq!(landed(&plain), rostered(&plain));
assert_eq!(
landed(&renamed),
landed(&plain)
.iter()
.map(|name| name.replacen("Frames", "ShotSearch", 1))
.collect::<Vec<_>>(),
);
assert!(
!landed(&renamed).is_empty(),
"the fixture mints a family for the claim to be about",
);
}
#[test]
fn the_authors_own_struct_name_never_moves() {
let renamed = frames(Some(IndexRename::Base(ident("ShotSearch"))));
let said = renamed.emit().to_string();
assert!(said.contains("for Frames"), "the impls still name the item");
assert!(
!landed(&renamed).iter().any(|name| name == "ShotSearch"),
"and the base is a STEM rather than a type: {:?}",
landed(&renamed),
);
}
#[test]
fn the_durable_slot_name_never_moves_with_a_rust_rename() {
let renamed = frames(Some(IndexRename::Base(ident("ShotSearch"))))
.emit()
.to_string();
let plain = frames(None).emit().to_string();
for durable in ["frames__clip__lance", "frames__poster__lance"] {
assert!(plain.contains(durable), "the fixture names its corpora");
assert!(
renamed.contains(durable),
"`{durable}` moved with a Rust rename",
);
}
assert!(
renamed.contains("ShotSearchClipLance"),
"and the MARKER did move",
);
}
#[test]
fn a_piece_rename_names_that_mint_and_leaves_the_rest_alone() {
let renamed = frames(Some(IndexRename::Pieces(vec![
(RenamePiece::FuseOptions, ident("ShotKnobs")),
(RenamePiece::Evidence, ident("WhoAgreed")),
])));
let names = landed(&renamed);
assert!(names.iter().any(|name| name == "ShotKnobs"), "{names:?}");
assert!(names.iter().any(|name| name == "WhoAgreed"), "{names:?}");
assert!(
!names.iter().any(|name| name == "FramesFuseOptions"),
"the named mint is gone from the scope: {names:?}",
);
assert!(
names.iter().any(|name| name == "FramesFuseQuestion"),
"and every mint the block did not name keeps the declaration's own: {names:?}",
);
assert_eq!(names, rostered(&renamed), "the roster moved with it");
}
#[test]
fn the_two_axes_compose_and_neither_reads_the_other() {
let mut model = frames(Some(IndexRename::Base(ident("ShotSearch"))));
let mut skin = crate::index::IndexBackend::of(GraphqlKind::AsyncGraphql);
skin.prefix = Some(syn::LitStr::new("wireFace", proc_macro2::Span::call_site()));
model.graphql = Some(IndexGraphql {
backends: vec![skin],
});
let said = model.emit().to_string();
assert!(
landed(&model)
.iter()
.all(|name| name.starts_with("ShotSearch")),
"the Rust family is the BONE word's: {:?}",
landed(&model),
);
assert!(
said.contains("\"WireFaceFuseOptions\""),
"and the schema is the SKIN word's",
);
assert!(
!said.contains("\"ShotSearchFuseOptions\""),
"with no Rust name reaching the schema",
);
}
#[test]
fn an_artifact_family_mints_no_type_for_a_rename_to_move() {
let mut blob = frames(None);
blob.kind = NodeKind::Blob;
blob.embeddings = Vec::new();
blob.engines = Vec::new();
blob.stores = vec![Engine::bare(ident("fs"))];
assert!(blob.emitted_types().is_empty());
assert!(landed(&blob).is_empty(), "{:?}", landed(&blob));
}
#[test]
fn the_slot_word_reaches_the_durable_name_and_the_default_stands() {
let mut blob = frames(None);
blob.kind = NodeKind::Blob;
blob.index = ident("PosterFrame");
blob.embeddings = Vec::new();
blob.engines = Vec::new();
blob.stores = vec![Engine::bare(ident("fs"))];
let default = blob.emit().to_string();
assert!(
default.contains("\"poster_frame\""),
"the default is `snake_case(<declaration name>)`",
);
blob.slot = Some(syn::LitStr::new(
"archive_2019",
proc_macro2::Span::call_site(),
));
let named = blob.emit().to_string();
assert!(named.contains("\"archive_2019\""), "{named}");
assert!(
!named.contains("\"poster_frame\""),
"one family lives in ONE place: {named}",
);
}