* claim: #5962 * Timeline: reorder anyway (allow_errors) and report the features the move breaks (#5962) timeline.reorder and timeline.reorder_many refuse a move after which a feature that worked would fail. Sometimes breaking a later feature is the point: an agent restructuring a design wants the move made, then the list of what broke so it can repair those features next. Both take allow_errors (default false: refused as before). With it the move is made and the reply lists broken: [{feature, error}] (empty when nothing broke); one undo puts the order back. timeline.reorder_many also takes active, as timeline.reorder does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
b4acd83c78
commit
3f6b9fe89f
2 files changed
+77
-11
No files matched your search
@@ -45,9 +45,9 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("timeline.roll_to", "Roll History Marker", roll_to).icon("rollback")
|
||||
.params("position: number of features to keep active, or \"end\" (omit = end) | feature: id|name (the marker goes right after it)"),
|
||||
CommandSpec::new("timeline.reorder", "Reorder Feature", reorder).icon("reorder")
|
||||
.params("feature: id|name, position: its new index, active?: bool (true = it ends up before the history marker, false = behind it; other features keep their state); refused when a feature that worked would fail"),
|
||||
.params("feature: id|name, position: its new index, active?: bool (true = it ends up before the history marker, false = behind it; other features keep their state); refused when a feature that worked would fail, unless allow_errors?: bool (default false): then made, and broken: [{feature, error}] lists the features it broke"),
|
||||
CommandSpec::new("timeline.reorder_many", "Reorder Features", reorder_many).icon("reorder").params(
|
||||
"features: [id|name], position: insertion slot in the current history; selected features keep their relative order; refused when a feature that worked would fail",
|
||||
"features: [id|name], position: insertion slot in the current history; selected features keep their relative order; active?: bool (as timeline.reorder's); refused when a feature that worked would fail, unless allow_errors?: bool (default false): then made, and broken: [{feature, error}] lists the features it broke",
|
||||
),
|
||||
CommandSpec::new("timeline.redefine", "Edit Feature", redefine).icon("edit")
|
||||
.params("feature: id|name, command: the feature's command id, params: its parameters (the feature is rebuilt in place)"),
|
||||
@@ -518,7 +518,7 @@ fn move_many(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
sort_group_features(&mut next);
|
||||
let slot = num(p, "position").map(|x| x.max(0.0) as usize).ok_or_else(|| bad(cmd, "`position` must be a number"))?;
|
||||
let active = active_param(p, cmd)?;
|
||||
let (mut next, ordered) = reorder_features(s, next, &moving, slot, cmd)?;
|
||||
let (mut next, ordered, _) = reorder_features(s, next, &moving, slot, false, cmd)?;
|
||||
place_marker(s, &mut next, &moving, active, cmd)?;
|
||||
if next != *s.doc {
|
||||
*s.doc_mut() = next;
|
||||
@@ -1169,7 +1169,9 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let mut after = s.model.clone();
|
||||
after.evaluate(&next);
|
||||
let broken = newly_broken(&s.model, &after);
|
||||
if !broken.is_empty() {
|
||||
// `allow_errors`: made anyway, with what it broke said (#5962).
|
||||
let allow = allow_errors(p, cmd)?;
|
||||
if !broken.is_empty() && !allow {
|
||||
let list: Vec<String> = broken.iter().map(|(n, e)| format!("{n} ({e})")).collect();
|
||||
return Err(bad(cmd, format!("moving {name} there breaks {}", list.join("; "))));
|
||||
}
|
||||
@@ -1177,7 +1179,25 @@ fn reorder(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if next != *s.doc {
|
||||
*s.doc_mut() = next;
|
||||
}
|
||||
Ok(json!({"feature": id, "position": to}))
|
||||
let mut out = json!({"feature": id, "position": to});
|
||||
if allow {
|
||||
out["broken"] = broken_json(&broken);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The optional `allow_errors` of a move: make it even when it breaks features that worked.
|
||||
fn allow_errors(p: &Value, cmd: &str) -> Result<bool> {
|
||||
match p.get("allow_errors") {
|
||||
None | Some(Value::Null) => Ok(false),
|
||||
Some(Value::Bool(allow)) => Ok(*allow),
|
||||
Some(_) => Err(bad(cmd, "`allow_errors` must be true or false")),
|
||||
}
|
||||
}
|
||||
|
||||
/// The features a move broke, as `[{feature, error}]`.
|
||||
fn broken_json(broken: &[(String, String)]) -> Value {
|
||||
broken.iter().map(|(feature, error)| json!({"feature": feature, "error": error})).collect()
|
||||
}
|
||||
|
||||
/// The optional `active` of a move: whether the moved features end up before the history marker.
|
||||
@@ -1210,11 +1230,18 @@ fn reorder_many(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "timeline.reorder_many";
|
||||
let ids = group_features(s, p, true, cmd)?;
|
||||
let slot = num(p, "position").map(|x| x.max(0.0) as usize).ok_or_else(|| bad(cmd, "`position` must be a number"))?;
|
||||
let (next, ordered) = reorder_features(s, (*s.doc).clone(), &ids, slot, cmd)?;
|
||||
let active = active_param(p, cmd)?;
|
||||
let allow = allow_errors(p, cmd)?;
|
||||
let (mut next, ordered, broken) = reorder_features(s, (*s.doc).clone(), &ids, slot, allow, cmd)?;
|
||||
place_marker(s, &mut next, &ordered, active, cmd)?;
|
||||
if next != *s.doc {
|
||||
*s.doc_mut() = next;
|
||||
}
|
||||
Ok(json!({"features": ordered, "position": slot.min(s.doc.features.len())}))
|
||||
let mut out = json!({"features": ordered, "position": slot.min(s.doc.features.len())});
|
||||
if allow {
|
||||
out["broken"] = broken_json(&broken);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn reorder_features(
|
||||
@@ -1222,8 +1249,9 @@ fn reorder_features(
|
||||
mut next: solidcraft_doc::Document,
|
||||
ids: &[u64],
|
||||
slot: usize,
|
||||
allow_errors: bool,
|
||||
cmd: &str,
|
||||
) -> Result<(solidcraft_doc::Document, Vec<u64>)> {
|
||||
) -> Result<(solidcraft_doc::Document, Vec<u64>, Vec<(String, String)>)> {
|
||||
let n = next.features.len();
|
||||
let slot = slot.min(n);
|
||||
let selected: std::collections::BTreeSet<u64> = ids.iter().copied().collect();
|
||||
@@ -1248,16 +1276,17 @@ fn reorder_features(
|
||||
next.features.splice(insert_at..insert_at, moving);
|
||||
sort_group_features(&mut next);
|
||||
require_contiguous_groups(&next, cmd)?;
|
||||
let mut broken = Vec::new();
|
||||
if !unchanged {
|
||||
let mut after = solidcraft_doc::Model::new();
|
||||
after.evaluate(&next);
|
||||
let broken = newly_broken(&s.model, &after);
|
||||
if !broken.is_empty() {
|
||||
broken = newly_broken(&s.model, &after);
|
||||
if !broken.is_empty() && !allow_errors {
|
||||
let list: Vec<String> = broken.iter().map(|(name, error)| format!("{name} ({error})")).collect();
|
||||
return Err(bad(cmd, format!("moving the selected features there breaks {}", list.join("; "))));
|
||||
}
|
||||
}
|
||||
Ok((next, ordered))
|
||||
Ok((next, ordered, broken))
|
||||
}
|
||||
|
||||
fn input_keys(kind: &FeatureKind) -> Vec<(String, solidcraft_doc::expr::Kind)> {
|
||||
|
||||
@@ -589,6 +589,43 @@ fn timeline_moves_across_the_marker_are_one_undo_step() {
|
||||
assert_eq!(s.undo.len(), undo, "a refused move adds no undo step");
|
||||
}
|
||||
|
||||
/// #5962: a reorder that breaks a feature is refused unless `allow_errors`; with it the move is
|
||||
/// made, the reply lists what broke, and one undo puts the order back. For both reorder commands.
|
||||
#[test]
|
||||
fn reorder_with_allow_errors_is_made_and_lists_what_broke() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base"}));
|
||||
run(&mut s, "solid.fillet", json!({"edges": [[10, 5, 10]], "radius": 1, "name": "Round"}));
|
||||
let order = |s: &Session| s.doc.features.iter().map(|f| f.name.clone()).collect::<Vec<_>>();
|
||||
let before = s.doc.clone();
|
||||
for (cmd, params) in
|
||||
[("timeline.reorder", json!({"feature": "Round", "position": 0})), ("timeline.reorder_many", json!({"features": ["Round"], "position": 0}))]
|
||||
{
|
||||
let error = s.execute(cmd, ¶ms).unwrap_err().to_string();
|
||||
assert!(error.contains("breaks Round"), "{cmd}: {error}");
|
||||
assert_eq!(s.doc, before, "{cmd}: refused, nothing moved");
|
||||
let mut anyway = params.clone();
|
||||
anyway["allow_errors"] = json!(true);
|
||||
let r = run(&mut s, cmd, anyway);
|
||||
assert_eq!(order(&s), ["Round", "Base"], "{cmd}");
|
||||
let broken = r["broken"].as_array().unwrap();
|
||||
assert_eq!(broken.len(), 1, "{cmd}: {r}");
|
||||
assert_eq!(broken[0]["feature"], "Round", "{cmd}: {r}");
|
||||
assert!(broken[0]["error"].as_str().is_some_and(|e| !e.is_empty()), "{cmd}: {r}");
|
||||
run(&mut s, "edit.undo", json!({}));
|
||||
assert_eq!(s.doc, before, "{cmd}: one undo puts the order back");
|
||||
}
|
||||
// A move that breaks nothing says so, and refuses anything but a boolean.
|
||||
run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [20, 0, 0], "operation": "new", "name": "Other"}));
|
||||
let r = run(&mut s, "timeline.reorder_many", json!({"features": ["Other"], "position": 0, "allow_errors": true}));
|
||||
assert_eq!(r["broken"], json!([]));
|
||||
assert!(s.execute("timeline.reorder", &json!({"feature": "Other", "position": 2, "allow_errors": "yes"})).is_err());
|
||||
// `reorder_many` takes `active` too: the moved feature ends up behind the history marker.
|
||||
run(&mut s, "timeline.reorder_many", json!({"features": ["Other"], "position": 3, "active": false}));
|
||||
assert_eq!(order(&s).last().map(String::as_str), Some("Other"));
|
||||
assert_eq!(s.doc.marker, Some(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_timeline_move_many_keeps_folder_membership_and_order() {
|
||||
let mut s = Session::default();
|
||||
|
||||
Reference in new issue
Block a user