KiCad - the KiCad Bridge

@@ -1068,16 +1068,67 @@ fn connect_to_bus(ctx: &mut Ctx) -> Result<Done, Value> { // Batch // --------------------------------------------------------------------------- +/// The batch's ops in KiCad's own names and shapes: an op may name the standard's schematic verb (sch_place_part,+/// sch_connect, sch_edit, ... with the standard's arguments, the standard's sch_batch #29) and is turned into KiCad's+/// the way a direct call is (catalog alias, then std_shapes); one standard op can become several KiCad ops.+fn native_ops(ops: &[Value]) -> Result<Vec<Value>, Value> {+    let mut out = Vec::new();+    for (i, opv) in ops.iter().enumerate() {+        let name = opv.get("op").and_then(Value::as_str).map(str::trim).ok_or_else(|| fail("bad_arg", format!("ops[{i}] has no op"), "Every op names its operation: {\"op\": \"sch_place_part\", ...}."))?;+        // the four standard schematic verbs KiCad answers under its own names (equivalents/kicad.json): the op runs as+        // KiCad's verb, chosen by the arguments where one standard verb is several KiCad ones, with KiCad's arguments+        let has = |k: &str| opv.get(k).is_some_and(|v| !v.is_null());+        let mapped = match name.trim_start_matches("kicad_") {+            "sch_place_part" => Some("sch_place_symbol"),+            "sch_swap_part" => Some("sch_replace_symbol"),+            "sch_connect" if has("net") && (has("pin") || has("pins") || has("reference")) => Some("sch_connect_to_net"),+            "sch_connect" if has("points") || has("from") => Some("sch_wire"),+            "sch_connect" if has("text") || has("label") => Some("sch_label"),+            "sch_connect" => Some("sch_no_connect"),+            "sch_edit" if opv.get("delete") == Some(&json!(true)) => Some("sch_delete"),+            "sch_edit" if has("rotation") || has("angle") => Some("sch_rotate"),+            "sch_edit" if has("to") || has("by") || has("at") => Some("sch_move"),+            "sch_edit" => Some("sch_set_property"),+            _ => None,+        };+        let name = mapped.unwrap_or(name);+        let called = if name.starts_with("kicad_") { name.to_string() } else { format!("kicad_{name}") };+        let full = crate::catalog::alias_target(&called).map(String::from).unwrap_or_else(|| called.clone());+        let mut args = opv.clone();+        if let Some(o) = args.as_object_mut() {+            o.remove("op");+        }+        match crate::std_shapes::to_native(&called, &full, &args) {+            Some(Err(refusal)) => return Err(refusal),+            Some(Ok(sh)) if sh.command == "kicad_sch_batch" => out.extend(sh.args["ops"].as_array().cloned().unwrap_or_default()),+            Some(Ok(sh)) => {+                let mut a = sh.args.clone();+                a["op"] = json!(sh.command.trim_start_matches("kicad_sch_").trim_start_matches("kicad_"));+                out.push(a);+            }+            None => {+                let mut a = opv.clone();+                a["op"] = json!(name);+                out.push(a);+            }+        }+    }+    Ok(out)+}+ fn batch(ctx: &mut Ctx) -> Result<Done, Value> {-    let ops = ctx.args.get("ops").and_then(Value::as_array).filter(|a| !a.is_empty()).ok_or_else(|| fail("missing_arg", "ops is required", "Pass ops as a list of {\"op\": \"wire\", ...that verb's arguments}."))?.clone();+    let given = ctx.args.get("ops").and_then(Value::as_array).filter(|a| !a.is_empty()).ok_or_else(|| fail("missing_arg", "ops is required", "Pass ops as a list of {\"op\": \"sch_place_part\" | \"place_symbol\", ...that verb's arguments}."))?.clone();+    let ops = native_ops(&given)?;     let mut results = Vec::new();     for (i, opv) in ops.iter().enumerate() {-        let name = opv.get("op").and_then(Value::as_str).map(|s| s.trim().trim_start_matches("kicad_sch_").to_string()).ok_or_else(|| fail("bad_arg", format!("ops[{i}] has no op"), "Every op names its operation: {\"op\": \"wire\", ...}."))?;+        let name = opv.get("op").and_then(Value::as_str).map(|s| s.trim().trim_start_matches("kicad_").trim_start_matches("sch_").to_string()).ok_or_else(|| fail("bad_arg", format!("ops[{i}] has no op"), "Every op names its operation: {\"op\": \"wire\", ...}."))?;         if name == "batch" {             return Err(fail("bad_arg", format!("ops[{i}] is a batch; batches do not nest"), "Flatten the ops into one list."));         }         let Some(f) = op_for(&name) else {-            return Err(fail("bad_arg", format!("ops[{i}]: unknown op {name}"), "Ops: place_symbol, wire, label, move, rotate, delete, set_property, no_connect, move_region, annotate, replace_symbol, update_from_library, reset_fields, delete_wire, split_wire, edit_label, junction, connect_to_net, connect_pins, text, bus, bus_entry, connect_to_bus."));+            let mut v = fail("bad_arg", format!("ops[{i}]: unknown op {name}"), "Ops: the standard's schematic verbs (sch_place_part, sch_connect, sch_edit, ...) or KiCad's: place_symbol, wire, label, move, rotate, delete, set_property, no_connect, move_region, annotate, replace_symbol, update_from_library, reset_fields, delete_wire, split_wire, edit_label, junction, connect_to_net, connect_pins, text, bus, bus_entry, connect_to_bus.");+            v["failedOp"] = json!(i);+            return Err(v);         };         let mut sub = Ctx { sch: &mut *ctx.sch, path: ctx.path, lib: ctx.lib, args: opv };         match f(&mut sub) {@@ -1318,6 +1369,19 @@ mod tests {         err("kicad_sch_connect_to_bus", &p, json!({"pins": ["U1.6"], "bus": "1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d", "members": ["X"], "entry": "up"}), "entry_off_bus");     } +    #[test]+    fn batch_takes_the_standards_op_names() {+        let p = temp_sheet("stdbatch");+        let v = call("kicad_sch_batch", &p, json!({"ops": [+            {"op": "sch_junction", "at": [101.6, 101.6]},+            {"op": "sch_place_part", "libId": "Device:R", "reference": "R77", "at": [127.0, 127.0]},+            {"op": "sch_text", "text": "standard names", "at": [50.8, 50.8]}]}));+        assert_eq!(v["success"], true, "{v}");+        assert_eq!(v["results"].as_array().map(|a| a.len()), Some(3), "{v}");+        let bad = call("kicad_sch_batch", &p, json!({"ops": [{"op": "sch_text", "text": "x", "at": [1, 1]}, {"op": "sch_no_such_verb"}]}));+        assert_eq!(bad["failedOp"], 1, "{bad}");+    }+     #[test]     fn batch_is_all_or_nothing() {         let p = temp_sheet("batch");