Merge pull request #90 from SteamSmith/fix/undo-merge-ends

fix(engine): end undo merge runs at gesture and request boundaries
This commit is contained in:
Rafael Mendes authored and GitHub committed 2026-11-05 15:39:29 -03:00
commit 63cb7db0c5
7 files changed
+146 -5

No files matched your search

+9 -1
View File
@@ -127,7 +127,11 @@ impl Headless {
if !self.trusted() {
authorize_command(id, &params)?;
}
Ok(materialcraft_engine::execute(&mut self.session, id, &params)?)
// Each request is its own undo step, never merged with a neighbour's.
self.session.end_merge();
let r = materialcraft_engine::execute(&mut self.session, id, &params);
self.session.end_merge();
Ok(r?)
}
/// Run `[{id, params?}]` in order, stopping at the first error (reported with its index).
@@ -306,3 +310,7 @@ pub fn batch_reply(results: Vec<Value>, failed: Option<(usize, &str, String)>) -
"failed": failed.map(|(index, id, error)| json!({ "index": index, "id": id, "error": error })),
})
}
#[cfg(test)]
#[path = "headless.test.rs"]
mod tests;
+16
View File
@@ -0,0 +1,16 @@
#[cfg(test)]
mod end_merge_tests {
use crate::headless::{Filesystem, Headless};
use serde_json::json;
#[test]
fn two_param_requests_are_two_undo_steps() {
let mut h = Headless::new(Headless::default_session(), Filesystem::TrustedLocal);
h.command_run("file.new", json!({"template": "empty"})).unwrap();
let id = h.command_run("graph.node.add", json!({"def": "levels"})).unwrap()["id"].as_u64().unwrap();
let sets = |h: &Headless| h.session.history().iter().filter(|l| *l == "Set parameter").count();
h.command_run("graph.node.param", json!({"id": id, "param": "in_low", "value": 0.3})).unwrap();
h.command_run("graph.node.param", json!({"id": id, "param": "in_low", "value": 0.4})).unwrap();
assert_eq!(sets(&h), 2, "separate requests must not merge");
}
}
+23 -3
View File
@@ -122,6 +122,8 @@ struct Snapshot {
graph: usize,
selection: Vec<NodeId>,
label: String,
modified: bool,
dirty: bool,
}
/// Nodes and connections copied to the clipboard (as JSON, so other sessions can paste them).
@@ -207,7 +209,14 @@ impl Session {
}
fn snapshot(&self, label: &str) -> Snapshot {
Snapshot { pkg: self.pkg.clone(), graph: self.graph, selection: self.selection.clone(), label: label.into() }
Snapshot {
pkg: self.pkg.clone(),
graph: self.graph,
selection: self.selection.clone(),
label: label.into(),
modified: self.modified,
dirty: self.dirty,
}
}
/// Run `f` as one undoable step. On error the session is restored.
@@ -220,9 +229,12 @@ impl Session {
/// make a single undo step.
pub fn edit_merged<T>(&mut self, key: &str, label: &str, f: impl FnOnce(&mut Session) -> Result<T>) -> Result<T> {
if self.merge_key.as_deref() == Some(key) && !self.undo.is_empty() {
// The merged step keeps its original snapshot; restore the session if `f` fails.
let snap = self.snapshot(label);
let r = f(self);
if r.is_ok() {
self.changed();
match &r {
Ok(_) => self.changed(),
Err(_) => self.restore(snap),
}
return r;
}
@@ -233,6 +245,12 @@ impl Session {
r
}
/// End the current coalescing run: the next [`Session::edit_merged`] starts a new undo step.
/// Call it when a gesture ends (pointer release) and once per control or MCP request.
pub fn end_merge(&mut self) {
self.merge_key = None;
}
fn edit_inner<T>(&mut self, label: &str, f: impl FnOnce(&mut Session) -> Result<T>) -> Result<T> {
let snap = self.snapshot(label);
match f(self) {
@@ -256,6 +274,8 @@ impl Session {
self.pkg = s.pkg;
self.graph = s.graph.min(self.pkg.graphs.len().saturating_sub(1));
self.selection = s.selection;
self.modified = s.modified;
self.dirty = s.dirty;
}
/// Mark the document modified and in need of a cook.
+61
View File
@@ -36,3 +36,64 @@ fn the_resource_decoder_reads_data_maps_as_stored() {
assert!((data.get(0, 0, false)[0] - 0.5).abs() < 0.01);
assert!((data.get(0, 0, false)[2] - 1.0).abs() < 0.01);
}
#[cfg(test)]
mod merge_tests {
use crate::{EngineError, Session};
fn session() -> Session {
crate::sample_session()
}
fn set(s: &mut Session, key: &str) {
s.edit_merged(key, "Set parameter", |s| {
s.modified = true;
Ok(())
})
.unwrap();
}
#[test]
fn same_key_merges_until_end_merge() {
let mut s = session();
let base = s.history().len();
set(&mut s, "k");
set(&mut s, "k");
assert_eq!(s.history().len(), base + 1, "one drag is one entry");
s.end_merge();
set(&mut s, "k");
assert_eq!(s.history().len(), base + 2, "a second drag after end_merge is a new entry");
}
#[test]
fn failed_merged_edit_restores_the_session() {
let mut s = session();
set(&mut s, "k");
let name = s.pkg.name.clone();
let r: Result<(), EngineError> = s.edit_merged("k", "Set parameter", |s| {
s.pkg.name = "half-applied".into();
Err(EngineError::Other("boom".into()))
});
assert!(r.is_err());
assert_eq!(s.pkg.name, name);
}
}
#[test]
fn failed_merged_edits_restore_clean_flags_and_history() {
let mut s = crate::sample_session();
s.edit_merged("k", "Set", |_| Ok(())).unwrap();
s.modified = false;
s.dirty = false;
let name = s.pkg.name.clone();
let history = s.history();
let result: crate::Result<()> = s.edit_merged("k", "Set", |s| {
s.pkg.name = "partial".into();
s.changed();
Err(crate::EngineError::Other("failed".into()))
});
assert!(result.is_err());
assert_eq!(s.pkg.name, name);
assert_eq!(s.history(), history);
assert!(!s.modified && !s.dirty);
}
+5 -1
View File
@@ -242,7 +242,11 @@ pub fn handle(app: &mut MaterialCraftApp, ctx: &egui::Context, method: &str, p:
"command.run" => {
let Some(id) = p.get("id").and_then(Value::as_str) else { return err("`id` is required") };
let params = p.get("params").cloned().unwrap_or(Value::Null);
match crate::cook::execute_guarded(&mut app.session, id, &params) {
// Each request ends its own coalescing run, including failed requests.
app.session.end_merge();
let r = crate::cook::execute_guarded(&mut app.session, id, &params);
app.session.end_merge();
match r {
Ok(v) => {
if id == "view.previewSize" {
app.ui.prefs.preview_size = app.session.preview_size.unwrap_or(0);
+11
View File
@@ -279,11 +279,22 @@ impl MaterialCraftApp {
function_editor::show(self, &ctx);
toasts(self, &ctx);
control::request_screenshots(self, &ctx);
end_gesture_if_released(
&mut self.session,
ctx.input(|i| i.pointer.any_released() || i.key_released(egui::Key::Enter) || i.key_released(egui::Key::Space) || i.key_released(egui::Key::Tab)),
);
let dt = (now_ms() - t0) as f32;
self.ui_ms = if self.ui_ms == 0.0 { dt } else { self.ui_ms * 0.9 + dt * 0.1 };
}
}
/// A completed pointer or keyboard action ends the gesture: the next edit is a new undo step.
pub(crate) fn end_gesture_if_released(session: &mut materialcraft_engine::Session, released: bool) {
if released {
session.end_merge();
}
}
/// `Documents/MaterialCraft/<sub>` in the user's home folder.
#[cfg(not(target_arch = "wasm32"))]
pub fn user_dir(sub: &str) -> std::path::PathBuf {
+21
View File
@@ -72,3 +72,24 @@ mod unsaved_state_tests {
assert!(back.windows.unsaved.is_none());
}
}
#[cfg(test)]
mod gesture_tests {
use crate::end_gesture_if_released;
#[test]
fn pointer_release_ends_the_merge_run() {
let mut s = materialcraft_engine::sample_session();
let base = s.history().len();
let set = |s: &mut materialcraft_engine::Session| {
s.edit_merged("k", "Set parameter", |_| Ok(())).unwrap();
};
set(&mut s);
end_gesture_if_released(&mut s, false);
set(&mut s);
assert_eq!(s.history().len(), base + 1, "still dragging: merged");
end_gesture_if_released(&mut s, true);
set(&mut s);
assert_eq!(s.history().len(), base + 2, "released: a new step");
}
}