Files
horizon-airdef/crates/horizon-client/examples/command_parse_fixture.rs
T
Ludovic Marie 6734879ff7 Pass rustfmt and clippy after merging the parity branches
Formats the overnight parity work, fixes the lints it introduced, and
updates the LAN bot test and mob AI probe for fields added on the other
side of the merges (the bot test also set a field that never existed).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-11 14:11:51 +02:00

261 lines
11 KiB
Rust

//! Command parsing for differential tests against vanilla's Brigadier tree
//! (tools/test_command_parse_parity.py): reads one command per line and prints
//! the parse result, the error (rendered text and UTF-16 cursor), the parsed
//! node names and the completion suggestions at the end of the input, in the
//! same JSON-lines shape as VanillaCommandParseOracle.
//!
//! usage: command_parse_fixture RESOURCES REGISTRIES.json CORPUS PERMISSION OUTPUT
use horizon_client::{
command::{ArgType, Dispatcher, NodeKind, Registries, args::RegistryIds, vanilla},
lang,
};
use serde_json::{Value, json};
use std::{fs, path::Path};
fn strings(v: &Value) -> Vec<String> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
fn utf16(input: &str, byte: usize) -> usize {
let mut end = byte.min(input.len());
while !input.is_char_boundary(end) {
end -= 1;
}
input[..end].encode_utf16().count()
}
fn parser_id(ty: &ArgType) -> String {
match ty {
ArgType::Bool => "brigadier:bool".into(),
ArgType::Integer { .. } => "brigadier:integer".into(),
ArgType::Float { .. } => "brigadier:float".into(),
ArgType::Double { .. } => "brigadier:double".into(),
ArgType::Word | ArgType::Str | ArgType::Greedy => "brigadier:string".into(),
ArgType::Entity { .. } => "minecraft:entity".into(),
ArgType::BlockPos => "minecraft:block_pos".into(),
ArgType::Vec3 { .. } => "minecraft:vec3".into(),
ArgType::Rotation => "minecraft:rotation".into(),
ArgType::Angle => "minecraft:angle".into(),
ArgType::Item => "minecraft:item_stack".into(),
ArgType::ItemPredicate => "minecraft:item_predicate".into(),
ArgType::BlockState => "minecraft:block_state".into(),
ArgType::BlockPredicate => "minecraft:block_predicate".into(),
ArgType::Resource(_) => "minecraft:resource".into(),
ArgType::Id(_) => "minecraft:resource_location".into(),
ArgType::Res(_) => "minecraft:resource".into(),
ArgType::ResKey(_) => "minecraft:resource_key".into(),
ArgType::ResOrTag(_) => "minecraft:resource_or_tag".into(),
ArgType::ResOrTagKey(_) => "minecraft:resource_or_tag_key".into(),
ArgType::StrEnum(values, _) => match values.first().copied() {
Some("world_surface") => "minecraft:heightmap".into(),
Some("none") if values.len() == 3 && values[1] == "left_right" => {
"minecraft:template_mirror".into()
}
Some("none") if values.len() == 3 => "minecraft:swing_animation".into(),
_ => "minecraft:template_rotation".into(),
},
ArgType::HexColor => "minecraft:hex_color".into(),
ArgType::Uuid => "minecraft:uuid".into(),
ArgType::GameProfile => "minecraft:game_profile".into(),
ArgType::Style => "minecraft:style".into(),
ArgType::Name(_) => "brigadier:string".into(),
ArgType::Time { .. } => "minecraft:time".into(),
ArgType::GameMode => "minecraft:gamemode".into(),
ArgType::Message => "minecraft:message".into(),
ArgType::Dimension => "minecraft:dimension".into(),
ArgType::Anchor => "minecraft:entity_anchor".into(),
ArgType::Swizzle => "minecraft:swizzle".into(),
ArgType::Component => "minecraft:component".into(),
ArgType::Nbt => "minecraft:nbt_compound_tag".into(),
ArgType::ScoreHolder { .. } => "minecraft:score_holder".into(),
ArgType::Objective => "minecraft:objective".into(),
ArgType::Team => "minecraft:team".into(),
ArgType::Criteria => "minecraft:objective_criteria".into(),
ArgType::ScoreboardSlot => "minecraft:scoreboard_slot".into(),
ArgType::Operation => "minecraft:operation".into(),
ArgType::TeamColor => "minecraft:team_color".into(),
ArgType::IntRange => "minecraft:int_range".into(),
ArgType::FloatRange => "minecraft:float_range".into(),
ArgType::NbtPath => "minecraft:nbt_path".into(),
ArgType::NbtTag => "minecraft:nbt_tag".into(),
ArgType::Vec2 => "minecraft:vec2".into(),
ArgType::ColumnPos => "minecraft:column_pos".into(),
ArgType::Particle => "minecraft:particle".into(),
ArgType::Enum(words) => format!("enum:{}", words.join("|")),
ArgType::Function => "minecraft:function".into(),
ArgType::Slots => "minecraft:slots".into(),
ArgType::Slot => "minecraft:item_slot".into(),
ArgType::SlotSource => "minecraft:slot_source".into(),
ArgType::ResourceOrId(r) => match *r {
"minecraft:loot_table" => "minecraft:loot_table".into(),
"minecraft:item_modifier" => "minecraft:loot_modifier".into(),
"minecraft:predicate" => "minecraft:loot_predicate".into(),
"minecraft:context_int_provider" => "minecraft:context_int_provider".into(),
"minecraft:context_float_provider" => "minecraft:context_float_provider".into(),
"minecraft:dialog" => "minecraft:dialog".into(),
_ => "minecraft:feature".into(),
},
}
}
fn tree(d: &Dispatcher, node: usize) -> Value {
let n = &d.nodes[node];
let mut children = serde_json::Map::new();
for &c in &n.children {
let child = &d.nodes[c];
let mut v = tree(d, c);
match &child.kind {
NodeKind::Literal(_) => v["type"] = json!("literal"),
NodeKind::Argument { ty, .. } => {
v["type"] = json!("argument");
v["parser"] = json!(parser_id(ty));
}
NodeKind::Root => {}
}
children.insert(child.name().to_owned(), v);
}
let mut v = json!({"children": children});
if n.command.is_some() {
v["executable"] = json!(true);
}
if n.redirect.is_some() {
v["redirect"] = json!(true);
}
v
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
if args.get(1).map(String::as_str) == Some("tree") {
let d = vanilla::release_dispatcher();
let mut v = tree(d, 0);
v["type"] = json!("root");
fs::write(&args[2], v.to_string())?;
return Ok(());
}
if args.len() != 6 {
return Err(
"usage: command_parse_fixture RESOURCES REGISTRIES CORPUS PERMISSION OUTPUT".into(),
);
}
let root = Path::new(&args[1]).to_path_buf();
lang::set(lang::Language::load(&[&root], lang::DEFAULT));
let r: Value = serde_json::from_slice(&fs::read(&args[2])?)?;
let mut reg = Registries {
permission: args[4].parse()?,
..Registries::default()
};
reg.items = strings(&r["items"]);
reg.item_tags = strings(&r["item_tags"]);
reg.block_tags = strings(&r["block_tags"]);
for (id, props) in r["blocks"].as_object().into_iter().flatten() {
let props = props
.as_array()
.into_iter()
.flatten()
.map(|p| (p[0].as_str().unwrap_or("").to_owned(), strings(&p[1])))
.collect();
reg.blocks.insert(id.clone(), props);
}
reg.summonable = strings(&r["summonable"]);
reg.entity_types = strings(&r["entity_types"]);
reg.effects = strings(&r["effects"]);
reg.attributes = strings(&r["attributes"]);
reg.sounds = strings(&r["sounds"]);
reg.enchantments = strings(&r["enchantments"]);
reg.structures = strings(&r["structures"]);
reg.biomes = strings(&r["biomes"]);
reg.damage_types = strings(&r["damage_types"]);
reg.clocks = strings(&r["clocks"]);
reg.timelines = strings(&r["timelines"]);
reg.dimensions = strings(&r["dimensions"]);
reg.players = strings(&r["players"]);
reg.teams = strings(&r["teams"]);
reg.objectives = strings(&r["objectives"]);
reg.tracked = strings(&r["tracked"]);
for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
reg.by_registry.insert(
name.clone(),
RegistryIds {
ids: strings(&entry["ids"]),
tags: strings(&entry["tags"]),
},
);
}
reg.block_entities = strings(&r["block_entities"]).into_iter().collect();
for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
reg.block_tag_members.insert(tag.clone(), strings(members));
}
reg.templates = strings(&r["templates"]);
reg.persistent_components = strings(&r["persistent_components"]);
reg.learnable_recipes = strings(&r["learnable_recipes"]);
for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
reg.clock_time_markers
.insert(clock.clone(), strings(markers));
}
for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
reg.advancement_criteria
.insert(id.clone(), strings(criteria));
}
reg.datapacks_enabled = strings(&r["datapacks_selected"]);
let enabled = reg.datapacks_enabled.clone();
reg.datapacks_disabled = strings(&r["datapacks_enableable"])
.into_iter()
.filter(|p| !enabled.contains(p))
.collect();
reg.advancements = reg.ids("minecraft:advancement").to_vec();
reg.recipes = reg.ids("minecraft:recipe").to_vec();
reg.loot_tables = reg.ids("minecraft:loot_table").to_vec();
reg.predicates = reg.ids("minecraft:predicate").to_vec();
reg.item_modifiers = reg.ids("minecraft:item_modifier").to_vec();
let dispatcher = vanilla::release_dispatcher();
let mut out = String::new();
for input in fs::read_to_string(&args[3])?.lines() {
let parse = dispatcher.parse(input, &reg);
let result = match parse.executable() {
Ok(_) => {
let mut nodes = Vec::new();
let mut c = Some(&parse.context);
while let Some(ctx) = c {
nodes.extend(
ctx.nodes
.iter()
.map(|(n, _)| dispatcher.nodes[*n].name().to_owned()),
);
c = ctx.child.as_deref();
}
json!({"ok": true, "nodes": nodes})
}
Err(e) => json!({
"ok": false,
"error": e.message.plain(),
// CommandSyntaxException.getCursor is -1 without context.
"cursor": if e.input.is_some() { utf16(input, e.cursor) as i64 } else { -1 },
}),
};
let (range, list) = dispatcher.suggestions(&parse, input.len(), &reg);
let list: Vec<String> = list
.into_iter()
.map(|s| match s.tooltip {
Some(t) => format!("{}\t{t}", s.text),
None => s.text,
})
.collect();
let row = json!({
"in": input,
"parse": result,
"sugg": {"start": utf16(input, range.0), "end": utf16(input, range.1), "list": list},
});
out.push_str(&row.to_string());
out.push('\n');
}
fs::write(&args[5], out)?;
Ok(())
}