Drawings: drawing.status says which dimensions the sheet shows as they last were (#12980)

A deferred drawing that holds shows each dimension's last reading until drawing.update. drawing.status now says so
for each one, as it says so for each view: a dimension whose view is out of date, or one read from another model or
record than it has now, has `out_of_date: true`. `held` is true when views or dimensions wait. Before, a change that
left the views current (a sketch, which shows the same) held their dimensions with no sign in the status.

The list comes from one rule, `out_of_date_dimensions`: the rule `drawing.scene` and `drawing.export` wrote inline for
their own `out_of_date`, moved into one function that they and the status share. `standing` gives it the views out of
date and the stale dimensions of every sheet. The status
reply's schema says what the new field means.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
CamWightandClaude Opus 5.5 authored and GitHub committed 2026-11-07 07:49:04 -05:00
1 parent 7d4befc1b9
commit c8cbe43dd9
4 files changed
+114 -19

No files matched your search

+9 -6
View File
@@ -7,7 +7,8 @@
//! page's picking uses ([`crate::drawing_scene::hit`]).
//!
//! `drawing.status` (#4894 WE2) says where the drawing open stands: each view as the provider last
//! drew it, and each dimension as the model has it now, in one read. `drawing.update` (#4892) lets a
//! drew it, and each dimension as the model has it now and whether its sheet shows that yet, in one
//! read. `drawing.update` (#4892) lets a
//! deferred drawing draw from the model as it is now.
use serde_json::Value;
@@ -40,7 +41,7 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new(STATUS, "Drawing Status
.doc_only()
.contract(&STATUS_CONTRACT)
.output(output_schema_for::<DrawingStatusResult>)
.params("→ {views: [{view, sheet, status: current|out_of_date|placeholder|failed, reason?}], dimensions: [{dimension, status: ok|overridden|ambiguous|suppressed|lost|unmeasurable, why?}], waiting: how many views are out of date, held?: true when a deferred drawing's wait for drawing.update}. current: drawn, from the model and with the settings the view has now. Balloons aren't listed: drawing.balloon.inspect reads each one. Read-only: nothing is drawn, and each body a dimension names is read once for the call."),
.params("→ {views: [{view, sheet, status: current|out_of_date|placeholder|failed, reason?}], dimensions: [{dimension, status: ok|overridden|ambiguous|suppressed|lost|unmeasurable, why?, out_of_date?: true when its sheet shows it as it last was}], waiting: how many views are out of date, held?: true when a deferred drawing's views or dimensions out of date wait for drawing.update}. current: drawn, from the model and with the settings the view has now. A dimension's status is its reading from the model now; out_of_date says the sheet doesn't show that yet: its view is out of date, or it was read from another model or record than it has now (as drawing.scene's out_of_date lists it). Balloons aren't listed: drawing.balloon.inspect reads each one. Read-only: nothing is drawn, and each body a dimension names is read once for the call."),
CommandSpec::new(UPDATE, "Update Drawing", crate::checked!("drawing.update", update))
.icon("update")
.in_drawing()
@@ -77,7 +78,9 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new(STATUS, "Drawing Status
fn status(s: &mut Session, p: &Value) -> Result<Value> {
let _: DrawingStatusParams = crate::schema::read(STATUS, p)?;
let d = s.drawing(STATUS)?.clone();
let views: Vec<ViewStatusResult> = crate::drawing_scene::standing(s, &d)
let standing = crate::drawing_scene::standing(s, &d);
let views: Vec<ViewStatusResult> = standing
.views
.into_iter()
.map(|v| ViewStatusResult { view: ids::encode(v.view), sheet: ids::encode(v.sheet), status: v.status, reason: v.reason })
.collect();
@@ -88,11 +91,11 @@ fn status(s: &mut Session, p: &Value) -> Result<Value> {
.zip(read)
.map(|(id, r)| {
let (status, why, _) = super::drawing_dimension::status_words(r.status);
DimensionStatusResult { dimension: ids::encode(*id), status, why }
DimensionStatusResult { dimension: ids::encode(*id), status, why, out_of_date: standing.dimensions.contains(id) }
})
.collect();
let waiting = views.iter().filter(|v| v.status == "out_of_date").count();
let held = waiting > 0 && crate::drawing_scene::held(s, &d);
let held = (waiting > 0 || !standing.dimensions.is_empty()) && crate::drawing_scene::held(s, &d);
let reply = DrawingStatusResult { views, dimensions, waiting, held, param_warnings: Vec::new() };
serde_json::to_value(reply).map_err(|e| EngineError::Other(e.to_string()))
}
@@ -101,7 +104,7 @@ fn update(s: &mut Session, p: &Value) -> Result<Value> {
let _: DrawingUpdateParams = crate::schema::read(UPDATE, p)?;
let d = s.drawing(UPDATE)?.clone();
crate::drawing_scene::update(s);
let waiting = crate::drawing_scene::standing(s, &d).iter().filter(|v| v.status == "out_of_date").count();
let waiting = crate::drawing_scene::standing(s, &d).views.iter().filter(|v| v.status == "out_of_date").count();
serde_json::to_value(DrawingUpdateResult { waiting, param_warnings: Vec::new() }).map_err(|e| EngineError::Other(e.to_string()))
}
+34 -9
View File
@@ -322,10 +322,9 @@ pub fn as_shown(s: &mut Session, d: &Drawing, sheet: u64) -> Result<SheetScene>
extract(s, sheet)?;
settle(s, d);
let shown = extract(s, sheet)?;
// A held view's dimensions are out of date with it: listed after the views, never read again here
// against its old lines. `stale_dimensions` holds those of the views up to date.
let held = dimensions_on(d, shown.stale.iter().copied()).into_iter().map(|record| record.id);
let out_of_date = shown.stale.iter().copied().chain(held).chain(shown.stale_dimensions).collect();
// A held view's dimensions are listed after the views, never read again here against its old lines.
let dimensions = out_of_date_dimensions(d, &shown.stale, shown.stale_dimensions);
let out_of_date = shown.stale.iter().copied().chain(dimensions).collect();
let (scene, objects) = (Arc::unwrap_or_clone(shown.scene), shown.objects.to_vec());
Ok(SheetScene { scene, views: shown.views, objects, dimensions: shown.dimensions, out_of_date })
}
@@ -499,6 +498,14 @@ fn draw_dimensions(
wanted.iter().enumerate().map(|(at, record)| one(at, record)).collect()
}
/// The dimensions of `d` a sheet shows as they last were, by id: each of a view out of date
/// (`stale_views`), as its view is, then `stale_dimensions`, those of the views up to date that were
/// read from another record, model, drawing of their view or lettering ([`Cache::stale_dimensions`]).
fn out_of_date_dimensions(d: &Drawing, stale_views: &[u64], stale_dimensions: Vec<u64>) -> Vec<u64> {
let held = dimensions_on(d, stale_views.iter().copied()).into_iter().map(|record| record.id);
held.chain(stale_dimensions).collect()
}
/// The dimensions of `views` of `d`, by view and id.
fn dimensions_on(d: &Drawing, views: impl Iterator<Item = u64>) -> Vec<Arc<Dimension>> {
let views: BTreeSet<u64> = views.collect();
@@ -997,16 +1004,26 @@ pub struct ViewStanding {
pub reason: Option<String>,
}
/// Where the drawing open stands with the provider ([`standing`]).
#[derive(Clone, Debug, PartialEq)]
pub struct Standing {
/// Each view, in id order.
pub views: Vec<ViewStanding>,
/// The dimensions its sheets show as they last were ([`out_of_date_dimensions`]).
pub dimensions: Vec<u64>,
}
/// Each view of `d`, the drawing open, in id order, as the provider last drew it, whichever sheet it
/// is on. It reads the cache, caught up first ([`catch_up`]): nothing is drawn. A view that drew but
/// didn't fit its sheet's scene is as the last assembly left it, while that is still its sheet's
/// scene ([`Cache::assembled`]).
pub fn standing(s: &mut Session, d: &Drawing) -> Vec<ViewStanding> {
/// is on, and the dimensions shown as they last were. It reads the cache, caught up first
/// ([`catch_up`]): nothing is drawn. A view that drew but didn't fit its sheet's scene is as the last
/// assembly left it, while that is still its sheet's scene ([`Cache::assembled`]).
pub fn standing(s: &mut Session, d: &Drawing) -> Standing {
forget_closed(s);
let state = s.world_state().ok();
if let Some(state) = &state {
catch_up(s, d, d.views.iter().map(|v| v.id), state);
}
let lettering = Lettering::of(s, d);
let cache = &s.drawing_scenes;
let assembled = cache.assembled(d).unwrap_or_default();
let in_assembly = |id: u64| assembled.binary_search_by_key(&id, |v| v.view).ok().and_then(|at| assembled.get(at));
@@ -1021,7 +1038,15 @@ pub fn standing(s: &mut Session, d: &Drawing) -> Vec<ViewStanding> {
};
ViewStanding { view: view.id, sheet: view.sheet, status, reason }
};
d.views.iter().map(one).collect()
let views: Vec<ViewStanding> = d.views.iter().map(one).collect();
let stale: Vec<u64> = views.iter().filter(|v| v.status == "out_of_date").map(|v| v.view).collect();
// Every sheet's views as `extract` takes one sheet's (`views_on`), but each on its own, so one
// that can't be placed leaves out only its own dimensions.
let on: Vec<(u64, ResolvedView, Vec2)> =
d.views.iter().filter_map(|v| Some((v.id, d.resolve_view(v.id).ok()?, d.view_centre(v.id).ok()?))).collect();
let stale_dimensions = state.as_ref().map_or_else(Vec::new, |state| cache.stale_dimensions(d, &on, state, &lettering));
let dimensions = out_of_date_dimensions(d, &stale, stale_dimensions.iter().map(|record| record.id).collect());
Standing { views, dimensions }
}
/// Sheet `sheet` of the drawing open, as the provider last drew it: at once, as nothing is drawn
+66 -3
View File
@@ -1573,14 +1573,15 @@ fn overfill(s: &mut Session, view: u64) -> Drawn {
std::mem::replace(&mut entry.drawn, Drawn { group: Some(group), status: Status::Drawn, stats: None, boundary: None, frame: None, owners: None })
}
/// Each dimension's word is the one inspect uses: read, then lost when its body goes, with why. A
/// parameter status takes nothing, and needs a drawing open.
/// Each dimension's word is the one inspect uses: read, then lost when its body goes, with why. Its
/// view not drawn yet, it isn't either: it is out of date. A parameter status takes nothing, and
/// needs a drawing open.
#[test]
fn status_says_where_each_dimension_stands() {
let (mut s, _, [front, _]) = front_and_top();
let added = run(&mut s, "drawing.dimension.add", json!({"view": ids::encode(front), "kind": {"length": {"edge": [50, 0, 20]}}}));
let reply = status_of(&mut s).0;
assert_eq!(reply["dimensions"], json!([{"dimension": added["record"]["id"], "status": "ok"}]), "{reply}");
assert_eq!(reply["dimensions"], json!([{"dimension": added["record"]["id"], "status": "ok", "out_of_date": true}]), "{reply}");
let drawing = ids::encode(s.open_drawing.unwrap());
run(&mut s, "drawing.close", json!({}));
assert!(s.execute("drawing.status", &json!({})).is_err(), "no drawing open");
@@ -1594,6 +1595,68 @@ fn status_says_where_each_dimension_stands() {
assert!(s.execute("drawing.status", &json!({"sheet": "x"})).is_err());
}
/// The dimensions a `drawing.status` reply says are out of date, by id, in its order.
fn out_of_date_dimensions(reply: &Value) -> Vec<Value> {
let dimensions = reply["dimensions"].as_array().unwrap().iter();
dimensions.filter(|d| d["out_of_date"] == json!(true)).map(|d| d["dimension"].clone()).collect()
}
/// A deferred drawing, its front view's bottom edge dimensioned, updated and drawn, then closed while
/// `change` runs on the model and opened again: the session, its sheet and the dimension.
fn held_after(change: impl FnOnce(&mut Session)) -> (Session, u64, u64) {
let (mut s, sheet, [front, _]) = front_and_top();
let id = front_edge(&mut s, front);
let drawing = json!({"drawing": ids::encode(s.open_drawing.unwrap())});
run(&mut s, "drawing.set", json!({"updates": "deferred"}));
run(&mut s, "drawing.update", json!({}));
settled(&mut s, sheet);
run(&mut s, "drawing.close", json!({}));
change(&mut s);
run(&mut s, "drawing.open", drawing);
(s, sheet, id)
}
/// Updated and drawn, a drawing has nothing out of date, and doesn't hold.
fn nothing_waits_once_updated(s: &mut Session, sheet: u64) {
run(s, "drawing.update", json!({}));
settled(s, sheet);
let (reply, words) = status_of(s);
assert!(all_are(&words, "current") && out_of_date_dimensions(&reply).is_empty() && reply.get("held").is_none(), "{reply}");
}
/// A deferred drawing held by a model change lists, beside its views out of date, their dimension:
/// the sheet shows its last reading too, as `drawing.export` lists it.
#[test]
fn status_lists_a_held_views_dimensions_with_it() {
let (mut s, sheet, id) = held_after(|s| {
let block = s.doc.features[0].id;
run(s, "timeline.edit", json!({"feature": block.to_string(), "set": {"length": 120}}));
});
let (reply, words) = status_of(&mut s);
assert!(all_are(&words, "out_of_date"), "{reply}");
assert_eq!((&reply["held"], &reply["waiting"]), (&json!(true), &json!(2)), "{reply}");
assert_eq!(out_of_date_dimensions(&reply), [json!(ids::encode(id))], "{reply}");
assert_eq!(out_of_date_dimensions(&reply), listed(&mut s, sheet)[2..], "as the export lists it, after the views");
nothing_waits_once_updated(&mut s, sheet);
}
/// A change that shows the same (a sketch: a new world state, no new body) leaves a held drawing's
/// views current, but not their dimension, read from the model before it: listed out of date, with
/// the drawing held though no view waits, as `drawing.export` lists it.
#[test]
fn status_lists_dimensions_out_of_date_whose_views_are_current() {
let (mut s, sheet, id) = held_after(|s| {
run(s, "sketch.create", json!({"plane": "XY", "name": "Note"}));
run(s, "sketch.finish", json!({}));
});
let (reply, words) = status_of(&mut s);
assert!(all_are(&words, "current"), "{reply}");
assert_eq!((&reply["held"], &reply["waiting"]), (&json!(true), &json!(0)), "{reply}");
assert_eq!(out_of_date_dimensions(&reply), [json!(ids::encode(id))], "{reply}");
assert_eq!(out_of_date_dimensions(&reply), listed(&mut s, sheet), "as the export lists it");
nothing_waits_once_updated(&mut s, sheet);
}
/// A dimension of the block's top front edge on view `view`, 10 from it; its id.
fn top_edge(s: &mut Session, view: u64) -> u64 {
let added = run(s, "drawing.dimension.add", json!({"view": ids::encode(view), "kind": {"linear": {"a": [0, 0, 20], "b": [100, 0, 20]}}}));
+5 -1
View File
@@ -207,6 +207,10 @@ pub struct DimensionStatusResult {
pub status: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
pub why: Option<String>,
/// Its sheet shows it as it last was: its view is out of date, or it was read from another model
/// or record than it has now.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub out_of_date: bool,
}
/// What `drawing.status` returns.
@@ -218,7 +222,7 @@ pub struct DrawingStatusResult {
pub dimensions: Vec<DimensionStatusResult>,
/// How many views are out of date.
pub waiting: usize,
/// A deferred drawing: they wait for `drawing.update`.
/// A deferred drawing: its views and dimensions out of date wait for `drawing.update`.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub held: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]