Merge pull request #5138 from dotCooCoo/fix/vars-p6

Variables: a text value on threaded type replaces the whole story

crates/engine/src/cmd/textedit.rs

@@ -186,6 +186,48 @@ pub(crate) fn set_plain_text(d: &mut vectorcraft_doc::Document, id: NodeId, text
     Ok(())
 }
 
+/// Replace the whole story of the type object `id` as [`set_plain_text`] replaces one type
+/// object's content: for a frame of threaded text, every frame's text. The new text goes into the
+/// thread's first frame and the other frames are emptied; the edit's reflow then pours it through
+/// them. → the story's last frame, which holds any text that does not fit.
+pub(crate) fn set_story_text(d: &mut vectorcraft_doc::Document, id: NodeId, text: &str) -> Result<NodeId> {
+    let story = d.story_of(id);
+    let (Some((&first, rest)), Some(&last)) = (story.split_first(), story.last()) else {
+        return Err(EngineError::NoNode(id));
+    };
+    if rest.is_empty() {
+        set_plain_text(d, id, text)?;
+        return Ok(id);
+    }
+    let frames: Vec<TextObject> = story
+        .iter()
+        .filter_map(|f| match d.node(*f).map(|n| &n.kind) {
+            Some(NodeKind::Text(t)) => Some((**t).clone()),
+            _ => None,
+        })
+        .collect();
+    let refs: Vec<&TextObject> = frames.iter().collect();
+    // The first frame takes the whole story first, so the replace keeps the story's first style
+    // and paragraph styles follow as for one type object.
+    let t = text_mut(d, first).ok_or(EngineError::NoNode(first))?;
+    t.runs = vectorcraft_text::thread::story(&refs);
+    t.set_paragraph_styles(vectorcraft_text::thread::story_paras(&refs, &[]));
+    set_plain_text(d, first, text)?;
+    // An emptied frame's paragraph takes the new text's last paragraph style, so it does not
+    // restyle that paragraph when the story is joined again.
+    let tail = match d.node(first).map(|n| &n.kind) {
+        Some(NodeKind::Text(t)) => t.paragraph_styles().last().cloned().unwrap_or_default(),
+        _ => Default::default(),
+    };
+    for f in rest {
+        let t = text_mut(d, *f).ok_or(EngineError::NoNode(*f))?;
+        t.runs.clear();
+        t.set_paragraph_styles(vec![tail.clone()]);
+        refresh_bounds(t);
+    }
+    Ok(last)
+}
+
 /// The byte offset that `k` holds, read with [`index`].
 fn byte_param(p: &Value, k: &str) -> Option<usize> {
     p.get(k).and_then(Value::as_u64).map(index)

crates/engine/src/cmd/variablecmds.rs

@@ -18,7 +18,7 @@ use vectorcraft_doc::{DataSet, DataValue, NodeId, NodeKind, Variable, VariableKi
 
 use super::edit::selected_roots;
 use super::fileio::{absolute_path, read_file_head, write_file};
-use super::textedit::set_plain_text;
+use super::textedit::set_story_text;
 use super::{CommandSpec, EngineError, Result, Session, bad, bool_or, checked_ids_or_selection, cmd, has_doc, has_selection, links, str_param};
 
 mod csv;
@@ -493,16 +493,20 @@ fn apply_dataset(s: &mut Session, name: &str) -> Result<Value> {
             };
             // Locked art, art in a locked layer or group, and text whose object is gone, can't be
             // rewritten: skipped and counted, like the rest. Hidden art is rewritten, in a hidden
-            // layer or group too, and stays hidden unless a visibility value shows it.
-            if !d.dataset_target(id) {
+            // layer or group too, and stays hidden unless a visibility value shows it. A text value
+            // rewrites the whole story of threaded text, so it skips when any frame of it is locked.
+            let target = if kind == VariableKind::Text { d.story_target(id) } else { d.dataset_target(id) };
+            if !target {
                 skipped += 1;
                 continue;
             }
             let done = match (kind, &value) {
                 // The Type tool's own whole-range replace, so a dataset's text is styled and
-                // laid out exactly as typing it would be.
-                (VariableKind::Text, DataValue::Text(text)) => set_plain_text(d, id, text).is_ok_and(|()| {
-                    typed.push(id);
+                // laid out exactly as typing it would be. A frame of threaded text has its whole
+                // story replaced, the value capture reads from it; the story's last frame is the
+                // one that overflows.
+                (VariableKind::Text, DataValue::Text(text)) => set_story_text(d, id, text).is_ok_and(|last| {
+                    typed.push(last);
                     true
                 }),
                 (VariableKind::Visibility, DataValue::Visible(show)) => d.node_mut(id).is_some_and(|n| {
@@ -676,7 +680,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Capture Data Set",
             ["Window", "Variables"],
             None,
-            "{name?} record what the bound objects hold right now as a new dataset (Data Set 1…), and make it the active one",
+            "{name?} record what the bound objects hold right now as a new dataset (Data Set 1…), and make it the active one; a frame of threaded text holds its whole story, every frame's text in thread order",
             has_doc,
             dataset_capture
         ),
@@ -712,7 +716,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Select Data Set",
             ["Window", "Variables"],
             None,
-            "{name} apply a dataset in one undo step, deselecting every selected object left hidden or locked (the key object too) → {applied, skipped, overflow?: [id…] (area type and type on a path whose text it rewrote and that no longer fits; left out when all fits), warning? (when no object is bound to a variable that the dataset has a value for, so nothing was applied)}",
+            "{name} apply a dataset in one undo step, deselecting every selected object left hidden or locked (the key object too); a text value bound to a frame of threaded text replaces the whole story → {applied, skipped, overflow?: [id…] (area type and type on a path whose text it rewrote and that no longer fits, the story's last frame for threaded text; left out when all fits), warning? (when no object is bound to a variable that the dataset has a value for, so nothing was applied)}",
             has_doc,
             dataset_select
         ),

crates/engine/src/tests/variables.rs

@@ -114,6 +114,113 @@ fn applying_a_dataset_reports_the_area_type_it_overflows() {
     assert_eq!((&v["name"], &v["overflow"]), (&json!("Long"), &json!([a.0])), "{v}");
 }
 
+/// Area type threaded into a rectangle → (session, first frame, second frame, the story).
+fn threaded(second_height: u32) -> (Session, NodeId, NodeId, String) {
+    let mut s = session();
+    let story = "The quick brown fox jumps over the lazy dog and keeps running. ".repeat(3) + "\nSecond paragraph.\nThird.";
+    let r = s.execute("text.create", &json!({"x": 10, "y": 10, "text": story, "area": {"width": 150, "height": 60}})).unwrap();
+    let a = NodeId(r["id"].as_u64().unwrap());
+    let r = s.execute("shape.rectangle", &json!({"x": 200, "y": 10, "width": 150, "height": second_height})).unwrap();
+    let b = NodeId(r["id"].as_u64().unwrap());
+    s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+    s.execute("text.thread.create", &json!({})).unwrap();
+    (s, a, b, story)
+}
+
+/// Whether `dataset.list` says the data set `name` matches the art.
+fn matches(s: &mut Session, name: &str) -> bool {
+    let sets = s.execute("dataset.list", &json!({})).unwrap();
+    let set = sets["datasets"].as_array().unwrap().iter().find(|d| d["name"] == name).unwrap().clone();
+    set["matches"].as_bool().unwrap()
+}
+
+#[test]
+fn a_text_value_on_a_frame_of_threaded_type_replaces_the_whole_story() {
+    let (mut s, a, b, story) = threaded(200);
+    assert!(!plain(&s, a).is_empty() && !plain(&s, b).is_empty());
+    s.execute("variable.define", &json!({"name": "Name", "kind": "text"})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Name", "ids": [a.0]})).unwrap();
+    // A capture reads the whole story, every frame's text in thread order.
+    s.execute("dataset.capture", &json!({"name": "Orig"})).unwrap();
+    let orig = s.doc().unwrap().doc.variables.dataset("Orig").unwrap().values.get("Name").cloned();
+    assert_eq!(orig, Some(vectorcraft_doc::DataValue::Text(story.clone())));
+    s.execute("dataset.new", &json!({"name": "B", "values": {"Name": "Bob"}})).unwrap();
+
+    let v = s.execute("dataset.select", &json!({"name": "B"})).unwrap();
+    assert_eq!((v["applied"].as_u64(), v["skipped"].as_u64()), (Some(1), Some(0)));
+    assert_eq!((plain(&s, a), plain(&s, b)), ("Bob".to_string(), String::new()));
+    assert!(matches(&mut s, "B"));
+    // The captured row applied back gives the story back, every time.
+    for _ in 0..2 {
+        s.execute("dataset.select", &json!({"name": "Orig"})).unwrap();
+        assert_eq!(format!("{}{}", plain(&s, a), plain(&s, b)), story);
+        assert!(!plain(&s, b).is_empty());
+        assert!(matches(&mut s, "Orig"));
+        s.execute("dataset.select", &json!({"name": "B"})).unwrap();
+        assert_eq!(format!("{}{}", plain(&s, a), plain(&s, b)), "Bob");
+    }
+}
+
+#[test]
+fn a_text_value_on_a_later_frame_of_threaded_type_replaces_the_whole_story() {
+    let (mut s, a, b, story) = threaded(200);
+    s.execute("variable.define", &json!({"name": "Tail", "kind": "text"})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Tail", "ids": [b.0]})).unwrap();
+    s.execute("dataset.capture", &json!({"name": "Orig"})).unwrap();
+    s.execute("dataset.new", &json!({"name": "T", "values": {"Tail": "END"}})).unwrap();
+
+    let v = s.execute("dataset.select", &json!({"name": "T"})).unwrap();
+    assert_eq!(v["applied"].as_u64(), Some(1));
+    assert_eq!((plain(&s, a), plain(&s, b)), ("END".to_string(), String::new()));
+    assert!(matches(&mut s, "T"));
+    s.execute("dataset.select", &json!({"name": "Orig"})).unwrap();
+    assert_eq!(format!("{}{}", plain(&s, a), plain(&s, b)), story);
+    assert!(matches(&mut s, "Orig"));
+}
+
+#[test]
+fn a_story_with_a_locked_frame_is_neither_read_nor_rewritten() {
+    let (mut s, a, b, story) = threaded(200);
+    s.execute("variable.define", &json!({"name": "Name", "kind": "text"})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Name", "ids": [a.0]})).unwrap();
+    s.execute("dataset.new", &json!({"name": "B", "values": {"Name": "Bob"}})).unwrap();
+    s.execute("select.set", &json!({"ids": [b.0]})).unwrap();
+    s.execute("object.lock", &json!({})).unwrap();
+
+    let v = s.execute("dataset.select", &json!({"name": "B"})).unwrap();
+    assert_eq!((v["applied"].as_u64(), v["skipped"].as_u64()), (Some(0), Some(1)));
+    assert_eq!(format!("{}{}", plain(&s, a), plain(&s, b)), story);
+    assert!(s.doc().unwrap().doc.captured_values().is_empty());
+}
+
+#[test]
+fn two_text_variables_in_one_story_apply_in_definition_order() {
+    let (mut s, a, b, _) = threaded(200);
+    s.execute("variable.define", &json!({"name": "Head", "kind": "text"})).unwrap();
+    s.execute("variable.define", &json!({"name": "Tail", "kind": "text"})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Tail", "ids": [a.0]})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Head", "ids": [b.0]})).unwrap();
+    s.execute("dataset.new", &json!({"name": "R", "values": {"Head": "one", "Tail": "two"}})).unwrap();
+
+    let v = s.execute("dataset.select", &json!({"name": "R"})).unwrap();
+    assert_eq!(v["applied"].as_u64(), Some(2));
+    assert_eq!(format!("{}{}", plain(&s, a), plain(&s, b)), "two");
+}
+
+#[test]
+fn applying_a_dataset_to_threaded_type_reports_overflow_on_the_last_frame() {
+    let (mut s, a, b, _) = threaded(40);
+    s.execute("variable.define", &json!({"name": "Name", "kind": "text"})).unwrap();
+    s.execute("variable.bind", &json!({"variable": "Name", "ids": [a.0]})).unwrap();
+    s.execute("dataset.new", &json!({"name": "Long", "values": {"Name": "word ".repeat(120)}})).unwrap();
+    s.execute("dataset.new", &json!({"name": "Short", "values": {"Name": "Ann"}})).unwrap();
+
+    let v = s.execute("dataset.select", &json!({"name": "Long"})).unwrap();
+    assert_eq!(&v["overflow"], &json!([b.0]), "{v}");
+    let v = s.execute("dataset.select", &json!({"name": "Short"})).unwrap();
+    assert!(v.get("overflow").is_none(), "{v}");
+}
+
 #[test]
 fn mismatched_and_missing_bindings_are_skipped_and_counted() {
     let mut s = session();