VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Fix #3545: draw_path and draw_shape with a paint the engine refuses leave the document unchanged
Taha-Mahmoodi648a8f51047c
diff --git a/crates/mcp/src/tests_drawopts.rs b/crates/mcp/src/tests_drawopts.rsindex 666ff1632..bef4e59b8 100644--- a/crates/mcp/src/tests_drawopts.rs+++ b/crates/mcp/src/tests_drawopts.rs@@ -138,3 +138,45 @@ fn schemas_list_the_options() {assert_eq!(v["result"]["isError"], false, "{tool}: {v}");}}++/// A paint the engine refuses (a fill or stroke it can't read, a swatch the document lacks) fails+/// the whole call: no object, no undo step, nothing in the SVG (#3545).+#[test]+fn a_bad_paint_draws_nothing() {+ let mut h = headless();+ let (before, undo, svg) =+ (objects(&h), h.session.doc().unwrap().history.undo.len(), vectorcraft_svg::export(&h.session.doc().unwrap().doc, &Default::default()));+ for bad in [+ json!({"stroke": "currentColor"}),+ json!({"fill": "currentColor"}),+ json!({"fill": "#550505", "stroke": "not-a-colour"}),+ json!({"fill": {"swatch": "No Such Swatch"}}),+ json!({"stroke": "#000000", "strokeWidth": "thick"}),+ ] {+ for (tool, base) in+ [("draw_path", json!({"d": "M0 0 L10 10"})), ("draw_shape", json!({"shape": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10}))]+ {+ let mut args = base.clone();+ for (k, v) in bad.as_object().unwrap() {+ args[k] = v.clone();+ }+ let r = call_tool(&mut h, tool, &args);+ assert!(r.is_error, "{tool} {args} must fail");+ let st = h.session.doc().unwrap();+ assert_eq!(objects(&h), before, "{tool} {args} drew something");+ assert_eq!(st.history.undo.len(), undo, "{tool} {args} left an undo step");+ assert_eq!(vectorcraft_svg::export(&st.doc, &Default::default()), svg, "{tool} {args} changed the SVG");+ }+ }+ // A good call is one undo step, named as the drawing command names its own.+ for (tool, args, label) in [+ ("draw_path", json!({"d": "M0 0 L10 10", "stroke": "#c19a4b", "strokeWidth": 2, "opacity": 50}), "Pen"),+ ("draw_shape", json!({"shape": "rectangle", "x": 0, "y": 0, "width": 10, "height": 10, "fill": "#000000", "stroke": "none"}), "Rectangle"),+ ] {+ let undo = h.session.doc().unwrap().history.undo.len();+ draw(&mut h, tool, args);+ let history = &h.session.doc().unwrap().history.undo;+ assert_eq!(history.len(), undo + 1, "{tool}");+ assert_eq!(history.last().unwrap().label, label);+ }+}diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rsindex 7587d67aa..3f37bce16 100644--- a/crates/mcp/src/tools.rs+++ b/crates/mcp/src/tools.rs@@ -528,20 +528,19 @@ fn paint_params(v: &Value) -> Result<Value, String> {})}-fn apply_paint(b: &mut dyn Backend, a: &Args, ids: Option<Value>) -> Result<Value, String> {- let with_ids = |mut p: Value| {- if let Some(ids) = &ids {- p["ids"] = ids.clone();- }- p- };- let mut applied = Map::new();+/// A command a drawing tool runs and its params.+type Step<'a> = (&'a str, Value);++/// The commands that apply `a`'s `fill`, `stroke`, `strokeWidth`, `dash`, `cap` and `join`, without+/// targets, and what each applies.+fn paint_steps(a: &Args) -> Result<(Vec<Step<'static>>, Map<String, Value>), String> {+ let (mut steps, mut applied) = (vec![], Map::new());if let Some(f) = a.get("fill") {- exec(b, "paint.setFill", with_ids(paint_params(f)?))?;+ steps.push(("paint.setFill", paint_params(f)?));applied.insert("fill".into(), f.clone());}if let Some(s) = a.get("stroke") {- exec(b, "paint.setStroke", with_ids(paint_params(s)?))?;+ steps.push(("paint.setStroke", paint_params(s)?));applied.insert("stroke".into(), s.clone());}// Weight, dash, cap and join go to one stroke.set.@@ -558,7 +557,18 @@ fn apply_paint(b: &mut dyn Backend, a: &Args, ids: Option<Value>) -> Result<Valu}}if !stroke.is_empty() {- exec(b, "stroke.set", with_ids(Value::Object(stroke)))?;+ steps.push(("stroke.set", Value::Object(stroke)));+ }+ Ok((steps, applied))+}++fn apply_paint(b: &mut dyn Backend, a: &Args, ids: Option<Value>) -> Result<Value, String> {+ let (steps, applied) = paint_steps(a)?;+ for (cmd, mut p) in steps {+ if let Some(ids) = &ids {+ p["ids"] = ids.clone();+ }+ exec(b, cmd, p)?;}Ok(Value::Object(applied))}@@ -609,9 +619,18 @@ fn check_draw_options(b: &mut dyn Backend, a: &Args) -> Result<(), String> {Ok(())}-/// Applies the checked options of [`check_draw_options`] to the new object `ids`, adding what was-/// applied to `made`. Paint and stroke options are [`apply_paint`]'s.-fn apply_draw_options(b: &mut dyn Backend, a: &Args, ids: Option<Value>, made: &mut Value) -> Result<(), String> {+/// Draws an object with `create` (a creating command and its params) and styles it with `a`'s+/// paint and draw options ([`check_draw_options`], checked first) as ONE `command.batch`, named+/// `label` (the undo step the creating command makes on its own): any step the engine refuses — a+/// colour it can't read, a swatch the document lacks — rolls the whole call back, so it leaves no+/// object and no undo step behind (#3545). The styling steps act on the new object, which the+/// creating command selects, and on its whole appearance (`item: null`) → `made` with the new+/// object's `id`, the `paint` applied and the other options applied.+fn draw(b: &mut dyn Backend, a: &Args, label: &str, create: Step<'_>, mut made: Value) -> Result<Value, String> {+ check_draw_options(b, a)?;+ let (paint, applied) = paint_steps(a)?;+ let mut steps = vec![create];+ steps.extend(paint);let mut props = json!({});for k in ["name", "opacity"] {if let Some(v) = a.get(k) {@@ -619,34 +638,40 @@ fn apply_draw_options(b: &mut dyn Backend, a: &Args, ids: Option<Value>, made: &made[k] = v.clone();}}- if let Some(ids) = &ids {- props["ids"] = ids.clone();- }if a.contains_key("name") || a.contains_key("opacity") {- exec(b, "object.setProps", props)?;+ steps.push(("object.setProps", props));}- let effects = a.get("effects").and_then(Value::as_array).filter(|e| !e.is_empty());- if let Some(effects) = effects {- let mut applied = vec![];- for e in effects {- // The whole object (item: null), as the Effect menu applies it.- let mut p = json!({"effect": e.get("effect"), "params": e.get("params").cloned().unwrap_or(json!({})), "item": null});- if let Some(ids) = &ids {- p["ids"] = ids.clone();+ // The fill, stroke and effects go to the new object's whole appearance (item: null), as the+ // Fill and Stroke proxies and the Effect menu apply them to a selected object.+ let effects = a.get("effects").and_then(Value::as_array).map(Vec::as_slice).unwrap_or_default();+ for e in effects {+ steps.push(("effect.apply", json!({"effect": e.get("effect"), "params": e.get("params").cloned().unwrap_or(json!({}))})));+ }+ let commands: Vec<Value> = steps+ .into_iter()+ .map(|(cmd, mut p)| {+ if matches!(cmd, "paint.setFill" | "paint.setStroke" | "stroke.set" | "effect.apply") {+ p["item"] = Value::Null;}- applied.push(exec(b, "effect.apply", p)?);- }- made["effects"] = Value::Array(applied);+ json!({"command": cmd, "params": p})+ })+ .collect();+ // The engine names the failed step of its batch; the caller sent no batch, so the reply gives+ // the step's own error.+ let r = exec(b, "command.batch", json!({"label": label, "commands": commands})).map_err(|e| match e.split_once(" failed: ") {+ Some((step, error)) if step.starts_with("batch step ") => error.to_string(),+ _ => e,+ })?;+ let results = r.get("results").and_then(Value::as_array).ok_or("command.batch returned no results")?;+ made["id"] = results.first().and_then(|r| r.get("id")).cloned().unwrap_or(Value::Null);+ made["paint"] = Value::Object(applied);+ if !effects.is_empty() {+ made["effects"] = Value::Array(results.iter().skip(results.len().saturating_sub(effects.len())).cloned().collect());}- Ok(())-}--fn created_id(r: &Value) -> Option<Value> {- r.get("id").filter(|v| v.is_u64()).map(|id| json!([id]))+ Ok(made)}fn draw_path(b: &mut dyn Backend, a: &Args) -> Result<Value, String> {- check_draw_options(b, a)?;let mut p = json!({});if let Some(d) = a.get("d").and_then(Value::as_str) {p["d"] = json!(d);@@ -667,33 +692,26 @@ fn draw_path(b: &mut dyn Backend, a: &Args) -> Result<Value, String> {p["anchors"] = Value::Array(anchors);p["closed"] = json!(a.get("closed").and_then(Value::as_bool).unwrap_or(false));}- let r = exec(b, "path.create", p)?;- let paint = apply_paint(b, a, created_id(&r))?;- let mut made = json!({"id": r.get("id"), "paint": paint});- apply_draw_options(b, a, created_id(&r), &mut made)?;- Ok(made)+ draw(b, a, "Pen", ("path.create", p), json!({}))}fn draw_shape(b: &mut dyn Backend, a: &Args) -> Result<Value, String> {let shape = req_str(a, "shape")?;- let cmd = match shape {- "rectangle" | "rect" => "shape.rectangle",- "ellipse" | "circle" => "shape.ellipse",- "polygon" => "shape.polygon",- "star" => "shape.star",- "line" => "shape.line",+ // Each command and the name of the undo step it makes.+ let (cmd, label) = match shape {+ "rectangle" | "rect" if a.get("radius").and_then(Value::as_f64).is_some_and(|r| r > 0.0) => ("shape.rectangle", "Rounded Rectangle"),+ "rectangle" | "rect" => ("shape.rectangle", "Rectangle"),+ "ellipse" | "circle" => ("shape.ellipse", "Ellipse"),+ "polygon" => ("shape.polygon", "Polygon"),+ "star" => ("shape.star", "Star"),+ "line" => ("shape.line", "Line"),other => return Err(format!("unknown shape `{other}` (rectangle, ellipse, polygon, star, line)")),};- check_draw_options(b, a)?;let mut p = a.clone();for k in ["shape", "fill", "stroke", "strokeWidth", "dash", "cap", "join", "opacity", "name", "effects"] {p.remove(k);}- let r = exec(b, cmd, Value::Object(p))?;- let paint = apply_paint(b, a, created_id(&r))?;- let mut made = json!({"id": r.get("id"), "shape": shape, "paint": paint});- apply_draw_options(b, a, created_id(&r), &mut made)?;- Ok(made)+ draw(b, a, label, (cmd, Value::Object(p)), json!({"shape": shape}))}/// Select `ids` when given (tools that act on the selection).diff --git a/docs/mcp.md b/docs/mcp.mdindex 750e3e11e..95bbcfda7 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -332,7 +332,9 @@ also style the new object in the same call: `dash` (lengths, or null for solid),(butt|round|square) and `join` (miter|round|bevel) go to `stroke.set` with `strokeWidth`; `opacity` (0–100 %)and `name` to `object.setProps`; `effects: [{effect, params?}]` are applied in order as `apply_effect`does, to the whole object. They are checked before anything is drawn (effect ids against `effect.list`),-so a bad one draws nothing. The reply adds `name`, `opacity` and `effects` (each `effect.apply` result)+so a bad one draws nothing. The object and its styling are one `command.batch`, so the call is one undo step+(named as the drawing command names its own, e.g. Pen or Rectangle) and a paint the engine refuses (a colour+it can't read, a swatch the document lacks) fails the call and leaves the document as it was. The reply adds `name`, `opacity` and `effects` (each `effect.apply` result)when given; `paint` lists the stroke options applied.A gradient given to several objects fits each one's own bounds; `paint.setFill` / `paint.setStroke` with`span: "selection"` place a linear or radial gradient once on the union of the targets' bounds instead, so one