use super::{graft_entries, render_graft_expression};
#[test]
fn graft_parser_collects_single_and_full_cuts() {
let source = r#"
xirang_kernel::static_graft_plan!(FRAMEWORK,
cut ["root/a1/b2"] graft "canvas_fast",
cut ["root/a"] full graft "a_fast",
);
"#;
let entries = graft_entries(source).unwrap();
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].cut, "root/a1/b2");
assert!(!entries[0].full);
assert_eq!(entries[1].graft, "a_fast");
assert!(entries[1].full);
}
#[test]
fn graft_parser_keeps_range_endpoints() {
let source = r#"xirang_kernel::graft_plan!(framework, cut ["root/a1" to "root/a3"] graft "replacement");"#;
let entries = graft_entries(source).unwrap();
assert_eq!(entries[0].cut, "root/a1");
assert_eq!(entries[0].cut_end.as_deref(), Some("root/a3"));
}
#[test]
fn a_path_containing_the_range_word_is_a_single_cut() {
let source = r#"xirang_kernel::static_graft_plan!(FRAMEWORK, cut "root/a to b" graft "g");"#;
let entries = graft_entries(source).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].cut, "root/a to b");
assert_eq!(entries[0].cut_end, None);
}
#[test]
fn graft_parser_accepts_unbracketed_single_cut() {
let source =
r#"xirang_kernel::static_graft_plan!(FRAMEWORK, cut "root/a" full graft "replacement");"#;
let entries = graft_entries(source).unwrap();
assert_eq!(entries[0].cut, "root/a");
assert!(entries[0].full);
}
#[test]
fn graft_parser_collects_declaration_only_static_plans() {
let source = r#"xirang_kernel::static_graft_plan!(FRAMEWORK,
cut "root/a" graft "replacement",
);"#;
let entries = graft_entries(source).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].cut, "root/a");
assert_eq!(entries[0].graft, "replacement");
}
#[test]
fn graft_parser_ignores_declarations_that_are_not_items() {
let in_function = r#"
fn plan() {
let _ = xirang_kernel::graft_plan!(FRAMEWORK, cut "root/a" graft "replacement");
}
"#;
assert!(graft_entries(in_function).unwrap().is_empty());
let in_test_module = r#"
#[cfg(test)]
mod tests {
xirang_kernel::static_graft_plan!(FRAMEWORK, cut "root/a" graft "replacement");
}
"#;
assert!(graft_entries(in_test_module).unwrap().is_empty());
let at_entry = r#"
#[cfg(feature = "optional-graft")]
xirang_kernel::static_graft_plan!(FRAMEWORK, cut "root/a" graft "replacement");
"#;
let entries = graft_entries(at_entry).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(
entries[0].cfg.as_deref(),
Some("feature = \"optional-graft\"")
);
}
#[test]
fn graft_parser_ignores_removed_macro_names() {
let source =
r#"fn plan() { xirang_kernel::graft!(framework, cut "root/a" graft "replacement"); }"#;
assert!(graft_entries(source).unwrap().is_empty());
}
#[test]
fn graft_parser_keeps_typed_expressions() {
let source = r#"xirang_kernel::static_graft_plan!(FRAMEWORK,
cut(crate::control::object::button::NODE_ID)
graft(graft_crate::button_fast::NODE_ID),
);"#;
let entries = graft_entries(source).unwrap();
let expressions = entries[0].expressions.as_ref().expect("typed expressions");
assert_eq!(
expressions.cut, "crate::control::object::button::NODE_ID",
"the host path is preserved verbatim so the compiler resolves it"
);
assert_eq!(expressions.graft, "graft_crate::button_fast::NODE_ID");
assert_eq!(expressions.cut_end, None);
assert!(!entries[0].full);
}
#[test]
fn graft_parser_keeps_a_typed_sibling_range() {
let source = r#"xirang_kernel::static_graft_plan!(FRAMEWORK,
cut(crate::control::object::button::NODE_ID to crate::control::object::slider::NODE_ID)
graft(graft_crate::fast::NODE_ID),
);"#;
let entries = graft_entries(source).unwrap();
let expressions = entries[0].expressions.as_ref().expect("typed expressions");
assert_eq!(expressions.cut, "crate::control::object::button::NODE_ID");
assert_eq!(
expressions.cut_end.as_deref(),
Some("crate::control::object::slider::NODE_ID")
);
assert_eq!(entries[0].cut, "crate::control::object::button::NODE_ID");
assert_eq!(
entries[0].cut_end.as_deref(),
Some("crate::control::object::slider::NODE_ID")
);
}
#[test]
fn graft_parser_rejects_mixed_typed_and_string_sides() {
let source = r#"xirang_kernel::static_graft_plan!(FRAMEWORK,
cut(crate::control::NODE_ID) graft "button_fast",
);"#;
let error = graft_entries(source).unwrap_err();
assert!(
error.message.contains("both sides"),
"unexpected message: {}",
error.message
);
}
#[test]
fn a_rendered_declaration_parses_back_into_the_same_structure() {
let line = render_graft_expression(
"crate::control::object::button::NODE_ID",
None,
true,
"control_button_graft::button_fast::NODE_ID",
)
.expect("the typed-expression form renders");
let source = format!("static_graft_plan! {{ {line} }}");
let parsed = graft_entries(&source).expect("and parses back");
assert_eq!(parsed.len(), 1, "{parsed:?}");
assert_eq!(parsed[0].cut, "crate::control::object::button::NODE_ID");
assert_eq!(
parsed[0].graft,
"control_button_graft::button_fast::NODE_ID"
);
assert!(parsed[0].full, "`full` survives the round trip");
assert!(parsed[0].cut_end.is_none());
assert!(parsed[0].expressions.is_some(), "it is the typed form");
}
#[test]
fn a_rendered_range_keeps_both_endpoints() {
let line = render_graft_expression(
"crate::control::object::button::NODE_ID",
Some("crate::control::object::slider::NODE_ID"),
false,
"control_button_graft::button_fast::NODE_ID",
)
.expect("a typed range renders");
let parsed =
graft_entries(&format!("static_graft_plan! {{ {line} }}")).expect("and parses back");
assert_eq!(parsed[0].cut, "crate::control::object::button::NODE_ID");
assert_eq!(
parsed[0].cut_end.as_deref(),
Some("crate::control::object::slider::NODE_ID"),
"the far endpoint is data, not part of the start path"
);
assert!(!parsed[0].full);
}
#[test]
fn the_renderer_refuses_a_spelling_it_cannot_guarantee() {
let refused = render_graft_expression("crate::to::NODE_ID", None, false, "x::y")
.expect_err("a `to` segment is read as a range separator");
assert!(refused.message.contains("range separator"), "{refused:?}");
let refused = render_graft_expression("crate::a::NODE_ID", None, false, "\"a string\"")
.expect_err("the literal spelling is a different shape");
assert!(refused.message.contains("another spelling"), "{refused:?}");
let refused = render_graft_expression("", None, false, "x::y").expect_err("empty is refused");
assert!(refused.message.contains("must not be empty"), "{refused:?}");
assert!(
refused.location.is_none(),
"nothing was written yet, so there is no location to point at"
);
}
#[test]
fn full_on_a_range_is_refused_in_both_directions() {
for source in [
r#"static_graft_plan! { cut ["root/a" to "root/c"] full graft "replacement" }"#,
r#"static_graft_plan! { cut(crate::a::NODE_ID to crate::b::NODE_ID) full graft(fast::NODE_ID) }"#,
] {
let error = graft_entries(source)
.expect_err("a range with `full` is refused")
.to_string();
assert!(
error.contains("`full` on a range cut has no defined meaning"),
"{source}: {error}"
);
assert!(
error.contains("Write one cut per face, or drop `full`"),
"the refusal carries the way out: {source}: {error}"
);
}
let refused = render_graft_expression(
"crate::a::NODE_ID",
Some("crate::b::NODE_ID"),
true,
"fast::NODE_ID",
)
.expect_err("the renderer must not write what its own parser refuses");
assert!(
refused
.message
.contains("`full` on a range cut has no defined meaning"),
"{refused:?}"
);
let range = render_graft_expression(
"crate::a::NODE_ID",
Some("crate::b::NODE_ID"),
false,
"fast::NODE_ID",
)
.expect("a range without `full` still renders");
assert!(graft_entries(&format!("static_graft_plan! {{ {range} }}")).is_ok());
let single = render_graft_expression("crate::a::NODE_ID", None, true, "fast::NODE_ID")
.expect("`full` without a range still renders");
let parsed = graft_entries(&format!("static_graft_plan! {{ {single} }}"))
.expect("and still parses back");
assert!(parsed[0].full && parsed[0].cut_end.is_none());
}
#[test]
fn each_entry_reports_its_own_location() {
let source = "xirang_kernel::static_graft_plan!(\n FRAMEWORK,\n cut(a::one::NODE_ID)\n graft(g::one::NODE_ID),\n cut(a::two::NODE_ID) graft(g::two::NODE_ID),\n);\n";
let entries = graft_entries(source).expect("the declaration parses");
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].location.line, 3, "{:?}", entries[0].location);
assert_eq!(entries[1].location.line, 5, "{:?}", entries[1].location);
assert_ne!(
entries[0].location, entries[1].location,
"two entries on two lines cannot share one location"
);
}
#[test]
fn a_refusal_points_at_the_entry_it_is_about() {
let source = "xirang_kernel::static_graft_plan!(\n FRAMEWORK,\n cut(a::one::NODE_ID) graft(g::one::NODE_ID),\n cut(a::two::NODE_ID) wrong(g::two::NODE_ID),\n);\n";
let error = graft_entries(source).expect_err("the second entry is malformed");
let location = error
.location
.expect("a refusal inside an entry can point at it");
assert_eq!(location.line, 4, "the refusal belongs to the fourth line");
}
#[test]
fn full_written_after_graft_is_refused_by_naming_where_it_belongs() {
let source = r#"xirang_kernel::graft_plan!(framework, cut ["root/a" to "root/a3"] graft "replacement" full);"#;
let error = graft_entries(source).expect_err("refused").to_string();
assert!(
error.contains("**before** `graft`"),
"it says where `full` belongs: {error}"
);
assert!(
!error.contains("expects `graft <implementation>`"),
"and does not send the reader looking for a `graft` that is already written: {error}"
);
}