2bc41aeb8602
actions_automatic_align.rs
//! An action's opt-in Align To follows the selection at playback without rewriting its recording.
// Integration tests may unwrap and panic (AGENTS.md, Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::sync::Mutex;
use serde_json::{Value, json};
use vectorcraft_doc::{Document, NodeId};
use vectorcraft_engine::Session;
use vectorcraft_ui_egui::panels::actions::{self, ActionSet};
use vectorcraft_ui_egui::{UiState, VectorcraftApp};
static CASE: Mutex<()> = Mutex::new(());
struct CenterRecording {
document: Document,
a: NodeId,
b: NodeId,
ui: Value,
raw_steps: Value,
}
fn bounds(app: &VectorcraftApp, id: NodeId) -> [f64; 4] {
let b = app.session.active().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap();
[b.x0, b.y0, b.x1, b.y1]
}
fn close(actual: [f64; 4], expected: [f64; 4]) -> bool {
actual.into_iter().zip(expected).all(|(a, e)| (a - e).abs() < 1e-8)
}
/// Record Center exactly once through New Action, the two actual Align commands, and Stop.
fn record_center(automatic: bool) -> CenterRecording {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300, "profile": null})).unwrap();
app.run("paint.setStroke", json!({"none": true})).unwrap();
let a = NodeId(app.run("shape.rectangle", json!({"x": 20, "y": 40, "width": 40, "height": 20})).unwrap()["id"].as_u64().unwrap());
let b = NodeId(app.run("shape.rectangle", json!({"x": 180, "y": 120, "width": 80, "height": 60})).unwrap()["id"].as_u64().unwrap());
let document = (*app.session.active().unwrap().doc).clone();
assert!(close(bounds(&app, a), [20.0, 40.0, 60.0, 60.0]));
assert!(close(bounds(&app, b), [180.0, 120.0, 260.0, 180.0]));
app.run("select.set", json!({"ids": [a.0, b.0]})).unwrap();
app.run("select.key", json!({"id": b.0})).unwrap();
app.ui.action_sets = vec![ActionSet::new("Automatic Align", vec![])];
let new_action = if automatic { json!({"set": 0, "name": "Center", "automaticAlignTo": true}) } else { json!({"set": 0, "name": "Center"}) };
app.run(actions::NEW_ACTION, new_action).unwrap();
app.run("object.align", json!({"horizontal": "center", "to": "key"})).unwrap();
app.run("object.align", json!({"vertical": "center", "to": "key"})).unwrap();
app.run(actions::STOP_RECORDING, json!({})).unwrap();
let action = &app.ui.action_sets[0].actions[0];
assert_eq!(action.steps.len(), 2);
assert!(action.steps.iter().all(|(id, p)| id == "object.align" && p["to"] == "key"));
assert_eq!(action.automatic_align_to, automatic, "New Action sets the option it is given");
let raw_steps = serde_json::to_value(&action.steps).unwrap();
let ui = serde_json::to_value(&app.ui).unwrap();
CenterRecording { document, a, b, ui, raw_steps }
}
fn playback_app(recording: &CenterRecording, only_a: bool, key: bool) -> VectorcraftApp {
let mut session = Session::new();
session.add_document(recording.document.clone(), None);
let mut app = VectorcraftApp::new(session, Default::default());
// Real UiState serialization/deserialization, not a separately authored Center action.
app.ui = serde_json::from_slice::<UiState>(&serde_json::to_vec(&recording.ui).unwrap()).unwrap();
let ids = if only_a { vec![recording.a.0] } else { vec![recording.a.0, recording.b.0] };
app.run("select.set", json!({"ids": ids})).unwrap();
if key {
app.run("select.key", json!({"id": recording.b.0})).unwrap();
} else {
app.run("select.key", json!({})).unwrap();
}
app
}
#[derive(Debug)]
struct Observation {
label: &'static str,
result: Result<Value, String>,
actual: [[f64; 4]; 2],
expected: [[f64; 4]; 2],
raw_unchanged: bool,
selection_unchanged: bool,
undo_steps: usize,
undo_restored: bool,
}
#[test]
fn automatic_center_recording_resolves_all_three_playback_selections() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(true);
let mut observed = vec![];
for (label, only_a, key, expected) in [
("one object / artboard", true, false, [[180.0, 140.0, 220.0, 160.0], [180.0, 120.0, 260.0, 180.0]]),
("two objects / B key", false, true, [[200.0, 140.0, 240.0, 160.0], [180.0, 120.0, 260.0, 180.0]]),
("two objects / selection", false, false, [[120.0, 100.0, 160.0, 120.0], [100.0, 80.0, 180.0, 140.0]]),
] {
let mut app = playback_app(&recording, only_a, key);
let selection = app.session.active().unwrap().selection.clone();
let undo = app.session.active().unwrap().history.undo.len();
let result = actions::play(&mut app, 0, 0);
let actual = [bounds(&app, recording.a), bounds(&app, recording.b)];
let raw_unchanged = serde_json::to_value(&app.ui.action_sets[0].actions[0].steps).unwrap() == recording.raw_steps;
let selection_unchanged = app.session.active().unwrap().selection == selection;
let undo_steps = app.session.active().unwrap().history.undo.len().saturating_sub(undo);
let undo_restored = result.is_ok()
&& app.run("edit.undo", json!({})).is_ok()
&& close(bounds(&app, recording.a), [20.0, 40.0, 60.0, 60.0])
&& close(bounds(&app, recording.b), [180.0, 120.0, 260.0, 180.0]);
observed.push(Observation { label, result, actual, expected, raw_unchanged, selection_unchanged, undo_steps, undo_restored });
}
// All three actual playbacks, including the legitimate B-key control, precede assertions.
println!("automatic Center raw steps: {}", recording.raw_steps);
println!("automatic Center playback observations: {observed:#?}");
for o in observed {
assert!(o.result.is_ok(), "{}: expected automatic reference selection, got {:?}", o.label, o.result);
assert!(close(o.actual[0], o.expected[0]) && close(o.actual[1], o.expected[1]), "{}: {o:?}", o.label);
assert!(o.raw_unchanged, "{}: playback must not rewrite the stored recording", o.label);
assert!(o.selection_unchanged, "{}: selected IDs and key remain unchanged", o.label);
assert_eq!(o.undo_steps, 1, "{}: Accelerated Center is one undo step", o.label);
assert!(o.undo_restored, "{}: one Undo restores both original rectangles", o.label);
}
}
#[test]
fn legacy_center_without_the_option_keeps_its_frozen_key_target() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(false);
assert!(recording.ui["action_sets"][0]["actions"][0].get("automaticAlignTo").is_none());
let mut app = playback_app(&recording, true, false);
let error = actions::play(&mut app, 0, 0).unwrap_err();
assert!(error.to_lowercase().contains("key"), "{error}");
assert!(close(bounds(&app, recording.a), [20.0, 40.0, 60.0, 60.0]));
assert!(close(bounds(&app, recording.b), [180.0, 120.0, 260.0, 180.0]));
assert_eq!(serde_json::to_value(&app.ui.action_sets[0].actions[0].steps).unwrap(), recording.raw_steps);
}
fn raw_steps(app: &VectorcraftApp) -> Value {
serde_json::to_value(&app.ui.action_sets[0].actions[0].steps).unwrap()
}
fn automatic_flag(app: &VectorcraftApp) -> bool {
serde_json::to_value(&app.ui.action_sets[0].actions[0]).unwrap()["automaticAlignTo"].as_bool().unwrap_or(false)
}
#[test]
fn automatic_align_options_toggle_restores_the_original_recorded_targets() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(true);
let mut app = playback_app(&recording, false, false);
app.run(actions::ACTION_OPTIONS, json!({"set": 0, "action": 0, "automaticAlignTo": false})).unwrap();
assert!(!automatic_flag(&app));
let error = actions::play(&mut app, 0, 0).unwrap_err();
assert!(error.to_lowercase().contains("key"), "{error}");
assert_eq!(raw_steps(&app), recording.raw_steps, "turning the option off does not replace recorded params");
assert!(close(bounds(&app, recording.a), [20.0, 40.0, 60.0, 60.0]));
app.run(actions::ACTION_OPTIONS, json!({"set": 0, "action": 0, "automaticAlignTo": true})).unwrap();
assert!(automatic_flag(&app));
let copy = app.ui.action_sets[0].actions[0].copy();
assert_eq!(serde_json::to_value(copy).unwrap()["automaticAlignTo"], true, "copying retains the per-action choice");
actions::play(&mut app, 0, 0).unwrap();
assert!(close(bounds(&app, recording.a), [120.0, 100.0, 160.0, 120.0]));
assert!(close(bounds(&app, recording.b), [100.0, 80.0, 180.0, 140.0]));
assert_eq!(raw_steps(&app), recording.raw_steps);
}
#[test]
fn automatic_align_observes_selection_changed_by_an_earlier_accelerated_step() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(true);
let mut app = playback_app(&recording, false, true);
app.ui.action_sets[0].actions[0].steps.insert(0, ("select.set".into(), json!({"ids": [recording.a.0]})));
let raw = raw_steps(&app);
let undo = app.session.active().unwrap().history.undo.len();
actions::play(&mut app, 0, 0).unwrap();
assert!(close(bounds(&app, recording.a), [180.0, 140.0, 220.0, 160.0]), "the new one-object selection uses the artboard, not the former key");
assert!(close(bounds(&app, recording.b), [180.0, 120.0, 260.0, 180.0]));
assert_eq!(raw_steps(&app), raw);
assert_eq!(app.session.active().unwrap().history.undo.len(), undo + 1);
app.run("edit.undo", json!({})).unwrap();
assert!(close(bounds(&app, recording.a), [20.0, 40.0, 60.0, 60.0]));
}
#[test]
fn automatic_align_step_speed_and_stop_continue_share_the_compiled_choice() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(true);
let mut app = playback_app(&recording, true, false);
app.ui.action_sets[0].actions[0].steps.insert(1, (actions::STOP_STEP.into(), json!({"message": "Choose B as key", "allowContinue": true})));
let raw = raw_steps(&app);
app.run(actions::PLAYBACK_OPTIONS, json!({"speed": "step"})).unwrap();
actions::play(&mut app, 0, 0).unwrap();
assert!(close(bounds(&app, recording.a), [180.0, 40.0, 220.0, 60.0]), "only horizontal Center ran before the Step wait");
assert!(actions::playback_held(&app));
actions::playback_drawn(&mut app);
actions::tick_playback(&mut app, 1.0);
assert!(actions::waiting_at_stop(&app));
// B must differ from the artboard center so a stale artboard reference fails this check.
app.run("select.set", json!({"ids": [recording.b.0]})).unwrap();
app.run("object.move", json!({"dx": 0, "dy": 40})).unwrap();
app.run("select.set", json!({"ids": [recording.a.0, recording.b.0]})).unwrap();
app.run("select.key", json!({"id": recording.b.0})).unwrap();
app.run(actions::CONTINUE_PLAYBACK, json!({})).unwrap();
assert!(app.ui.action_playing.is_none());
assert!(
close(bounds(&app, recording.a), [180.0, 180.0, 220.0, 200.0]),
"continued vertical Center resolves B at y=190, not the artboard at y=150"
);
assert!(close(bounds(&app, recording.b), [180.0, 160.0, 260.0, 220.0]), "the current key stays stationary during Continue");
assert_eq!(raw_steps(&app), raw);
}
// These are the actual host I/O callbacks used by public Save/Load Actions commands.
// The stored bytes are observable without writing user files or exposing private file helpers.
type ActionFiles = std::rc::Rc<std::cell::RefCell<std::collections::BTreeMap<String, Vec<u8>>>>;
fn host_files(app: &mut VectorcraftApp) -> ActionFiles {
let files = ActionFiles::default();
let writes = files.clone();
app.services.write = Some(Box::new(move |path, bytes| {
writes.borrow_mut().insert(path.to_string(), bytes.to_vec());
Ok(())
}));
let reads = files.clone();
app.services.read = Some(Box::new(move |path| reads.borrow().get(path).cloned().ok_or_else(|| format!("no saved action file: {path}"))));
files
}
fn save_file(app: &mut VectorcraftApp, files: &ActionFiles, path: &str) -> Value {
app.run(actions::SAVE_SET, json!({"set": 0, "path": path})).unwrap();
serde_json::from_slice(files.borrow().get(path).unwrap()).unwrap()
}
fn load_only_file(app: &mut VectorcraftApp, path: &str) {
app.ui.action_sets.clear();
let result = app.run(actions::LOAD_SET, json!({"path": path})).unwrap();
assert_eq!(result["set"], 0);
}
#[test]
fn automatic_align_files_preserve_enabled_and_raw_recorded_excluded_semantics() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let recording = record_center(true);
let mut app = playback_app(&recording, false, false);
let files = host_files(&mut app);
let enabled = save_file(&mut app, &files, "enabled.vcactions");
assert_eq!(enabled["version"], 7);
assert_eq!(enabled["actions"][0]["automaticAlignTo"], true);
load_only_file(&mut app, "enabled.vcactions");
assert!(automatic_flag(&app), "public file loading retains the enabled choice");
assert_eq!(raw_steps(&app), recording.raw_steps);
// The destination stays default-false; its automatic meaning comes only from recorded raw steps.
app.run(actions::NEW_ACTION, json!({"set": 0, "name": "Recorded Automatic Center"})).unwrap();
actions::play(&mut app, 0, 0).unwrap();
app.run(actions::STOP_RECORDING, json!({})).unwrap();
let destination = app.ui.action_sets[0].actions[1].clone();
assert_ne!(serde_json::to_value(&destination).unwrap()["automaticAlignTo"], true);
assert_eq!(destination.steps.len(), 1);
assert_eq!(destination.steps[0].0, "command.batch");
let nested = destination.steps[0].1["commands"].as_array().unwrap();
assert_eq!(nested.len(), 2);
assert!(nested.iter().all(|s| s["command"] == "object.align" && s["params"]["to"] == "auto"));
let raw = serde_json::to_value(&destination.steps).unwrap();
app.ui.action_sets = vec![ActionSet::new("Recorded Default-false", vec![destination])];
let recorded = save_file(&mut app, &files, "recorded.vcactions");
assert_eq!(recorded["version"], 7, "raw automatic batches require version 7 even when no action flag is true");
assert_ne!(recorded["actions"][0]["automaticAlignTo"], true);
load_only_file(&mut app, "recorded.vcactions");
assert!(!automatic_flag(&app));
assert_eq!(raw_steps(&app), raw);
let imported = app.ui.action_sets[0].actions[0].clone();
let mut fresh = playback_app(&recording, false, false);
fresh.ui.action_sets = vec![ActionSet::new("Imported", vec![imported])];
actions::play(&mut fresh, 0, 0).unwrap();
assert!(close(bounds(&fresh, recording.a), [120.0, 100.0, 160.0, 120.0]));
assert!(close(bounds(&fresh, recording.b), [100.0, 80.0, 180.0, 140.0]));
app.ui.action_sets[0].actions[0].excluded_steps.insert(0);
let excluded = save_file(&mut app, &files, "excluded.vcactions");
assert_eq!(excluded["version"], 7, "excluding a raw automatic batch does not make its stored semantics compatible with older readers");
load_only_file(&mut app, "excluded.vcactions");
assert!(!automatic_flag(&app));
assert_eq!(raw_steps(&app), raw);
assert!(app.ui.action_sets[0].actions[0].excluded_steps.contains(&0));
// Nested raw batches may be stored/excluded even though command.batch cannot execute nested batches.
// The format requirement follows their retained command semantics, not an executable flattening.
let recorded_batch = app.ui.action_sets[0].actions[0].steps[0].1.clone();
app.ui.action_sets[0].actions[0].steps[0].1 = json!({"commands": [{"command": "command.batch", "params": recorded_batch}]});
let deeper = raw_steps(&app);
assert_eq!(save_file(&mut app, &files, "nested-excluded.vcactions")["version"], 7);
load_only_file(&mut app, "nested-excluded.vcactions");
assert_eq!(raw_steps(&app), deeper);
assert!(app.ui.action_sets[0].actions[0].excluded_steps.contains(&0));
}
const LEGACY_V1: &str = r#"{
"format": "vcactions",
"version": 1,
"name": "Legacy Align",
"actions": [
{
"name": "Frozen Center",
"steps": [
{
"command": "object.align",
"params": {
"horizontal": "center",
"to": "key"
}
}
]
}
]
}"#;
const LEGACY_V6: &str = r#"{
"format": "vcactions",
"version": 6,
"name": "Legacy View",
"actions": [
{
"name": "Zoom",
"steps": [
{
"command": "view.zoomIn",
"params": {}
}
]
}
]
}"#;
#[test]
fn automatic_align_legacy_files_keep_their_old_bytes_and_versions() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let mut app = VectorcraftApp::new(Session::new(), Default::default());
let files = host_files(&mut app);
for (path, wire, version) in [("legacy-v1.vcactions", LEGACY_V1, 1), ("legacy-v6.vcactions", LEGACY_V6, 6)] {
files.borrow_mut().insert(path.into(), wire.as_bytes().to_vec());
load_only_file(&mut app, path);
assert!(!automatic_flag(&app));
let saved = save_file(&mut app, &files, "legacy-resaved.vcactions");
assert_eq!(saved["version"], version);
assert_eq!(files.borrow().get("legacy-resaved.vcactions").unwrap(), wire.as_bytes(), "false-only legacy serialization is byte-equivalent");
}
let future = LEGACY_V6.replace("\"version\": 6", "\"version\": 8");
assert!(app.run(actions::LOAD_SET, json!({"data": future})).unwrap_err().contains("later version"));
}
#[test]
fn automatic_align_ignores_an_artboard_the_step_stores() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300, "artboards": 2, "profile": null})).unwrap();
app.run("paint.setStroke", json!({"none": true})).unwrap();
let a = NodeId(app.run("shape.rectangle", json!({"x": 20, "y": 40, "width": 40, "height": 20})).unwrap()["id"].as_u64().unwrap());
app.run("select.set", json!({"ids": [a.0]})).unwrap();
let center = json!({"horizontal": "center", "vertical": "center", "to": "artboard"});
app.run("object.align", center.clone()).unwrap();
let current = bounds(&app, a);
app.run("edit.undo", json!({})).unwrap();
let mut stored = center;
stored["artboard"] = json!(1);
app.run("object.align", stored.clone()).unwrap();
let second = bounds(&app, a);
app.run("edit.undo", json!({})).unwrap();
assert!(!close(current, second), "the two artboards center the rectangle in different places");
let mut action = actions::Action::new("Center", vec![("object.align".into(), stored.clone())]);
action.automatic_align_to = true;
app.ui.action_sets = vec![ActionSet::new("Automatic Align", vec![action])];
actions::play(&mut app, 0, 0).unwrap();
assert!(close(bounds(&app, a), current), "automatic playback uses the current artboard, not the stored one");
assert_eq!(app.ui.action_sets[0].actions[0].steps[0].1, stored, "the stored step keeps its artboard");
}
#[test]
fn automatic_align_inside_a_recorded_batch_run_needs_version_7() {
let _case = CASE.lock().unwrap_or_else(|e| e.into_inner());
let mut app = VectorcraftApp::new(Session::new(), Default::default());
let files = host_files(&mut app);
let align = json!({"command": "object.align", "params": {"horizontal": "center", "to": "auto"}});
let batch = json!({"commands": [align], "label": "Center", "source": "datasets", "destination": "none"});
let action = actions::Action::new("Batch Center", vec![("action.batch".into(), batch.clone())]);
app.ui.action_sets = vec![ActionSet::new("Recorded Batch", vec![action])];
let saved = save_file(&mut app, &files, "batch.vcactions");
assert_eq!(saved["version"], 7, "a Batch run's automatic Align step needs a reader that knows `to: \"auto\"`");
assert_ne!(saved["actions"][0]["automaticAlignTo"], true);
load_only_file(&mut app, "batch.vcactions");
assert_eq!(app.ui.action_sets[0].actions[0].steps[0].1, batch);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.