1687a9c05b0c
macro_editor.rs
//! The macro step editor (Automate › New Macro; Macros › Edit, Create, Step Into): a large,
//! resizable window.
//!
//! - **Left, the step list.** Each row has its number, a breakpoint dot in the gutter (click to
//! toggle), a category icon, a one-line summary, an error marker and an enabled checkbox. Rows
//! drag to reorder within their list (the shared [`crate::dnd`] helpers); Add Step opens a
//! Command Palette picker; Duplicate and Delete act on the selected step.
//! - **Right, the inspector.** Step: the selected step's fields, with RefEdit boxes that switch
//! between relative tokens (`Input.col(2)`) and absolute A1, and token suggestions. Inputs: the
//! shape, header and column types each input must have, from an example. Output: the anchor and
//! what to do when results would land on data.
//! - **The debug bar.** Check (a dry run that colours the grid), Run, Step, Continue, Run to Here
//! and Stop (keep the changes or undo them). While debugging, the current step is highlighted
//! and its parameters are shown as they will run.
//!
//! The editor works on a draft and saves it with `macro.save`; checking, running and debugging
//! save first, then go through `macro.check`, `macro.run` and `macro.debug`.
use std::collections::BTreeMap;
use egui::{Color32, Id, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
use gridcraft_engine::core::RangeRef;
use gridcraft_engine::macros::policy::{Policy, macro_policy};
use gridcraft_engine::macros::resolve::{self, Env, Place};
use gridcraft_engine::model::{ColType, CompareOp, InputKind, Macro, NamedInput, OnConflict, RepeatOf, Step, StepKind, Workbook};
use serde_json::{Map, Value as Json, json};
use crate::dialogs::Dialog;
use crate::icons::{self, Icon};
use crate::theme::{self, Cat, Tokens};
use crate::widgets::small_button;
use crate::{SheetApp, dnd, macro_ui};
/// The inspector's tabs.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Tab {
#[default]
Step,
Inputs,
Output,
}
/// The Add Step picker (or Change, which replaces a step's command).
#[derive(Clone, Debug, Default)]
pub struct Picker {
pub search: String,
/// The step whose command is being changed; `None` adds a step.
pub replace: Option<String>,
pub index: usize,
}
/// The editor's state while it is open.
#[derive(Clone, Debug)]
pub struct Editor {
/// The workbook (`DocState::uid`) the macro is in: the editor saves, checks and runs there only.
pub doc: u64,
pub draft: Macro,
/// The name the macro is saved under (`None` until it is first saved).
pub saved_as: Option<String>,
/// The name the editor opened with: a new macro that still has it and nothing else counts
/// as untouched.
pub opened_as: String,
pub dirty: bool,
/// The selected row: a step path (`3`, `2.1`, `4.then.1`) or an If branch (`4.then`).
pub selected: Option<String>,
pub tab: Tab,
/// The input selected on the Inputs tab.
pub input: usize,
pub picker: Option<Picker>,
/// The last `macro.check` result (the grid overlays come from it).
pub check: Option<Json>,
/// The debugger's state while paused.
pub debug: Option<Json>,
/// What the last run, check or debug session ended with.
pub outcome: Option<String>,
/// Errors from the last check or run, by step path.
pub errors: BTreeMap<String, String>,
/// Asking whether to keep what a stopped debug run did (and then close, if `closing`).
pub ask_stop: bool,
pub closing: bool,
/// Close as the title bar's close button does (asking first) on the next frame.
pub close_requested: bool,
/// The window is quitting: once the editor has closed, the window close goes on.
pub quit: bool,
/// The workbook (or the editor's window) is closing: once the editor has closed, this close
/// runs again, in the window it was asked in.
pub then_close: Option<PendingClose>,
/// Asking whether to save before closing.
pub ask_close: bool,
/// Start debugging on the first frame (Macros › Step Into).
pub start_debug: bool,
/// Check on the first frame (`{"check": true}`).
pub start_check: bool,
/// The example the first input stands for (the selection when the editor opened, or the
/// input's default range): Check, Run and Debug use it, and tokens are shown against it.
pub example: String,
/// The parameter being added to the selected step: (key, value).
pub new_param: (String, String),
/// The reference boxes' picking state.
pub refs: RefPick,
}
/// A workbook or window close (`file.close` or `window.close`, with its params) waiting on the
/// editor's question about its draft. Once the editor has closed, it runs again in the window it
/// was asked in, whichever window became active meanwhile.
#[derive(Clone, Debug, PartialEq)]
pub struct PendingClose {
/// The editor's window, where the close was asked.
pub window: u64,
/// Whether the workbook closes (its last window, or `file.close {document: true}`), rather
/// than the editor's window alone while the workbook stays open in another.
pub whole: bool,
pub id: String,
pub params: Json,
}
/// Which reference box grid selections write into, and the selection to put back on closing.
#[derive(Clone, Debug, Default)]
pub struct RefPick {
/// The reference box that grid selections currently write into.
pub pick: Option<String>,
/// The selection reference last written by (or seen while) picking.
pub seen: String,
/// Sheet, ranges and active cell from before picking, put back when the editor closes.
pub home: Option<(usize, String, String)>,
/// The reference box the window is collapsed to (only that box shows).
pub collapsed: Option<String>,
/// Whether the picking box was drawn this frame: a pick ends with a box that left the screen
/// (another step or tab was chosen), or a later selection would land in it unseen.
pub drawn: bool,
}
// ---------------------------------------------------------------- step paths
fn child(parent: &str, i: usize) -> String {
if parent.is_empty() { (i + 1).to_string() } else { format!("{parent}.{}", i + 1) }
}
/// `"4.then.2"` → (`"4.then"`, 1). `None` for a branch key or anything else that isn't a step.
pub fn split_path(path: &str) -> Option<(&str, usize)> {
let (parent, last) = path.rsplit_once('.').unwrap_or(("", path));
Some((parent, last.parse::<usize>().ok()?.checked_sub(1)?))
}
/// The step list a parent key names: `""` (the top), `"2"` (a Repeat's body), `"4.then"`.
pub fn list_mut<'a>(mut cur: &'a mut Vec<Step>, parent: &str) -> Option<&'a mut Vec<Step>> {
let toks: Vec<&str> = parent.split('.').filter(|t| !t.is_empty()).collect();
let mut i = 0;
while let Some(tok) = toks.get(i) {
let idx = tok.parse::<usize>().ok()?.checked_sub(1)?;
let branch = toks.get(i + 1).copied();
let st = cur.get_mut(idx)?;
cur = match (&mut st.kind, branch) {
(StepKind::If { then, .. }, Some("then")) => {
i += 2;
then
}
(StepKind::If { otherwise, .. }, Some("else")) => {
i += 2;
otherwise
}
(StepKind::Repeat { body, .. }, _) => {
i += 1;
body
}
_ => return None,
};
}
Some(cur)
}
pub fn step_mut<'a>(steps: &'a mut Vec<Step>, path: &str) -> Option<&'a mut Step> {
let (parent, i) = split_path(path)?;
list_mut(steps, parent)?.get_mut(i)
}
/// The step list a parent key names, read-only (see [`list_mut`]).
pub fn list_at<'a>(mut cur: &'a [Step], parent: &str) -> Option<&'a [Step]> {
let toks: Vec<&str> = parent.split('.').filter(|t| !t.is_empty()).collect();
let mut i = 0;
while let Some(tok) = toks.get(i) {
let idx = tok.parse::<usize>().ok()?.checked_sub(1)?;
let branch = toks.get(i + 1).copied();
let st = cur.get(idx)?;
cur = match (&st.kind, branch) {
(StepKind::If { then, .. }, Some("then")) => {
i += 2;
then
}
(StepKind::If { otherwise, .. }, Some("else")) => {
i += 2;
otherwise
}
(StepKind::Repeat { body, .. }, _) => {
i += 1;
body
}
_ => return None,
};
}
Some(cur)
}
/// A copy of the step at `path`. Reads the path in place: copying the whole list for every row
/// made a large macro's step list quadratic.
pub fn step_at(steps: &[Step], path: &str) -> Option<Step> {
let (parent, i) = split_path(path)?;
list_at(steps, parent)?.get(i).cloned()
}
/// The paths of the steps with a breakpoint.
pub fn breakpoints(steps: &[Step], parent: &str, out: &mut Vec<String>) {
for (i, st) in steps.iter().enumerate() {
let path = child(parent, i);
if st.breakpoint {
out.push(path.clone());
}
match &st.kind {
StepKind::Repeat { body, .. } => breakpoints(body, &path, out),
StepKind::If { then, otherwise, .. } => {
breakpoints(then, &format!("{path}.then"), out);
breakpoints(otherwise, &format!("{path}.else"), out);
}
_ => {}
}
}
}
/// One row of the step list.
#[derive(Clone, Debug, PartialEq)]
pub struct Row {
/// The step path, or the branch key for an If's Then/Else row.
pub key: String,
/// The list it is in, and its place there.
pub parent: String,
pub index: usize,
pub depth: usize,
/// `Some("Then")` / `Some("Else")` for a branch row.
pub branch: Option<&'static str>,
}
/// The step list flattened into rows, nested steps indented under their Repeat or If.
pub fn rows(steps: &[Step], parent: &str, depth: usize, out: &mut Vec<Row>) {
if depth > 16 {
return;
}
for (i, st) in steps.iter().enumerate() {
let key = child(parent, i);
out.push(Row { key: key.clone(), parent: parent.to_string(), index: i, depth, branch: None });
match &st.kind {
StepKind::Repeat { body, .. } => rows(body, &key, depth + 1, out),
StepKind::If { then, otherwise, .. } => {
for (label, list, b) in [("Then", then, "then"), ("Else", otherwise, "else")] {
let bk = format!("{key}.{b}");
out.push(Row { key: bk.clone(), parent: key.clone(), index: 0, depth: depth + 1, branch: Some(label) });
rows(list, &bk, depth + 2, out);
}
}
_ => {}
}
}
}
/// Moves the step at `from` in list `parent` so it lands before row `to` (an index among the
/// list's steps as they are now). Returns the step's new path.
pub fn move_step(steps: &mut Vec<Step>, parent: &str, from: usize, to: usize) -> Option<String> {
let list = list_mut(steps, parent)?;
if from >= list.len() {
return None;
}
let st = list.remove(from);
let to = if to > from { to - 1 } else { to }.min(list.len());
list.insert(to, st);
Some(child(parent, to))
}
// ---------------------------------------------------------------- summaries
fn short(v: &Json) -> String {
let text = match v {
Json::String(s) => s.clone(),
other => other.to_string(),
};
if text.chars().count() > 40 { format!("{}…", text.chars().take(39).collect::<String>()) } else { text }
}
/// The label of command `id` (`Set Cell`), or the id when it isn't a command.
pub fn command_label(id: &str) -> String {
gridcraft_engine::find_command(id).map(|c| c.label.to_string()).unwrap_or_else(|| id.to_string())
}
/// A step in one line: "Set D2 to =B2*C2", "Repeat for each row of Input.data".
pub fn summary(st: &Step) -> String {
match &st.kind {
StepKind::Command { id, params } => {
let p = |k: &str| params.get(k).map(short);
match (id.as_str(), p("cell"), p("input"), p("range")) {
("cell.set", Some(c), Some(i), _) => format!("Set {c} to {i}"),
("selection.set", _, _, Some(r)) => format!("Select {r}"),
_ => {
let label = command_label(id);
let args: Vec<String> =
params.as_object().map(|o| o.iter().take(3).map(|(k, v)| format!("{k}: {}", short(v))).collect()).unwrap_or_default();
if args.is_empty() { label } else { format!("{label} · {}", args.join(", ")) }
}
}
}
StepKind::Repeat { over, of, .. } => {
format!("Repeat for each {} of {}", if *of == RepeatOf::Rows { "row" } else { "column" }, if over.is_empty() { "…" } else { over })
}
StepKind::If { cell, op, value, .. } => {
let op = match op {
CompareOp::Eq => "=",
CompareOp::Ne => "≠",
CompareOp::Gt => ">",
CompareOp::Ge => "≥",
CompareOp::Lt => "<",
CompareOp::Le => "≤",
CompareOp::Empty => return format!("If {cell} is empty"),
CompareOp::NotEmpty => return format!("If {cell} isn't empty"),
CompareOp::Contains => "contains",
};
format!("If {cell} {op} {}", short(value))
}
StepKind::Stop { message, .. } => {
if message.is_empty() {
"Stop".into()
} else {
format!("Stop: {message}")
}
}
}
}
/// The icon and colour of a step's category.
pub fn category(st: &Step) -> (Icon, Cat) {
match &st.kind {
StepKind::Repeat { .. } => (Icon::Redo, Cat::Purple),
StepKind::If { .. } => (Icon::Validation, Cat::Amber),
StepKind::Stop { .. } => (Icon::StopSquare, Cat::Red),
StepKind::Command { id, .. } => {
let prefix = id.split('.').next().unwrap_or("");
match prefix {
"cell" | "range" | "edit" => (Icon::Sheet, Cat::Blue),
"selection" => (Icon::Find, Cat::Slate),
"home" => (Icon::Format, Cat::Orange),
"data" | "table" | "pivot" => (Icon::SortFilter, Cat::Green),
"insert" | "chart" | "object" => (Icon::Insert, Cat::Purple),
"formulas" => (Icon::Function, Cat::Teal),
"sheet" | "view" | "pageLayout" => (Icon::Sheet, Cat::Amber),
_ => (Icon::Script, Cat::Slate),
}
}
}
}
/// Problems the editor can see without running: an unknown command, one a macro may not run,
/// one that needs a permission the macro doesn't list, a Repeat or If with nothing to work on.
pub fn static_error(m: &Macro, st: &Step) -> Option<String> {
match &st.kind {
StepKind::Command { id, params } => {
if gridcraft_engine::find_command(id).is_none() {
return Some(format!("There is no command “{id}”."));
}
match macro_policy(id, params, gridcraft_engine::Trust::Local) {
Policy::Deny(why) => Some(format!("{id} can't run in a macro: {why}.")),
Policy::NeedsPermission(what) if !m.permissions.iter().any(|p| p == id) => {
Some(format!("{id} {what}: the macro must list it in its permissions."))
}
_ => None,
}
}
StepKind::Repeat { over, .. } if over.trim().is_empty() => Some("Choose the range to repeat over.".into()),
StepKind::If { cell, .. } if cell.trim().is_empty() => Some("Choose the cell to test.".into()),
_ => None,
}
}
/// The parameters a new step starts with, from the command's documentation: the required ones,
/// plus an optional `cell` or `range` (`{cell?, input, array?}` → cell, input).
pub fn required_keys(doc: &str) -> Vec<String> {
let Some(start) = doc.find('{') else { return vec![] };
let mut depth = 0i32;
let mut quoted = false;
let mut part = String::new();
let mut parts = Vec::new();
for c in doc.get(start + 1..).unwrap_or("").chars() {
if c == '"' {
quoted = !quoted;
}
if quoted {
continue;
}
match c {
'{' | '[' | '(' => depth += 1,
'}' if depth == 0 => {
parts.push(std::mem::take(&mut part));
break;
}
'}' | ']' | ')' => depth -= 1,
',' if depth == 0 => {
parts.push(std::mem::take(&mut part));
continue;
}
_ => {}
}
if depth == 0 {
part.push(c);
}
}
parts
.iter()
.filter_map(|p| {
let p = p.trim();
let key: String = p.chars().take_while(|c| c.is_alphanumeric() || *c == '_').collect();
let rest = p.get(key.len()..).unwrap_or("").trim_start();
let optional = rest.starts_with('?') || rest.starts_with('|');
(!key.is_empty() && (!optional || key == "cell" || key == "range")).then_some(key)
})
.take(8)
.collect()
}
// ---------------------------------------------------------------- tokens
/// The token for `target` relative to the input called `name` at `input`: `Input`, `Input.col(2)`,
/// `Input.rows(2..3)`, `Input.cell(1,4)`, `Input.offset(0,4)`, or a cell offset from the input's
/// first cell (`Input.cell(1,1).offset(-1,0)`) with a `resize` when it is larger than one cell.
pub fn token_for(name: &str, input: RangeRef, target: RangeRef) -> String {
let (i, r) = (input, target);
if r == i {
return name.to_string();
}
let dr = i64::from(r.start.row) - i64::from(i.start.row);
let dc = i64::from(r.start.col) - i64::from(i.start.col);
let (h, w) = (r.height(), r.width());
if h == i.height() && w == i.width() {
return format!("{name}.offset({dr},{dc})");
}
let inside = i.contains(r.start) && i.contains(r.end);
if inside {
let (r0, r1) = (dr + 1, dr + i64::from(h));
let (c0, c1) = (dc + 1, dc + i64::from(w));
if r.start.row == i.start.row && r.end.row == i.end.row {
return if w == 1 { format!("{name}.col({c0})") } else { format!("{name}.cols({c0}..{c1})") };
}
if r.start.col == i.start.col && r.end.col == i.end.col {
return if h == 1 { format!("{name}.row({r0})") } else { format!("{name}.rows({r0}..{r1})") };
}
let cell = format!("{name}.cell({r0},{c0})");
return if r.is_single() { cell } else { format!("{cell}.resize({h},{w})") };
}
let cell = format!("{name}.cell(1,1).offset({dr},{dc})");
if r.is_single() { cell } else { format!("{cell}.resize({h},{w})") }
}
/// `Sheet1!$B$2:$D$9,C4` → [(Some("Sheet1"), B2:D9), (None, C4)].
pub fn parse_refs(text: &str) -> Vec<(Option<String>, RangeRef)> {
text.split(',')
.filter_map(|part| {
let part = part.trim();
let (sheet, body) = gridcraft_engine::core::split_sheet(part);
RangeRef::parse(&body.replace('$', "")).map(|r| (sheet, r))
})
.take(500)
.collect()
}
/// The inputs bound to their examples, for showing tokens as A1 and A1 as tokens.
fn bound_inputs(wb: &Workbook, ed: &Editor) -> Vec<(String, Place, bool)> {
let env = Env { wb, active_sheet: wb.active_sheet(), inputs: &[], output: None, item: None };
ed.draft
.inputs
.iter()
.enumerate()
.filter_map(|(k, i)| {
let example = if k == 0 { Some(ed.example.as_str()) } else { i.default_ref.as_deref() };
let place = resolve::resolve_ref(example?, &env).ok()?;
Some((i.name.clone(), place, i.header))
})
.collect()
}
/// The suggestions offered beside a reference box.
fn token_suggestions(wb: &Workbook, ed: &Editor, in_repeat: bool) -> Vec<String> {
let mut out = Vec::new();
for (k, i) in ed.draft.inputs.iter().enumerate() {
let n = &i.name;
out.push(n.clone());
if i.header {
out.push(format!("{n}.data"));
}
let width = if k == 0 { parse_refs(&ed.example).first().map_or(3, |(_, r)| r.width()) } else { 3 }.clamp(1, 6);
out.extend((1..=width).map(|c| format!("{n}.col({c})")));
out.push(format!("{n}.rows(2..)"));
out.push(format!("{n}.cell(1,1)"));
out.push(format!("{n}.right"));
out.push(format!("{n}.below"));
}
if ed.draft.output.anchor.is_some() {
out.push("Output".into());
out.push("Output.offset(1,0)".into());
}
if in_repeat {
out.push("Row".into());
out.push("Row.right".into());
}
out.extend(wb.names.iter().take(20).map(|n| format!("Name:{}", n.name)));
out
}
// ---------------------------------------------------------------- opening
/// Opens the editor: `{macro}` edits a saved macro (`debug: true` also starts debugging it,
/// `check: true` checks it), `{new}` starts one with that name, `{}` one with the next free name.
pub fn open(app: &mut SheetApp, params: &Json) -> Option<Dialog> {
let doc = app.session.active()?;
let wb = &doc.wb;
let selection = doc.selection.current().a1();
let found = params["macro"].as_str().and_then(|n| gridcraft_engine::macros::find(wb, n)).and_then(|i| wb.macros.get(i)).cloned();
let (draft, saved_as) = match found {
Some(m) => {
let name = m.name.clone();
(m, Some(name))
}
None => {
let name = params["new"]
.as_str()
.map(str::trim)
.filter(|n| !n.is_empty())
.map(|n| gridcraft_engine::macros::unique_name(wb, n))
.unwrap_or_else(|| gridcraft_engine::macros::next_name(wb));
(Macro { name, inputs: vec![NamedInput::default()], ..Default::default() }, None)
}
};
let example = draft.inputs.first().and_then(|i| i.default_ref.clone()).unwrap_or(selection);
let start_debug = params["debug"].as_bool() == Some(true) && saved_as.is_some();
let title = format!("Macro: {}", draft.name);
let selected = (!draft.steps.is_empty()).then(|| "1".to_string());
let doc = doc.uid;
app.macros.editor = Some(Editor {
doc,
opened_as: draft.name.clone(),
draft,
dirty: saved_as.is_none(),
saved_as,
selected,
tab: Tab::Step,
input: 0,
picker: None,
check: None,
debug: None,
outcome: None,
errors: BTreeMap::new(),
ask_stop: false,
closing: false,
close_requested: false,
quit: false,
then_close: None,
ask_close: false,
start_debug,
start_check: params["check"].as_bool() == Some(true),
example,
new_param: Default::default(),
refs: RefPick::default(),
});
Some(Dialog::custom("macroEditor", &title, json!({})))
}
// ---------------------------------------------------------------- actions
/// Whether the editor's workbook is the active one, which the `macro.*` commands act on. When
/// another workbook is active (File › New, Switch Window, an agent), says so and returns false.
fn at_home(app: &mut SheetApp, ed: &Editor, title: &str) -> bool {
if app.session.active().is_some_and(|d| d.uid == ed.doc) {
return true;
}
let book = home_title(app, ed);
app.message = Some((title.into(), format!("The macro “{}” is in “{book}”. Switch back to it to save, check or run the macro.", ed.draft.name)));
false
}
/// The title of the editor's workbook.
fn home_title(app: &SheetApp, ed: &Editor) -> String {
app.session.documents().iter().find(|d| d.uid == ed.doc).map(|d| d.display_title()).unwrap_or_default()
}
/// Saves the draft (renaming the saved macro if its name changed). False when it couldn't.
pub fn save(app: &mut SheetApp, ed: &mut Editor) -> bool {
if !at_home(app, ed, "Save Macro") {
return false;
}
ed.draft.name = ed.draft.name.trim().to_string();
if let Err(e) = ed.draft.check_limits() {
app.message = Some(("Save Macro".into(), e));
return false;
}
if let Some(old) = ed.saved_as.clone()
&& !old.eq_ignore_ascii_case(&ed.draft.name)
{
if let Err(e) = app.run("macro.rename", json!({"name": old, "to": ed.draft.name})) {
app.message = Some(("Save Macro".into(), crate::clean_error(&e)));
return false;
}
// The workbook has it under the new name now, even if the save below fails.
ed.saved_as = Some(ed.draft.name.clone());
}
// A new draft never replaces a macro that has its name; the person chooses another.
let replace = ed.saved_as.is_some();
if !replace
&& let Some(doc) = app.session.active()
&& let Err(e) = gridcraft_engine::macros::check_new_name(&doc.wb, &ed.draft.name)
{
app.message = Some(("Save Macro".into(), e));
return false;
}
match app.run("macro.save", json!({"macro": gridcraft_engine::macros::macro_json(&ed.draft), "replace": replace})) {
Ok(_) => {
ed.saved_as = Some(ed.draft.name.clone());
ed.dirty = false;
true
}
Err(e) => {
app.message = Some(("Save Macro".into(), crate::clean_error(&e)));
false
}
}
}
fn ensure_saved(app: &mut SheetApp, ed: &mut Editor) -> bool {
if ed.dirty || ed.saved_as.is_none() { save(app, ed) } else { true }
}
impl Editor {
/// The draft holds changes not yet saved into the workbook. A new macro counts once it
/// differs from the empty one the editor started with, its name included.
pub fn has_unsaved_changes(&self) -> bool {
let untouched = Macro { name: self.opened_as.clone(), inputs: vec![NamedInput::default()], ..Default::default() };
self.dirty && (self.saved_as.is_some() || self.draft != untouched)
}
}
/// Closing the editor's workbook (File › Close, Cmd+W, the Backstage Close, a window's close
/// button) while the draft has unsaved changes: the editor asks about them first, as its own
/// close button does, and the close (`id` with `params`) goes on once the editor has closed, in
/// the window it was asked in; Cancel keeps both. Closing the window that shows the editor asks
/// too, even when the workbook stays open in another window. A close of another of the
/// workbook's windows, or a forced one, is none of the editor's business (`None`) and goes ahead
/// as before.
///
/// While the editor is asking, one question stands for one close: a further request for the
/// same close (Cmd+W pressed again, the close button after Cmd+W) waits for the answer without a
/// second question, and the pending close then runs once. A request for a different close (the
/// workbook while only the editor's window was closing, or the reverse) is refused with the
/// reason until the question is answered, so that the answer never closes more or less than
/// what was asked.
pub fn ask_before_closing(app: &mut SheetApp, id: &str, params: &Json) -> Option<Result<Json, String>> {
let flag = |k: &str| params.get(k).and_then(Json::as_bool) == Some(true);
if flag("force") {
return None;
}
let doc = app.macros.editor.as_ref().filter(|ed| ed.has_unsaved_changes()).map(|ed| ed.doc)?;
let window = match id {
"file.close" => app.session.active_window(),
"window.close" => gridcraft_engine::Target::from_json(params).ok().and_then(|t| app.session.target_window(t).ok()),
_ => None,
};
let owner = window.and_then(|w| app.session.window(w)).map(|w| w.doc_uid)?;
// The editor asks in the window it is shown in.
let home = app.window_with_dialog("macroEditor")?;
let only = app.session.windows().iter().filter(|w| w.doc_uid == owner).count() <= 1;
// The workbook closes, or the window that shows the editor does (taking the editor with it).
let whole = only || (id == "file.close" && flag("document"));
if owner != doc || !(whole || window == Some(home)) {
return None;
}
if app.ui_window() != Some(home) {
app.enter_window(home);
}
let ed = app.macros.editor.as_mut()?;
let waiting = json!({"closed": false, "dirty": true, "macroDraft": true});
// Quitting: the quit asks about every unsaved workbook itself once the editor has closed,
// and Cancel keeps them all.
if ed.quit {
return Some(Ok(waiting));
}
match &ed.then_close {
Some(pending) if pending.whole == whole => {}
Some(pending) => {
let what = |whole: bool| if whole { "the workbook" } else { "its window" };
return Some(Err(format!(
"The macro step editor is asking whether to save its draft before {} closes. Answer that first, then close {}.",
what(pending.whole),
what(whole)
)));
}
None => {
ed.then_close = Some(PendingClose { window: home, whole, id: id.to_string(), params: params.clone() });
ed.close_requested = true;
}
}
Some(Ok(waiting))
}
/// The inputs a run from the editor uses: the first input's example.
fn run_inputs(ed: &Editor) -> Json {
match ed.draft.inputs.first() {
Some(i) if !ed.example.trim().is_empty() => json!({ i.name.clone(): ed.example }),
_ => json!({}),
}
}
/// The step path an error message names (`Step 3 (cell.set): …` → `3`).
fn error_step(msg: &str) -> Option<(String, String)> {
let rest = msg.get(msg.find("Step ")? + 5..)?;
let end = rest.find([' ', ':']).unwrap_or(rest.len());
let path = rest.get(..end)?.to_string();
split_path(&path)?;
Some((path, msg.to_string()))
}
/// Check: validates the inputs and dry-runs the macro; the grid shows what it would touch.
pub fn check(app: &mut SheetApp, ed: &mut Editor) {
// A reference box picking from the grid would take the selections the action makes.
ed.refs.pick = None;
if !at_home(app, ed, "Check Macro") || !ensure_saved(app, ed) {
return;
}
ed.errors.clear();
let name = ed.draft.name.clone();
match app.run("macro.check", json!({"name": name, "inputs": run_inputs(ed)})) {
Ok(v) => {
for e in v["errors"].as_array().into_iter().flatten().filter_map(Json::as_str) {
if let Some((path, msg)) = error_step(e) {
ed.errors.insert(path, msg);
}
}
if let Some(e) = v["footprint"]["error"].as_object()
&& let Some(step) = e.get("step").and_then(Json::as_str)
{
ed.errors.insert(step.to_string(), e.get("message").and_then(Json::as_str).unwrap_or("").to_string());
}
ed.outcome = Some(check_text(&v));
ed.check = Some(v);
}
Err(e) => {
ed.check = None;
ed.outcome = Some(crate::clean_error(&e));
}
}
}
fn check_text(v: &Json) -> String {
if let Some(errors) = v["errors"].as_array().filter(|e| !e.is_empty()) {
return errors.iter().filter_map(Json::as_str).collect::<Vec<_>>().join(" ");
}
if let Some(asks) = v["needsApproval"].as_array() {
return format!("Needs approval before it can run: it {}.", asks.iter().filter_map(Json::as_str).collect::<Vec<_>>().join(", "));
}
let cells: u64 = v["footprint"]["sheets"].as_array().into_iter().flatten().filter_map(|s| s["changed"].as_u64()).sum();
let conflicts = v["conflicts"].as_u64().unwrap_or(0);
let mut text = format!("Check passed: writes {cells} cell{}", if cells == 1 { "" } else { "s" });
if conflicts > 0 {
text.push_str(&format!(", {conflicts} of them hold data (red)"));
} else {
text.push_str(", over no data");
}
if v["footprint"]["partial"].is_object() {
text.push_str(". Later steps can't be previewed.");
}
text
}
/// Run: runs the saved macro as one undo step.
pub fn run(app: &mut SheetApp, ed: &mut Editor) {
ed.refs.pick = None;
if !at_home(app, ed, "Run Macro") || !ensure_saved(app, ed) {
return;
}
ed.errors.clear();
let name = ed.draft.name.clone();
match macro_ui::call(app, "Run Macro", "macro.run", json!({"name": name, "inputs": run_inputs(ed)})) {
Some(v) => ed.outcome = Some(format!("Ran {} step{}.", v["ran"].as_u64().unwrap_or(0), if v["ran"] == 1 { "" } else { "s" })),
None => {
if let Some((_, text)) = app.message.as_ref()
&& let Some((path, msg)) = error_step(text)
{
ed.errors.insert(path, msg);
}
}
}
}
/// The breakpoints sent with each debugger action: the draft's (they replace the saved ones, so
/// a dot cleared while paused takes effect at once).
fn bp_params(ed: &Editor) -> Json {
let mut list = Vec::new();
breakpoints(&ed.draft.steps, "", &mut list);
json!({"breakpoints": list, "breakpointsOnly": true})
}
fn with(mut base: Json, extra: Json) -> Json {
if let (Some(b), Some(e)) = (base.as_object_mut(), extra.as_object()) {
for (k, v) in e {
b.insert(k.clone(), v.clone());
}
}
base
}
/// Step, Continue or Run to Here: starts debugging if needed (paused before step 1), then acts.
pub fn debug_action(app: &mut SheetApp, ed: &mut Editor, action: &str) {
ed.refs.pick = None;
let debugging = app.session.macro_debug.is_some();
// Starting selects the first step: take Run to Here's target before that.
let target = ed.selected.clone().filter(|s| split_path(s).is_some());
if !debugging {
if !at_home(app, ed, "Debug Macro") || !ensure_saved(app, ed) {
return;
}
ed.errors.clear();
// A dry run first, so the grid shows the inputs and what the run will write.
check(app, ed);
let name = ed.draft.name.clone();
let p = with(json!({"name": name, "inputs": run_inputs(ed), "action": "start"}), bp_params(ed));
let Some(v) = macro_ui::call(app, "Debug Macro", "macro.debug", p) else { return };
apply_debug(ed, &v);
if action == "step" || v["state"] != "paused" {
return;
}
}
let p = match action {
"runTo" => match target {
Some(step) => json!({"action": "runTo", "step": step}),
None => return,
},
other => json!({"action": other}),
};
if let Some(v) = macro_ui::call(app, "Debug Macro", "macro.debug", with(p, bp_params(ed))) {
apply_debug(ed, &v);
}
}
/// Stop: ends the debugged run, keeping its changes as one undo step or undoing them.
pub fn stop(app: &mut SheetApp, ed: &mut Editor, keep: bool) {
if let Some(v) = macro_ui::call(app, "Debug Macro", "macro.debug", json!({"action": "stop", "keep": keep})) {
apply_debug(ed, &v);
}
}
/// Takes in a `macro.debug` result: paused (select the current step), or ended (say how).
pub fn apply_debug(ed: &mut Editor, v: &Json) {
match v["state"].as_str() {
Some("paused") => {
if let Some(step) = v["current"]["step"].as_str() {
ed.selected = Some(step.to_string());
ed.tab = Tab::Step;
}
ed.outcome = None;
ed.debug = Some(v.clone());
}
Some(state) => {
ed.debug = None;
let executed = v["executed"].as_u64().unwrap_or(0);
ed.outcome = Some(match state {
"finished" => format!("Finished: {executed} step{} ran, one undo step.", if executed == 1 { "" } else { "s" }),
"failed" => {
if let Some(step) = v["error"]["step"].as_str() {
let msg = v["error"]["message"].as_str().unwrap_or("").to_string();
ed.errors.insert(step.to_string(), msg);
ed.selected = Some(step.to_string());
}
v["message"].as_str().unwrap_or("The macro failed; nothing was changed.").to_string()
}
_ if v["kept"] == true => format!("Stopped after {executed} step{}; the changes were kept.", if executed == 1 { "" } else { "s" }),
_ => match v["stopped"].as_str() {
Some(msg) => format!("Stopped: {msg}"),
None => "Stopped; the changes were undone.".into(),
},
});
}
None => {}
}
}
// ---------------------------------------------------------------- the window
/// Draws the editor window. `open` turns false when it closes.
pub fn window(app: &mut SheetApp, ctx: &egui::Context, d: &mut Dialog, open: &mut bool) {
let Some(mut ed) = app.macros.editor.take() else {
*open = false;
return;
};
// A prompt's button re-ran a debugger action (making room for the output, approving).
if let Some(v) = app.macros.debug_result.take() {
apply_debug(&mut ed, &v);
}
if ed.start_check {
ed.start_check = false;
check(app, &mut ed);
}
if ed.start_debug {
ed.start_debug = false;
debug_action(app, &mut ed, "step");
}
// The run ended elsewhere (the status bar, an agent).
if ed.debug.is_some() && app.session.macro_debug.is_none() {
ed.debug = None;
}
// Its workbook was closed: the macro went with it.
if !app.session.documents().iter().any(|d| d.uid == ed.doc) {
*open = false;
return;
}
let home = app.session.active().is_some_and(|d| d.uid == ed.doc);
let home_title = home_title(app, &ed);
let dirty_mark = if ed.dirty { " •" } else { "" };
let screen = ctx.content_rect();
let fit = (screen.size() - vec2(16.0, 16.0)).max(vec2(240.0, 200.0));
let mut win_open = true;
ed.refs.drawn = false;
egui::Window::new(format!("Macro: {}{dirty_mark}", ed.draft.name))
.id(Id::unique("gridcraft.macro_editor"))
.collapsible(false)
.resizable(true)
// Never larger than the app's window, so a narrow one keeps every control on screen.
.default_size(vec2(840.0, 560.0).min(fit))
.min_size(vec2(660.0, 380.0).min(fit))
// To the right, so the data the overlays mark (usually top left) stays in view.
.default_pos(pos2((screen.right() - 860.0).max(screen.left() + 20.0), screen.top() + 190.0))
.open(&mut win_open)
.show(ctx, |ui| {
if !home {
let t = Tokens::get(ui.ctx());
ui.label(
egui::RichText::new(format!("This macro is in “{home_title}”. Switch back to it to edit, check or run the macro."))
.color(t.danger),
);
}
ui.add_enabled_ui(home, |ui| {
if let Some(key) = ed.refs.collapsed.clone() {
ref_edit(app, ui, d, &mut ed.refs, &key, 340.0);
apply_ref_value(&mut ed, d, &key);
return;
}
body(app, ui, d, &mut ed);
});
});
if ed.refs.pick.is_some() && !ed.refs.drawn {
ed.refs.pick = None;
}
if !win_open || std::mem::take(&mut ed.close_requested) {
if app.session.macro_debug.is_some() {
ed.ask_stop = true;
ed.closing = true;
} else if ed.has_unsaved_changes() {
ed.ask_close = true;
} else {
*open = false;
}
}
if ctx.input(|i| i.key_pressed(egui::Key::Escape)) && ed.picker.is_some() {
ed.picker = None;
}
prompts(app, ctx, &mut ed, open);
// The overlays mark the editor's workbook's cells, so they show only while it is active.
app.grid.macro_overlay = if *open && home { overlay(app, &ed) } else { None };
if *open {
app.macros.editor = Some(ed);
} else {
if home {
restore_home(app, &ed.refs);
}
if ed.quit {
// A quit takes over a workbook close waiting on the editor: it asks about every
// unsaved workbook itself, and the close replayed after it would act on whichever
// workbook the quit is asking about.
if app.native_windows {
// Each workbook window is a native window whose close button closes only it:
// the quit goes on directly.
app.continue_quit(ctx);
} else {
ctx.send_viewport_cmd(egui::ViewportCommand::Close);
}
} else if let Some(close) = ed.then_close.take() {
// The close runs in the window it was asked in, not in whichever window the person
// activated meanwhile: `file.close` acts on the active window and workbook.
if app.session.window(close.window).is_some() {
app.enter_window(close.window);
app.run_or_alert(&close.id, close.params);
} else {
app.message = Some(("Close".into(), "The window that was closing has closed already; nothing else was closed.".into()));
}
}
}
}
/// Asks the open step editor to close, as its close button does: it asks about a debug run or
/// unsaved steps first. With `quit` (the window is closing, or the app is quitting), the close or
/// quit goes on once the editor has closed; a Cancel in its questions keeps both open.
pub fn request_close(app: &mut SheetApp, quit: bool) {
if let Some(ed) = app.macros.editor.as_mut() {
ed.close_requested = true;
ed.quit = quit;
}
}
/// Closes the step editor at once for a caller outside its window (the control channel's
/// `ui.dialog.cancel`), with the cleanup its own close does. Refused while it holds a debug run
/// or unsaved steps, which only its window asks about.
pub fn close_now(app: &mut SheetApp) -> Result<(), String> {
if app.session.macro_debug.is_some() {
return Err("A macro is being debugged: stop it first (macro.debug {\"action\": \"stop\"}).".into());
}
if app.macros.editor.as_ref().is_some_and(Editor::has_unsaved_changes) {
return Err("The macro step editor has unsaved steps: save them or close the editor in its window.".into());
}
if let Some(ed) = app.macros.editor.take()
&& app.session.active().is_some_and(|d| d.uid == ed.doc)
{
restore_home(app, &ed.refs);
}
app.grid.macro_overlay = None;
app.dialog = None;
Ok(())
}
// ---------------------------------------------------------------- reference boxes
/// A range as an absolute reference: `$B$2:$D$9`.
fn abs(r: &RangeRef) -> String {
let a = |c: gridcraft_engine::core::CellRef| format!("${}${}", gridcraft_engine::core::col_to_letters(c.col), c.row + 1);
if r.is_single() { a(r.start) } else { format!("{}:{}", a(r.start), a(r.end)) }
}
/// The grid selection as a reference: absolute, comma-joined areas, with the sheet name when it
/// isn't the sheet picking started on.
fn selection_ref(app: &SheetApp, home_sheet: Option<usize>) -> String {
let Some(doc) = app.session.active() else { return String::new() };
let areas: Vec<String> = doc.selection.ranges.iter().map(abs).collect();
match (home_sheet, doc.wb.active()) {
(Some(h), Some(sh)) if h != doc.wb.active_sheet() => {
let q = gridcraft_engine::formula::quote_sheet(&sh.name);
areas.iter().map(|a| format!("{q}!{a}")).collect::<Vec<_>>().join(",")
}
_ => areas.join(","),
}
}
/// Starts picking into `key`: later grid selections are written into the box. The first pick
/// remembers the selection, so closing the editor can put it back.
fn begin_pick(app: &SheetApp, refs: &mut RefPick, key: &str) {
if refs.home.is_none()
&& let Some(doc) = app.session.active()
{
let ranges: Vec<String> = doc.selection.ranges.iter().map(|r| r.a1()).collect();
refs.home = Some((doc.wb.active_sheet(), ranges.join(","), doc.selection.active.a1()));
}
refs.pick = Some(key.to_string());
refs.seen = selection_ref(app, refs.home.as_ref().map(|h| h.0));
}
/// Puts back the sheet and selection from before picking started.
fn restore_home(app: &mut SheetApp, refs: &RefPick) {
if let Some((sheet, ranges, active)) = &refs.home {
let _ = app.session.run("selection.set", json!({"sheet": sheet, "range": ranges, "active": active}));
}
}
/// A reference box (Excel's RefEdit): a text field that grid selections fill while it is the
/// pick target, with a button that collapses the window to just this box and expands it again.
/// The text is kept in `d.values[key]`.
fn ref_edit(app: &SheetApp, ui: &mut Ui, d: &mut Dialog, refs: &mut RefPick, key: &str, width: f32) {
let mut s = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string();
let sel = selection_ref(app, refs.home.as_ref().map(|h| h.0));
let picking = refs.pick.as_deref() == Some(key);
if picking {
refs.drawn = true;
}
ui.horizontal(|ui| {
let r = ui.add(egui::TextEdit::singleline(&mut s).desired_width(width - 30.0).id_salt(("refedit", key)));
if r.gained_focus() || (r.clicked() && !picking) {
begin_pick(app, refs, key);
} else if picking && !r.has_focus() && sel != refs.seen && app.session.macro_debug.is_none() {
// A selection made on the grid becomes the reference; while debugging, the selection
// follows the steps and is not a pick.
s = sel.clone();
refs.seen = sel;
}
let collapsed = refs.collapsed.as_deref() == Some(key);
let t = Tokens::get(ui.ctx());
let (icon, tip) = if collapsed { (Icon::Expand, "Expand the editor") } else { (Icon::Collapse, "Collapse the editor to this box") };
if crate::widgets::icon_button(ui, icon, t.text_dim, tip, vec2(22.0, 20.0)).clicked() {
refs.collapsed = if collapsed { None } else { Some(key.to_string()) };
if !collapsed {
begin_pick(app, refs, key);
}
}
});
d.values.insert(key.into(), json!(s));
}
/// Keep changes? (stopping a debugged run) and Save changes? (closing with unsaved edits).
fn prompts(app: &mut SheetApp, ctx: &egui::Context, ed: &mut Editor, open: &mut bool) {
if ed.ask_stop {
let mut answer: Option<Option<bool>> = None;
egui::Modal::new(Id::unique("gridcraft.macro_editor.stop")).show(ctx, |ui| {
ui.set_width(360.0);
ui.label(egui::RichText::new("Stop debugging").strong());
ui.label("Keep the changes the macro has made so far? They are one undo step either way.");
ui.add_space(8.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button("Cancel").clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
answer = Some(None);
}
if ui.button("Undo Changes").clicked() {
answer = Some(Some(false));
}
if ui.button("Keep Changes").clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)) {
answer = Some(Some(true));
}
});
});
match answer {
Some(Some(keep)) => {
ed.ask_stop = false;
stop(app, ed, keep);
if ed.closing {
if ed.has_unsaved_changes() { ed.ask_close = true } else { *open = false }
}
ed.closing = false;
}
Some(None) => {
ed.ask_stop = false;
ed.closing = false;
ed.quit = false;
ed.then_close = None;
}
None => {}
}
return;
}
if ed.ask_close {
let mut answer: Option<Option<bool>> = None;
egui::Modal::new(Id::unique("gridcraft.macro_editor.close")).show(ctx, |ui| {
ui.set_width(360.0);
ui.label(egui::RichText::new(format!("Save changes to macro “{}”?", ed.draft.name)).strong());
ui.add_space(8.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.button("Cancel").clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
answer = Some(None);
}
if ui.button("Don't Save").clicked() {
answer = Some(Some(false));
}
if ui.button("Save").clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)) {
answer = Some(Some(true));
}
});
});
match answer {
Some(Some(true)) => {
ed.ask_close = false;
if save(app, ed) {
*open = false;
} else {
// The draft stays open with the reason shown; the workbook is not closed and
// the app does not quit, then or when the editor closes later.
ed.then_close = None;
ed.quit = false;
}
}
Some(Some(false)) => {
ed.ask_close = false;
*open = false;
}
Some(None) => {
ed.ask_close = false;
ed.quit = false;
ed.then_close = None;
}
None => {}
}
}
}
fn body(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor) {
let t = Tokens::get(ui.ctx());
let debugging = app.session.macro_debug.is_some();
// Name, description, Save; they wrap in a narrow window.
ui.horizontal_wrapped(|ui| {
let label = ui.label("Name:");
let name =
ui.add_enabled(!debugging, egui::TextEdit::singleline(&mut ed.draft.name).desired_width(180.0).id_salt("me_name")).labelled_by(label.id);
let label = ui.label("Description:");
let desc = ui
.add_enabled(
!debugging,
egui::TextEdit::singleline(&mut ed.draft.description).desired_width((ui.available_width() - 90.0).max(80.0)).id_salt("me_desc"),
)
.labelled_by(label.id);
if name.changed() || desc.changed() {
ed.dirty = true;
}
if ui.add_enabled(ed.dirty && !debugging, egui::Button::new("Save")).clicked() {
save(app, ed);
}
});
ui.add_space(2.0);
toolbar(app, ui, ed, debugging);
status_line(app, ui, ed, &t);
ui.separator();
let avail = ui.available_size();
// The step list takes about half; in a narrow window the inspector keeps room for its tabs.
let left_w = (avail.x * 0.52).max(300.0).min((avail.x - 190.0).max(160.0));
ui.horizontal_top(|ui| {
ui.allocate_ui_with_layout(vec2(left_w, avail.y), egui::Layout::top_down(egui::Align::Min), |ui| {
ui.set_min_size(vec2(left_w, avail.y));
if ed.picker.is_some() {
picker(ui, ed);
} else {
step_list(app, ui, ed, debugging);
}
});
ui.separator();
ui.allocate_ui_with_layout(vec2(ui.available_width(), avail.y), egui::Layout::top_down(egui::Align::Min), |ui| {
egui::ScrollArea::both().id_salt("me_inspector").auto_shrink([false, false]).show(ui, |ui| {
inspector(app, ui, d, ed, debugging);
});
});
});
}
fn toolbar(app: &mut SheetApp, ui: &mut Ui, ed: &mut Editor, debugging: bool) {
let t = Tokens::get(ui.ctx());
// The buttons wrap onto a second row in a narrow window.
ui.horizontal_wrapped(|ui| {
ui.spacing_mut().item_spacing.x = 2.0;
let editing = !debugging;
if ui.add_enabled(editing, |ui: &mut Ui| small_button(ui, Icon::Plus, "Add Step", "Add a step after the selected one", false)).clicked() {
ed.picker = Some(Picker::default());
}
let has_step = ed.selected.as_deref().and_then(split_path).is_some();
if ui
.add_enabled(editing && has_step, |ui: &mut Ui| small_button(ui, Icon::Copy, "Duplicate", "Duplicate the selected step", false))
.clicked()
{
duplicate(ed);
}
if ui.add_enabled(editing && has_step, |ui: &mut Ui| small_button(ui, Icon::Delete, "Delete", "Delete the selected step", false)).clicked() {
delete(ed);
}
sep(ui, &t);
if ui
.add_enabled(editing, |ui: &mut Ui| {
small_button(ui, Icon::Check, "Check", "Check the inputs and show on the grid what the macro would change", false)
})
.clicked()
{
check(app, ed);
}
if ui.add_enabled(editing, |ui: &mut Ui| small_button(ui, Icon::Play, "Run", "Run the macro as one undo step", false)).clicked() {
run(app, ed);
}
sep(ui, &t);
if small_button(ui, Icon::Step, "Step", if debugging { "Run the current step" } else { "Start debugging: stop before the first step" }, false)
.clicked()
{
debug_action(app, ed, "step");
}
if small_button(ui, Icon::Continue, "Continue", "Run to the next breakpoint or the end", false).clicked() {
debug_action(app, ed, "continue");
}
let can_run_to = ed.selected.as_deref().and_then(split_path).is_some();
if ui.add_enabled(can_run_to, |ui: &mut Ui| small_button(ui, Icon::RunTo, "Run to Here", "Run until the selected step", false)).clicked() {
debug_action(app, ed, "runTo");
}
if ui.add_enabled(debugging, |ui: &mut Ui| small_button(ui, Icon::StopSquare, "Stop", "Stop debugging", false)).clicked() {
ed.ask_stop = true;
}
});
}
fn sep(ui: &mut Ui, t: &Tokens) {
let (r, _) = ui.allocate_exact_size(vec2(9.0, 20.0), Sense::hover());
ui.painter().line_segment([pos2(r.center().x, r.top() + 2.0), pos2(r.center().x, r.bottom() - 2.0)], Stroke::new(1.0, t.separator));
}
/// Where the run is (while debugging) or what the last check, run or debug session said, with
/// the overlay legend.
fn status_line(app: &SheetApp, ui: &mut Ui, ed: &Editor, t: &Tokens) {
if let Some(st) = &ed.debug {
let cur = &st["current"];
let step = cur["step"].as_str().unwrap_or("");
let what = match cur["kind"].as_str() {
Some("command") => command_label(cur["command"].as_str().unwrap_or("")),
Some(k) => k.to_string(),
None => String::new(),
};
let mut head = format!("Paused before step {step} · {what}");
if let (Some(at), Some(of)) = (cur["iteration"]["at"].as_u64(), cur["iteration"]["of"].as_u64()) {
head.push_str(&format!(" · pass {at} of {of}"));
}
if st["atBreakpoint"] == true {
head.push_str(" · at a breakpoint");
}
ui.label(egui::RichText::new(head).strong().color(t.text));
let resolved = cur.get("params").or(cur.get("over")).or(cur.get("cell")).map(|p| p.to_string());
if let Some(p) = resolved {
ui.horizontal(|ui| {
ui.label(egui::RichText::new("Runs with:").color(t.text_dim));
ui.add(egui::Label::new(egui::RichText::new(p).monospace().color(t.text)).truncate());
});
} else if let Some(e) = cur["paramsError"].as_str() {
ui.label(egui::RichText::new(e).color(t.danger));
}
let changed: Vec<&str> = st["changed"].as_array().into_iter().flatten().filter_map(Json::as_str).take(6).collect();
ui.label(
egui::RichText::new(format!("Changed so far: {}", if changed.is_empty() { "nothing".into() } else { changed.join(", ") }))
.color(t.text_dim),
);
} else if let Some(text) = &ed.outcome {
let bad = !ed.errors.is_empty() || ed.check.as_ref().is_some_and(|c| c["ok"] == false);
ui.add(egui::Label::new(egui::RichText::new(text).color(if bad { t.danger } else { t.text })).wrap());
} else {
ui.label(
egui::RichText::new("Check shows on the grid what the macro reads and writes. Click a step's gutter to set a breakpoint.")
.color(t.text_dim),
);
}
if app.grid.macro_overlay.is_some() {
ui.horizontal(|ui| {
for (label, c) in [
("Inputs", t.sheet_macro_input),
("Writes", t.sheet_macro_footprint),
("Writes over data", t.sheet_macro_conflict),
("Current step", t.sheet_macro_target),
] {
let (r, _) = ui.allocate_exact_size(vec2(12.0, 12.0), Sense::hover());
ui.painter().rect_filled(r, 2.0, c);
ui.label(egui::RichText::new(label).small().color(t.text_dim));
ui.add_space(6.0);
}
});
}
}
// ---------------------------------------------------------------- the step list
/// A step being dragged: the list it is in and its place there.
#[derive(Clone, Debug)]
struct StepDrag {
parent: String,
index: usize,
label: String,
}
fn step_list(app: &mut SheetApp, ui: &mut Ui, ed: &mut Editor, debugging: bool) {
let t = Tokens::get(ui.ctx());
let mut list = Vec::new();
rows(&ed.draft.steps, "", 0, &mut list);
if list.is_empty() {
ui.add_space(8.0);
ui.label(egui::RichText::new("No steps yet. Add Step picks a command, or record one with Automate › Record Macro.").color(t.text_dim));
return;
}
let current = ed.debug.as_ref().and_then(|s| s["current"]["step"].as_str().map(str::to_string));
let dragging = egui::DragAndDrop::payload::<StepDrag>(ui.ctx());
let pointer = ui.ctx().pointer_latest_pos();
let mut placed: Vec<(String, Rect)> = Vec::new();
egui::ScrollArea::vertical().id_salt("me_steps").auto_shrink([false, false]).show(ui, |ui| {
ui.spacing_mut().item_spacing.y = 1.0;
for row in &list {
let w = ui.available_width();
let (rect, resp) = ui.allocate_exact_size(vec2(w, 24.0), Sense::click_and_drag());
placed.push((row.parent.clone(), rect));
let selected = ed.selected.as_deref() == Some(row.key.as_str());
let is_current = current.as_deref() == Some(row.key.as_str());
let p = ui.painter();
if is_current {
p.rect_filled(rect, 3.0, t.accent_soft);
} else if selected {
p.rect_filled(rect, 3.0, t.pressed);
} else if resp.hovered() {
p.rect_filled(rect, 3.0, t.hover);
}
if resp.clicked() {
ed.selected = Some(row.key.clone());
ed.tab = Tab::Step;
}
let indent = row.depth as f32 * 16.0;
if let Some(label) = row.branch {
p.text(pos2(rect.left() + 58.0 + indent, rect.center().y), egui::Align2::LEFT_CENTER, label, theme::ui_bold(12.0), t.text_dim);
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("{label} branch {}", row.parent)));
continue;
}
let Some(st) = step_at(&ed.draft.steps, &row.key) else { continue };
// Gutter: the breakpoint dot (click to toggle), the current-step arrow.
let gutter = Rect::from_min_size(rect.min, vec2(18.0, rect.height()));
let g = ui.interact(gutter, Id::unique(("me_bp", &row.key)), Sense::click());
if st.breakpoint {
p.circle_filled(gutter.center(), 5.0, t.breakpoint);
} else if g.hovered() {
p.circle_stroke(gutter.center(), 4.5, Stroke::new(1.0, t.breakpoint));
}
if is_current {
let c = pos2(gutter.right() + 1.0, gutter.center().y);
p.add(egui::Shape::convex_polygon(vec![c + vec2(-6.0, -5.0), c + vec2(1.0, 0.0), c + vec2(-6.0, 5.0)], t.accent, Stroke::NONE));
}
g.widget_info(|| egui::WidgetInfo::selected(egui::Role::CheckBox, true, st.breakpoint, format!("Breakpoint {}", row.key)));
if g.on_hover_text("Breakpoint: the debugger stops before this step").clicked()
&& let Some(s) = step_mut(&mut ed.draft.steps, &row.key)
{
s.breakpoint = !s.breakpoint;
ed.dirty = true;
}
p.text(pos2(rect.left() + 48.0, rect.center().y), egui::Align2::RIGHT_CENTER, &row.key, theme::ui_font(11.5), t.text_dim);
let (icon, cat) = category(&st);
icons::paint(p, Rect::from_center_size(pos2(rect.left() + 62.0 + indent, rect.center().y), vec2(16.0, 16.0)), icon, t.cat(cat));
let text = summary(&st);
let text_color = if st.enabled { t.text } else { t.text_disabled };
let text_left = rect.left() + 76.0 + indent;
let text_clip = Rect::from_min_max(pos2(text_left, rect.top()), pos2(rect.right() - 46.0, rect.bottom()));
p.with_clip_rect(text_clip).text(pos2(text_left, rect.center().y), egui::Align2::LEFT_CENTER, &text, theme::ui_font(12.5), text_color);
resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, format!("Step {}: {text}", row.key)));
// Error marker.
let error = ed.errors.get(&row.key).cloned().or_else(|| static_error(&ed.draft, &st));
if let Some(err) = error {
let c = pos2(rect.right() - 36.0, rect.center().y);
p.circle_filled(c, 7.0, t.danger);
p.text(c, egui::Align2::CENTER_CENTER, "!", theme::ui_bold(11.0), t.window);
ui.interact(Rect::from_center_size(c, vec2(16.0, 16.0)), Id::unique(("me_err", &row.key)), Sense::hover()).on_hover_text(err);
}
// Enabled.
let mut on = st.enabled;
let cb =
ui.put(Rect::from_center_size(pos2(rect.right() - 12.0, rect.center().y), vec2(18.0, 18.0)), egui::Checkbox::without_text(&mut on));
if cb.on_hover_text("Run this step (a disabled step is skipped)").changed()
&& let Some(s) = step_mut(&mut ed.draft.steps, &row.key)
{
s.enabled = on;
ed.dirty = true;
}
if !debugging {
dnd::drag_source(ui, &resp, StepDrag { parent: row.parent.clone(), index: row.index, label: text.clone() });
}
}
});
// Dropping a dragged step among its own list's rows.
if let (Some(drag), Some(p)) = (dragging, pointer) {
let group: Vec<Rect> =
list.iter().zip(&placed).filter(|(r, _)| r.branch.is_none() && r.parent == drag.parent).map(|(_, (_, rect))| *rect).collect();
let zone = group.iter().fold(Rect::NOTHING, |a, r| a.union(*r));
let area = placed.iter().fold(Rect::NOTHING, |a, (_, r)| a.union(*r)).expand(12.0);
dnd::ghost(ui, &drag.label, p);
if area.contains(p) && zone.is_positive() {
dnd::drop_marker(ui, zone, &group, p.y);
}
if ui.input(|i| i.pointer.any_released()) {
let _ = egui::DragAndDrop::take_payload::<StepDrag>(ui.ctx());
if area.contains(p) {
let to = dnd::insert_index(&group, p.y);
if to != drag.index
&& to != drag.index + 1
&& let Some(path) = move_step(&mut ed.draft.steps, &drag.parent, drag.index, to)
{
ed.selected = Some(path);
ed.errors.clear();
ed.dirty = true;
}
}
}
}
let _ = app;
}
/// Where a new step goes: after the selected step in its list, at the end of a selected branch
/// or Repeat, or at the end of the macro.
fn insertion_point(ed: &Editor) -> (String, usize) {
let Some(sel) = ed.selected.as_deref() else { return (String::new(), ed.draft.steps.len()) };
let mut steps = ed.draft.steps.clone();
if split_path(sel).is_none() {
// A branch row: the end of that branch.
let len = list_mut(&mut steps, sel).map_or(0, |l| l.len());
return (sel.to_string(), len);
}
if let Some(st) = step_mut(&mut steps, sel)
&& let StepKind::Repeat { body, .. } = &st.kind
{
return (sel.to_string(), body.len());
}
match split_path(sel) {
Some((parent, i)) => (parent.to_string(), i + 1),
None => (String::new(), ed.draft.steps.len()),
}
}
fn insert_step(ed: &mut Editor, step: Step) {
let (parent, at) = insertion_point(ed);
if let Some(list) = list_mut(&mut ed.draft.steps, &parent) {
let at = at.min(list.len());
list.insert(at, step);
ed.selected = Some(child(&parent, at));
ed.tab = Tab::Step;
ed.errors.clear();
ed.dirty = true;
}
}
fn duplicate(ed: &mut Editor) {
let Some(sel) = ed.selected.clone() else { return };
let Some((parent, i)) = split_path(&sel) else { return };
if let Some(list) = list_mut(&mut ed.draft.steps, parent)
&& let Some(st) = list.get(i).cloned()
{
list.insert(i + 1, st);
ed.selected = Some(child(parent, i + 1));
ed.errors.clear();
ed.dirty = true;
}
}
fn delete(ed: &mut Editor) {
let Some(sel) = ed.selected.clone() else { return };
let Some((parent, i)) = split_path(&sel) else { return };
if let Some(list) = list_mut(&mut ed.draft.steps, parent)
&& i < list.len()
{
list.remove(i);
ed.selected = if list.is_empty() { (!parent.is_empty()).then(|| parent.to_string()) } else { Some(child(parent, i.min(list.len() - 1))) };
ed.errors.clear();
ed.dirty = true;
}
}
// ---------------------------------------------------------------- Add Step
/// The steps the picker offers for `query`: control steps first, then commands a macro may run.
pub fn picker_items(query: &str) -> Vec<(String, String, String)> {
let q = query.trim().to_ascii_lowercase();
let mut out: Vec<(String, String, String)> = [
("@repeat", "Repeat for each row", "Control: run steps once per row of a range"),
("@if", "If", "Control: run steps when a cell meets a condition"),
("@stop", "Stop with message", "Control: end the run with a message"),
]
.iter()
.filter(|(_, l, _)| q.is_empty() || l.to_ascii_lowercase().contains(&q))
.map(|(a, b, c)| (a.to_string(), b.to_string(), c.to_string()))
.collect();
for c in gridcraft_engine::command_specs() {
if matches!(macro_policy(c.id, &json!({}), gridcraft_engine::Trust::Local), Policy::Deny(_)) || c.id.starts_with("ui.") {
continue;
}
if q.is_empty() || c.label.to_ascii_lowercase().contains(&q) || c.id.to_ascii_lowercase().contains(&q) {
out.push((c.id.to_string(), c.label.to_string(), c.menu.join(" › ")));
}
if out.len() >= 60 {
break;
}
}
out
}
/// A new step for a picker item, with the command's required parameters filled in as blanks.
pub fn new_step(item: &str) -> Step {
match item {
"@repeat" => Step::new(StepKind::Repeat { over: "Input".into(), of: RepeatOf::Rows, max: 10_000, body: vec![] }),
"@if" => {
Step::new(StepKind::If { cell: "Input.cell(1,1)".into(), op: CompareOp::NotEmpty, value: Json::Null, then: vec![], otherwise: vec![] })
}
"@stop" => Step::new(StepKind::Stop { message: String::new(), rollback: false }),
id => {
let doc = gridcraft_engine::find_command(id).map(|c| c.params).unwrap_or("");
let params: Map<String, Json> = required_keys(doc).into_iter().map(|k| (k, json!(""))).collect();
Step::command(id, Json::Object(params))
}
}
}
fn picker(ui: &mut Ui, ed: &mut Editor) {
let Some(pk) = ed.picker.as_mut() else { return };
let t = Tokens::get(ui.ctx());
ui.horizontal(|ui| {
ui.label(egui::RichText::new(if pk.replace.is_some() { "Change the command" } else { "Add a step" }).strong());
if ui.small_button("Cancel").clicked() {
pk.search = "\u{1}".into();
}
});
if pk.search == "\u{1}" {
ed.picker = None;
return;
}
let r = ui.add(
egui::TextEdit::singleline(&mut pk.search)
.hint_text("Search commands, e.g. bold, sort, set…")
.desired_width(f32::INFINITY)
.id_salt("me_pick"),
);
r.request_focus();
if r.changed() {
pk.index = 0;
}
let mut items = picker_items(&pk.search);
// Change swaps a command step's command; it can't turn the step into Repeat, If or Stop.
if pk.replace.is_some() {
items.retain(|(id, ..)| !id.starts_with('@'));
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowDown)) {
pk.index = (pk.index + 1).min(items.len().saturating_sub(1));
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowUp)) {
pk.index = pk.index.saturating_sub(1);
}
let mut chosen = ui.input(|i| i.key_pressed(egui::Key::Enter)).then_some(pk.index);
egui::ScrollArea::vertical().id_salt("me_pick_list").auto_shrink([false, false]).show(ui, |ui| {
for (i, (id, label, menu)) in items.iter().enumerate() {
let r = ui.add(egui::Button::selectable(i == pk.index, label.as_str()).min_size(vec2(ui.available_width(), 20.0)));
if r.clicked() {
chosen = Some(i);
}
r.on_hover_text(format!("{id} {menu}"));
}
if items.is_empty() {
ui.label(egui::RichText::new("No command matches.").color(t.text_dim));
}
});
let Some(item) = chosen.and_then(|i| items.get(i)).map(|x| x.0.clone()) else { return };
let replace = pk.replace.clone();
ed.picker = None;
match replace {
Some(path) => {
let fresh = new_step(&item);
if let Some(st) = step_mut(&mut ed.draft.steps, &path) {
st.kind = fresh.kind;
ed.dirty = true;
}
}
None => insert_step(ed, new_step(&item)),
}
}
// ---------------------------------------------------------------- the inspector
fn inspector(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor, debugging: bool) {
ui.horizontal_wrapped(|ui| {
for (tab, label) in [(Tab::Step, "Details"), (Tab::Inputs, "Inputs"), (Tab::Output, "Output")] {
if ui.selectable_label(ed.tab == tab, label).clicked() {
ed.tab = tab;
}
}
});
ui.separator();
ui.add_enabled_ui(!debugging, |ui| match ed.tab {
Tab::Step => step_tab(app, ui, d, ed),
Tab::Inputs => inputs_tab(app, ui, d, ed),
Tab::Output => output_tab(app, ui, d, ed),
});
}
/// The dialog value key of a reference box.
fn ref_key(path: &str, field: &str) -> String {
format!("ref:{path}:{field}")
}
/// After a RefEdit box changed (typed, or picked on the grid): writes it into the draft.
fn apply_ref_value(ed: &mut Editor, d: &Dialog, key: &str) {
let Some(v) = d.values.get(key).and_then(Json::as_str).map(str::to_string) else { return };
let mut parts = key.splitn(3, ':');
let (_, path, field) = (parts.next(), parts.next().unwrap_or(""), parts.next().unwrap_or(""));
if set_ref(ed, path, field, &v) {
ed.dirty = true;
}
}
/// Writes reference text into the field a ref box edits. True when it changed.
fn set_ref(ed: &mut Editor, path: &str, field: &str, v: &str) -> bool {
match path {
"@output" => {
let new = (!v.trim().is_empty()).then(|| v.trim().to_string());
let changed = ed.draft.output.anchor != new;
ed.draft.output.anchor = new;
changed
}
"@example" => {
let changed = ed.example != v;
ed.example = v.to_string();
if let Some(i) = ed.draft.inputs.first_mut()
&& i.default_ref.is_some()
{
i.default_ref = Some(v.to_string());
}
changed
}
_ => {
let Some(st) = step_mut(&mut ed.draft.steps, path) else { return false };
let slot: Option<&mut String> = match (&mut st.kind, field) {
(StepKind::Repeat { over, .. }, "over") => Some(over),
(StepKind::If { cell, .. }, "cell") => Some(cell),
_ => None,
};
if let Some(s) = slot {
let changed = s != v;
*s = v.to_string();
return changed;
}
if let StepKind::Command { params, .. } = &mut st.kind
&& let Some(o) = params.as_object_mut()
{
let changed = o.get(field).and_then(Json::as_str) != Some(v);
o.insert(field.to_string(), json!(v));
return changed;
}
false
}
}
}
/// A reference box: RefEdit (type, or select on the grid), Relative/Absolute, and suggestions.
fn ref_field(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor, (path, field): (&str, &str), value: &str, in_repeat: bool) {
let key = ref_key(path, field);
if ed.refs.pick.as_deref() != Some(key.as_str()) || d.values.get(&key).is_none() {
d.values.insert(key.clone(), json!(value));
}
let width = (ui.available_width() - 96.0).clamp(120.0, 320.0);
ui.horizontal(|ui| {
ref_edit(app, ui, d, &mut ed.refs, &key, width);
apply_ref_value(ed, d, &key);
let current = d.values.get(&key).and_then(Json::as_str).unwrap_or("").to_string();
let Some(doc) = app.session.active() else { return };
let wb = doc.wb.clone();
let inputs = bound_inputs(&wb, ed);
let env = Env { wb: &wb, active_sheet: wb.active_sheet(), inputs: &inputs, output: None, item: None };
let relative = !current.trim().is_empty() && resolve::is_token(¤t, &env);
if path != "@example" {
if ui.selectable_label(relative, "Rel").on_hover_text("Relative: a token that follows the input the macro runs on").clicked() && !relative
{
let place = resolve::resolve_ref(¤t, &env).ok();
if let (Some(p), Some((name, input, _))) = (place, inputs.first())
&& p.sheet == input.sheet
{
let tok = token_for(name, input.range, p.range);
set_ref(ed, path, field, &tok);
d.values.insert(key.clone(), json!(tok));
ed.dirty = true;
}
}
if ui.selectable_label(!relative && !current.trim().is_empty(), "Abs").on_hover_text("Absolute: always these cells").clicked()
&& relative
&& let Ok(p) = resolve::resolve_ref(¤t, &env)
{
let a = resolve::a1(p, &env);
set_ref(ed, path, field, &a);
d.values.insert(key.clone(), json!(a));
ed.dirty = true;
}
let menu = ui.button("▾").on_hover_text("Tokens");
egui::Popup::menu(&menu).show(|ui| {
ui.set_max_height(300.0);
egui::ScrollArea::vertical().show(ui, |ui| {
for tok in token_suggestions(&wb, ed, in_repeat) {
let shown =
resolve::resolve_ref(&tok, &env).map(|p| format!("{tok} {}", resolve::a1(p, &env))).unwrap_or_else(|_| tok.clone());
if ui.button(shown).clicked() {
set_ref(ed, path, field, &tok);
d.values.insert(key.clone(), json!(tok));
ed.dirty = true;
}
}
});
});
}
});
// What a token stands for on the example.
let current = d.values.get(&key).and_then(Json::as_str).unwrap_or("").to_string();
if let Some(doc) = app.session.active() {
let wb = &doc.wb;
let inputs = bound_inputs(wb, ed);
let env = Env { wb, active_sheet: wb.active_sheet(), inputs: &inputs, output: None, item: None };
if !current.trim().is_empty() && resolve::is_token(¤t, &env) && !current.starts_with("Row") && !current.starts_with("Output") {
let t = Tokens::get(ui.ctx());
match resolve::resolve_ref(¤t, &env) {
Ok(p) => ui.label(egui::RichText::new(format!("= {} on the example", resolve::a1(p, &env))).small().color(t.text_dim)),
Err(e) => ui.label(egui::RichText::new(e.message()).small().color(t.danger)),
};
}
}
}
fn step_tab(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor) {
let t = Tokens::get(ui.ctx());
let Some(path) = ed.selected.clone() else {
ui.label(egui::RichText::new("Select a step to see its settings.").color(t.text_dim));
return;
};
let Some(st) = step_at(&ed.draft.steps, &path) else {
ui.label(
egui::RichText::new(format!(
"Steps here run when the If is {}. Add Step puts a step in this branch.",
if path.ends_with("then") { "true" } else { "false" }
))
.color(t.text_dim),
);
return;
};
let in_repeat = path.contains('.');
let (icon, cat) = category(&st);
ui.horizontal(|ui| {
let (r, _) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::hover());
icons::paint(ui.painter(), r, icon, t.cat(cat));
let title = match &st.kind {
StepKind::Command { id, .. } => command_label(id),
StepKind::Repeat { .. } => "Repeat".into(),
StepKind::If { .. } => "If".into(),
StepKind::Stop { .. } => "Stop".into(),
};
ui.label(egui::RichText::new(format!("Step {path} · {title}")).strong());
if let StepKind::Command { id, .. } = &st.kind {
ui.label(egui::RichText::new(id).monospace().color(t.text_dim));
if ui.small_button("Change…").clicked() {
ed.picker = Some(Picker { replace: Some(path.clone()), ..Default::default() });
}
}
});
let mut enabled = st.enabled;
let mut bp = st.breakpoint;
ui.horizontal(|ui| {
let a = ui.checkbox(&mut enabled, "Enabled").changed();
let b = ui.checkbox(&mut bp, "Breakpoint").changed();
if (a || b)
&& let Some(s) = step_mut(&mut ed.draft.steps, &path)
{
s.enabled = enabled;
s.breakpoint = bp;
ed.dirty = true;
}
});
if let Some(e) = ed.errors.get(&path).cloned().or_else(|| static_error(&ed.draft, &st)) {
ui.label(egui::RichText::new(e).color(t.danger));
}
ui.add_space(4.0);
match st.kind.clone() {
StepKind::Command { id, params } => command_fields(app, ui, d, ed, &path, &id, ¶ms, in_repeat),
StepKind::Repeat { over, of, max, .. } => {
ui.label("For each");
let mut of2 = of;
ui.horizontal(|ui| {
ui.radio_value(&mut of2, RepeatOf::Rows, "row");
ui.radio_value(&mut of2, RepeatOf::Columns, "column");
ui.label("of:");
});
ref_field(app, ui, d, ed, (&path, "over"), &over, in_repeat);
let mut max2 = max;
ui.horizontal(|ui| {
ui.label("At most");
ui.add(egui::DragValue::new(&mut max2).range(1..=100_000));
ui.label("times");
});
if (of2 != of || max2 != max)
&& let Some(StepKind::Repeat { of, max, .. }) = step_mut(&mut ed.draft.steps, &path).map(|s| &mut s.kind)
{
*of = of2;
*max = max2;
ed.dirty = true;
}
ui.label(egui::RichText::new("Inside, Row (or Column) stands for the current one, e.g. Row.right.").small().color(t.text_dim));
}
StepKind::If { cell, op, value, .. } => {
ui.label("If cell");
ref_field(app, ui, d, ed, (&path, "cell"), &cell, in_repeat);
let mut op2 = op;
let ops = [
(CompareOp::Eq, "equals"),
(CompareOp::Ne, "doesn't equal"),
(CompareOp::Gt, "is greater than"),
(CompareOp::Ge, "is at least"),
(CompareOp::Lt, "is less than"),
(CompareOp::Le, "is at most"),
(CompareOp::Empty, "is empty"),
(CompareOp::NotEmpty, "isn't empty"),
(CompareOp::Contains, "contains"),
];
let label = ops.iter().find(|(o, _)| *o == op).map_or("", |x| x.1);
craft_ui::ComboBox::from_id_salt(("me_op", &path)).selected_text(label).show_ui(ui, |ui| {
for (o, l) in ops {
ui.selectable_value(&mut op2, o, l);
}
});
let mut text = match &value {
Json::String(s) => s.clone(),
Json::Null => String::new(),
other => other.to_string(),
};
let changed_value = if matches!(op2, CompareOp::Empty | CompareOp::NotEmpty) {
false
} else {
ui.add(egui::TextEdit::singleline(&mut text).hint_text("value").id_salt(("me_ifv", &path))).changed()
};
if (op2 != op || changed_value)
&& let Some(StepKind::If { op, value, .. }) = step_mut(&mut ed.draft.steps, &path).map(|s| &mut s.kind)
{
*op = op2;
if changed_value {
*value = scalar(&text);
}
ed.dirty = true;
}
}
StepKind::Stop { message, rollback } => {
let (mut m, mut rb) = (message.clone(), rollback);
ui.label("Message:");
let a = ui.add(egui::TextEdit::singleline(&mut m).desired_width(f32::INFINITY).id_salt(("me_stop", &path))).changed();
let b = ui.checkbox(&mut rb, "Undo what the macro did before stopping").changed();
if (a || b)
&& let Some(StepKind::Stop { message, rollback }) = step_mut(&mut ed.draft.steps, &path).map(|s| &mut s.kind)
{
*message = m;
*rollback = rb;
ed.dirty = true;
}
}
}
ui.add_space(6.0);
ui.label("Note:");
let mut note = st.note.clone();
if ui.add(egui::TextEdit::multiline(&mut note).desired_rows(2).desired_width(f32::INFINITY).id_salt(("me_note", &path))).changed()
&& let Some(s) = step_mut(&mut ed.draft.steps, &path)
{
s.note = note;
ed.dirty = true;
}
}
/// Typed text as a JSON value: a number, TRUE/FALSE, or text.
fn scalar(text: &str) -> Json {
let t = text.trim();
if let Ok(n) = t.parse::<f64>()
&& n.is_finite()
{
return json!(n);
}
match t.to_ascii_lowercase().as_str() {
"true" => json!(true),
"false" => json!(false),
_ => json!(text),
}
}
#[allow(clippy::too_many_arguments)]
fn command_fields(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor, path: &str, id: &str, params: &Json, in_repeat: bool) {
let t = Tokens::get(ui.ctx());
let fields: Vec<(String, Json)> = params.as_object().map(|o| o.iter().map(|(k, v)| (k.clone(), v.clone())).collect()).unwrap_or_default();
let mut remove: Option<String> = None;
let mut set: Option<(String, Json)> = None;
egui::Grid::new(("me_params", path)).num_columns(3).spacing(vec2(8.0, 4.0)).show(ui, |ui| {
for (k, v) in &fields {
ui.label(k.as_str());
match v {
Json::String(s) if resolve::is_ref_key(k) => {
ui.vertical(|ui| ref_field(app, ui, d, ed, (path, k), s, in_repeat));
}
Json::String(s) => {
let mut text = s.clone();
if ui.add(egui::TextEdit::singleline(&mut text).desired_width(220.0).id_salt(("me_p", path, k))).changed() {
set = Some((k.clone(), json!(text)));
}
}
Json::Bool(b) => {
let mut on = *b;
if ui.checkbox(&mut on, "").changed() {
set = Some((k.clone(), json!(on)));
}
}
Json::Number(n) => {
let mut x = n.as_f64().unwrap_or(0.0);
if ui.add(egui::DragValue::new(&mut x).speed(0.1)).changed() {
set = Some((k.clone(), json!(x)));
}
}
other => {
let jk = format!("json:{path}:{k}");
let mut text = d.values.get(&jk).and_then(Json::as_str).map(str::to_string).unwrap_or_else(|| other.to_string());
let ok = serde_json::from_str::<Json>(&text).is_ok();
let r = ui.add(
egui::TextEdit::singleline(&mut text)
.desired_width(220.0)
.font(egui::TextStyle::Monospace)
.text_color(if ok { t.text } else { t.danger })
.id_salt(("me_pj", path, k)),
);
if r.changed() {
if let Ok(v) = serde_json::from_str::<Json>(&text) {
set = Some((k.clone(), v));
}
d.values.insert(jk, json!(text));
}
}
}
if crate::widgets::icon_button(ui, Icon::Close, t.text_dim, "Remove this parameter", vec2(18.0, 18.0)).clicked() {
remove = Some(k.clone());
}
ui.end_row();
}
});
if let Some(StepKind::Command { params, .. }) = step_mut(&mut ed.draft.steps, path).map(|s| &mut s.kind) {
if !params.is_object() {
*params = json!({});
}
if let Some(o) = params.as_object_mut() {
if let Some((k, v)) = set {
o.insert(k, v);
ed.dirty = true;
}
if let Some(k) = remove {
o.remove(&k);
ed.dirty = true;
}
}
}
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut ed.new_param.0).hint_text("parameter").desired_width(90.0).id_salt("me_np_k"));
ui.add(egui::TextEdit::singleline(&mut ed.new_param.1).hint_text("value").desired_width(140.0).id_salt("me_np_v"));
let key = ed.new_param.0.trim().to_string();
if ui.add_enabled(!key.is_empty(), egui::Button::new("Add")).clicked() {
let raw = ed.new_param.1.clone();
let v = serde_json::from_str::<Json>(&raw).unwrap_or(Json::String(raw));
if let Some(StepKind::Command { params, .. }) = step_mut(&mut ed.draft.steps, path).map(|s| &mut s.kind)
&& let Some(o) = params.as_object_mut()
{
o.insert(key, v);
ed.dirty = true;
}
ed.new_param = Default::default();
}
});
if let Some(spec) = gridcraft_engine::find_command(id)
&& !spec.params.is_empty()
{
ui.add_space(4.0);
ui.add(egui::Label::new(egui::RichText::new(spec.params).small().color(t.text_dim)).wrap());
}
}
fn inputs_tab(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor) {
let t = Tokens::get(ui.ctx());
ui.label(egui::RichText::new("The ranges the macro works on. Each is checked before the macro runs.").small().color(t.text_dim));
ui.horizontal_wrapped(|ui| {
for (k, i) in ed.draft.inputs.iter().enumerate() {
if ui.selectable_label(ed.input == k, i.name.as_str()).clicked() {
ed.input = k;
}
}
if ui.small_button("Add").clicked() && ed.draft.inputs.len() < 64 {
let n = (2..).map(|k| format!("Input{k}")).find(|n| !ed.draft.inputs.iter().any(|i| i.name.eq_ignore_ascii_case(n))).unwrap_or_default();
ed.draft.inputs.push(NamedInput { name: n, ..Default::default() });
ed.input = ed.draft.inputs.len() - 1;
ed.dirty = true;
}
if ui.add_enabled(!ed.draft.inputs.is_empty(), egui::Button::new("Remove").small()).clicked() && ed.input < ed.draft.inputs.len() {
ed.draft.inputs.remove(ed.input);
ed.input = ed.input.saturating_sub(1);
ed.dirty = true;
}
});
let k = ed.input;
let Some(mut i) = ed.draft.inputs.get(k).cloned() else {
ui.label(egui::RichText::new("No inputs: the macro works on fixed cells only.").color(t.text_dim));
return;
};
let before = i.clone();
ui.separator();
egui::Grid::new("me_input").num_columns(2).spacing(vec2(8.0, 4.0)).show(ui, |ui| {
ui.label("Name:");
ui.add(egui::TextEdit::singleline(&mut i.name).desired_width(140.0).id_salt("me_in_name"));
ui.end_row();
ui.label("Shape:");
ui.horizontal(|ui| {
ui.radio_value(&mut i.kind, InputKind::Range, "range");
ui.radio_value(&mut i.kind, InputKind::Cell, "single cell");
});
ui.end_row();
if i.kind == InputKind::Range {
ui.label("Data rows:");
ui.horizontal(|ui| {
ui.add(egui::DragValue::new(&mut i.rows[0]).range(0..=1_048_576).prefix("at least "));
ui.add(
egui::DragValue::new(&mut i.rows[1])
.range(0..=1_048_576)
.prefix("at most ")
.custom_formatter(|v, _| if v == 0.0 { "any".into() } else { format!("{v}") }),
);
});
ui.end_row();
ui.label("Columns:");
ui.horizontal(|ui| {
ui.add(egui::DragValue::new(&mut i.cols[0]).range(0..=16_384).prefix("at least "));
ui.add(
egui::DragValue::new(&mut i.cols[1])
.range(0..=16_384)
.prefix("at most ")
.custom_formatter(|v, _| if v == 0.0 { "any".into() } else { format!("{v}") }),
);
});
ui.end_row();
ui.label("");
ui.checkbox(&mut i.header, "First row holds column names");
ui.end_row();
}
ui.label("");
ui.checkbox(&mut i.non_empty, "Every cell must hold something");
ui.end_row();
});
// Column types, one per column of the example (or of the list so far).
let ncols = if k == 0 { parse_refs(&ed.example).first().map_or(0, |(_, r)| r.width() as usize) } else { 0 }.max(i.col_types.len()).min(16);
if i.kind == InputKind::Range && ncols > 0 {
ui.label("Each column must hold:");
let headers = if k == 0 { example_headers(app, &ed.example, i.header) } else { vec![] };
egui::Grid::new("me_types").num_columns(2).show(ui, |ui| {
for c in 0..ncols {
let label = headers.get(c).filter(|h| !h.is_empty()).cloned().unwrap_or_else(|| format!("Column {}", c + 1));
ui.label(label);
let mut ty = i.col_types.get(c).copied().unwrap_or(ColType::Any);
let before_ty = ty;
craft_ui::ComboBox::from_id_salt(("me_ty", c)).selected_text(type_name(ty)).show_ui(ui, |ui| {
for x in [ColType::Any, ColType::Number, ColType::Text, ColType::Date, ColType::Bool] {
ui.selectable_value(&mut ty, x, type_name(x));
}
});
if ty != before_ty {
while i.col_types.len() <= c {
i.col_types.push(ColType::Any);
}
if let Some(slot) = i.col_types.get_mut(c) {
*slot = ty;
}
}
ui.end_row();
}
});
}
if i != before {
tidy_input(&mut i, &before);
if let Some(slot) = ed.draft.inputs.get_mut(k) {
*slot = i;
}
ed.dirty = true;
}
if k == 0 {
ui.separator();
ui.label("Example (what Check, Run and Debug use here):");
let example = ed.example.clone();
ref_field(app, ui, d, ed, ("@example", "example"), &example, false);
ui.horizontal(|ui| {
if ui.button("Use current selection as example").clicked() {
use_selection_as_example(app, ed);
}
let mut fixed = ed.draft.inputs.first().is_some_and(|i| i.default_ref.is_some());
if ui.checkbox(&mut fixed, "Always run on this range").on_hover_text("Otherwise the macro runs on the selection").changed()
&& let Some(first) = ed.draft.inputs.first_mut()
{
first.default_ref = fixed.then(|| ed.example.clone());
ed.dirty = true;
}
});
}
}
fn type_name(t: ColType) -> &'static str {
match t {
ColType::Any => "anything",
ColType::Number => "numbers",
ColType::Text => "text",
ColType::Date => "dates",
ColType::Bool => "TRUE or FALSE",
}
}
/// The header texts of the example's first row (when it has a header).
fn example_headers(app: &SheetApp, example: &str, header: bool) -> Vec<String> {
let (Some(doc), true) = (app.session.active(), header) else { return vec![] };
let wb = &doc.wb;
let Some((sheet, r)) = parse_refs(example).into_iter().next() else { return vec![] };
let si = sheet.and_then(|s| wb.sheet_index(&s)).unwrap_or(wb.active_sheet());
let Some(sh) = wb.sheet(si) else { return vec![] };
(r.start.col..=r.end.col.min(r.start.col.saturating_add(15)))
.map(|c| gridcraft_engine::display::cell_text(wb, sh, gridcraft_engine::core::CellRef::new(r.start.row, c)))
.collect()
}
/// Keeps an input the person is editing to the shapes a macro may declare, as the edit is made:
/// a single cell is one row and one column with no header and at most one column type; a least
/// above its most moves the other end along (the one just set wins); and a range lists no more
/// column types than it allows columns.
pub fn tidy_input(i: &mut NamedInput, before: &NamedInput) {
if i.kind == InputKind::Cell {
(i.rows, i.cols, i.header) = ([1, 1], [1, 1], false);
i.col_types.truncate(1);
return;
}
for (now, was) in [(&mut i.rows, before.rows), (&mut i.cols, before.cols)] {
if now[1] != 0 && now[0] > now[1] {
if now[0] != was[0] {
now[1] = now[0];
} else {
now[0] = now[1];
}
}
}
if i.cols[1] != 0 {
i.col_types.truncate(i.cols[1] as usize);
}
}
/// "Use current selection as example": the selection becomes the first input's example, and its
/// shape, header and column types are read from it.
pub fn use_selection_as_example(app: &SheetApp, ed: &mut Editor) {
let Some(doc) = app.session.active() else { return };
let r = doc.selection.current();
let Some(sh) = doc.wb.active() else { return };
ed.example = r.a1();
let Some(first) = ed.draft.inputs.first_mut() else { return };
let inferred = infer_input(sh, r);
let before = first.clone();
first.kind = if r.is_single() { InputKind::Cell } else { InputKind::Range };
first.header = inferred.0;
first.col_types = inferred.1;
first.cols = [r.width(), r.width()];
first.rows = [1, 0];
tidy_input(first, &before);
if first.default_ref.is_some() {
first.default_ref = Some(ed.example.clone());
}
ed.dirty = true;
}
/// Whether the first row of `r` looks like a header (all text over a row that isn't), and what
/// each column holds below it.
pub fn infer_input(sh: &gridcraft_engine::model::Sheet, r: RangeRef) -> (bool, Vec<ColType>) {
use gridcraft_engine::core::{CellRef, Value};
let kind = |v: &Value| match v {
Value::Number(_) => Some(ColType::Number),
Value::Text(_) => Some(ColType::Text),
Value::Bool(_) => Some(ColType::Bool),
_ => None,
};
let rows = r.height().min(2_000);
let cols = r.width().min(16);
let first: Vec<Option<ColType>> = (0..cols).map(|c| kind(&sh.value(CellRef::new(r.start.row, r.start.col + c)))).collect();
let header = rows > 1
&& first.iter().all(|k| *k == Some(ColType::Text))
&& (0..cols).any(|c| matches!(kind(&sh.value(CellRef::new(r.start.row + 1, r.start.col + c))), Some(ColType::Number | ColType::Bool)));
let start = r.start.row + u32::from(header);
let types = (0..cols)
.map(|c| {
let mut seen: Option<ColType> = None;
for row in start..r.start.row + rows {
match (kind(&sh.value(CellRef::new(row, r.start.col + c))), seen) {
(None, _) => {}
(Some(k), None) => seen = Some(k),
(Some(k), Some(s)) if k == s => {}
_ => return ColType::Any,
}
}
seen.unwrap_or(ColType::Any)
})
.collect();
(header, types)
}
fn output_tab(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, ed: &mut Editor) {
let t = Tokens::get(ui.ctx());
ui.label("Output anchor (what the Output token stands for):");
let anchor = ed.draft.output.anchor.clone().unwrap_or_default();
ref_field(app, ui, d, ed, ("@output", "anchor"), &anchor, false);
ui.label(
egui::RichText::new("Leave it empty when no step uses Output. A token such as Input.right keeps it beside the data.")
.small()
.color(t.text_dim),
);
ui.add_space(6.0);
ui.label("When results would land on cells that hold data:");
let mut rule = ed.draft.output.on_conflict;
for (r, label) in [
(OnConflict::Ask, "Ask (overwrite, shift down or shift right)"),
(OnConflict::Fail, "Don't run"),
(OnConflict::Overwrite, "Overwrite the data"),
(OnConflict::ShiftDown, "Shift the data down"),
(OnConflict::ShiftRight, "Shift the data right"),
] {
ui.radio_value(&mut rule, r, label);
}
if rule != ed.draft.output.on_conflict {
ed.draft.output.on_conflict = rule;
ed.dirty = true;
}
ui.label(egui::RichText::new("Agents and other programs that run the macro get an error instead of the question.").small().color(t.text_dim));
if !ed.draft.permissions.is_empty() {
ui.add_space(6.0);
ui.label(format!("May use files through: {}", ed.draft.permissions.join(", ")));
}
}
// ---------------------------------------------------------------- grid overlays
/// What the grid shows while the editor is open: the inputs (blue), the cells the macro writes
/// (green), the ones among them that hold data (red), and the current step's target (outlined).
/// Each range is on the named sheet.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct MacroOverlay {
pub inputs: Vec<(String, RangeRef)>,
pub footprint: Vec<(String, RangeRef)>,
pub conflicts: Vec<(String, RangeRef)>,
pub target: Vec<(String, RangeRef)>,
}
impl MacroOverlay {
fn is_empty(&self) -> bool {
self.inputs.is_empty() && self.footprint.is_empty() && self.conflicts.is_empty() && self.target.is_empty()
}
}
fn named_refs(text: &str, default_sheet: &str) -> Vec<(String, RangeRef)> {
parse_refs(text).into_iter().map(|(s, r)| (s.unwrap_or_else(|| default_sheet.to_string()), r)).collect()
}
/// The overlay for the editor's last check and debugger state.
pub fn overlay(app: &SheetApp, ed: &Editor) -> Option<MacroOverlay> {
let sheet = app.session.active()?.wb.active()?.name.clone();
let mut o = MacroOverlay::default();
if let Some(c) = &ed.check {
for v in c["inputs"].as_object().into_iter().flat_map(|m| m.values()).filter_map(Json::as_str) {
o.inputs.extend(named_refs(v, &sheet));
}
for s in c["footprint"]["sheets"].as_array().into_iter().flatten() {
let name = s["sheet"].as_str().unwrap_or(&sheet).to_string();
for v in s["cells"].as_array().into_iter().flatten().filter_map(Json::as_str) {
o.footprint.extend(named_refs(v, &name));
}
for v in s["conflicts"].as_array().into_iter().flatten().filter_map(Json::as_str) {
o.conflicts.extend(named_refs(v, &name));
}
}
}
if let Some(st) = &ed.debug {
let cur = &st["current"];
if let Some(p) = cur["params"].as_object() {
for (k, v) in p {
if resolve::is_ref_key(k)
&& let Some(s) = v.as_str()
{
o.target.extend(named_refs(s, &sheet));
}
}
}
for k in ["over", "cell"] {
if let Some(s) = cur[k].as_str() {
o.target.extend(named_refs(s, &sheet));
}
}
}
(!o.is_empty()).then_some(o)
}
/// One overlay layer: its ranges, colour, wash alpha and stroke width.
type OverlayLayer<'a> = (&'a Vec<(String, RangeRef)>, Color32, u8, f32);
/// Paints the overlay's ranges on `sh` (called from the grid's overlay pass).
pub fn paint_overlay(p: &egui::Painter, geo: &crate::grid::Geo, sh: &gridcraft_engine::model::Sheet, o: &MacroOverlay) {
let t = Tokens::get(p.ctx());
let wash = |c: Color32, a: u8| Color32::from_rgba_unmultiplied(c.r(), c.g(), c.b(), a);
let layers: [OverlayLayer; 3] = [
(&o.footprint, t.sheet_macro_footprint, 30, 1.5),
(&o.inputs, t.sheet_macro_input, 26, 2.0),
(&o.conflicts, t.sheet_macro_conflict, 60, 2.0),
];
for (list, c, alpha, width) in layers {
for (name, r) in list.iter().filter(|(n, _)| n.eq_ignore_ascii_case(&sh.name)) {
let rect = geo.range_rect(sh, *r);
if !p.clip_rect().intersects(rect) {
continue;
}
p.rect_filled(rect, 0.0, wash(c, alpha));
p.rect_stroke(rect, 0.0, Stroke::new(width, c), StrokeKind::Inside);
let _ = name;
}
}
for (_, r) in o.target.iter().filter(|(n, _)| n.eq_ignore_ascii_case(&sh.name)) {
let rect = geo.range_rect(sh, *r).expand(1.0);
p.rect_stroke(rect, 1.0, Stroke::new(2.5, t.sheet_macro_target), StrokeKind::Outside);
for corner in [rect.left_top(), rect.right_top(), rect.left_bottom(), rect.right_bottom()] {
p.rect_filled(Rect::from_center_size(corner, vec2(5.0, 5.0)), 0.0, t.sheet_macro_target);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn example_references_unquote_sheet_names_as_formulas_do() {
// #2012: one shared reading of `'Bob''s'!A1` and `'a!b'!A1`.
let refs = parse_refs("'Bob''s'!$A$1:$B$2, 'a!b'!C3, D4");
let sheets: Vec<Option<String>> = refs.iter().map(|(s, _)| s.clone()).collect();
assert_eq!(sheets, [Some("Bob's".to_string()), Some("a!b".to_string()), None]);
assert_eq!(refs.iter().map(|(_, r)| r.a1()).collect::<Vec<_>>(), ["A1:B2", "C3", "D4"]);
}
#[test]
fn an_edited_input_keeps_a_shape_a_macro_may_declare() {
let range = NamedInput { rows: [2, 10], cols: [3, 3], header: true, col_types: vec![ColType::Number; 3], ..NamedInput::default() };
// Switching a range to a single cell drops what a cell can't have.
let mut cell = NamedInput { kind: InputKind::Cell, ..range.clone() };
tidy_input(&mut cell, &range);
assert_eq!((cell.rows, cell.cols, cell.header, cell.col_types.len()), ([1, 1], [1, 1], false, 1));
// A least set above the most moves the most up; a most set below the least moves the least.
let mut i = NamedInput { rows: [12, 10], ..range.clone() };
tidy_input(&mut i, &range);
assert_eq!(i.rows, [12, 12]);
let mut i = NamedInput { rows: [2, 1], ..range.clone() };
tidy_input(&mut i, &range);
assert_eq!(i.rows, [1, 1]);
// At most 0 is no limit; fewer columns drop the column types past them.
let mut i = NamedInput { rows: [12, 0], cols: [1, 2], ..range.clone() };
tidy_input(&mut i, &range);
assert_eq!((i.rows, i.cols, i.col_types.len()), ([12, 0], [1, 2], 2));
// Each passes the format's own check.
for input in [cell, i] {
let m = Macro { name: "M".into(), inputs: vec![input], ..Macro::default() };
assert_eq!(m.check_limits(), Ok(()), "{m:?}");
}
}
fn steps() -> Vec<Step> {
vec![
Step::command("cell.set", json!({"cell": "A1", "input": "x"})),
Step::new(StepKind::Repeat {
over: "Input".into(),
of: RepeatOf::Rows,
max: 10,
body: vec![Step::command("cell.set", json!({"cell": "Row.right", "input": "a"})), Step::command("home.bold", json!({}))],
}),
Step::new(StepKind::If {
cell: "B1".into(),
op: CompareOp::Empty,
value: Json::Null,
then: vec![Step::new(StepKind::Stop { message: "empty".into(), rollback: false })],
otherwise: vec![],
}),
]
}
#[test]
fn paths_reach_nested_steps() {
let mut s = steps();
assert_eq!(split_path("3.then.1"), Some(("3.then", 0)));
assert_eq!(split_path("3.then"), None);
assert_eq!(split_path("0"), None);
assert!(matches!(step_at(&s, "2.2").map(|s| s.kind), Some(StepKind::Command { id, .. }) if id == "home.bold"));
assert!(matches!(step_at(&s, "3.then.1").map(|s| s.kind), Some(StepKind::Stop { .. })));
assert!(step_at(&s, "3.else.1").is_none());
assert!(step_at(&s, "1.1").is_none(), "a command has no body");
assert!(step_at(&s, "9").is_none());
assert!(list_mut(&mut s, "3.else").is_some_and(|l| l.is_empty()));
}
#[test]
fn rows_flatten_with_branches() {
let mut out = Vec::new();
rows(&steps(), "", 0, &mut out);
let keys: Vec<&str> = out.iter().map(|r| r.key.as_str()).collect();
assert_eq!(keys, ["1", "2", "2.1", "2.2", "3", "3.then", "3.then.1", "3.else"]);
assert_eq!(out.iter().find(|r| r.key == "2.2").map(|r| (r.parent.as_str(), r.index, r.depth)), Some(("2", 1, 1)));
assert_eq!(out.iter().find(|r| r.key == "3.then").and_then(|r| r.branch), Some("Then"));
}
#[test]
fn moving_a_step_within_its_list() {
let mut s = steps();
// Step 1 dropped after step 2 (before row 2 of 0..3).
assert_eq!(move_step(&mut s, "", 0, 2).as_deref(), Some("2"));
assert!(matches!(&s[0].kind, StepKind::Repeat { .. }));
// Inside the Repeat: the second step to the top.
assert_eq!(move_step(&mut s, "1", 1, 0).as_deref(), Some("1.1"));
assert!(matches!(step_at(&s, "1.1").map(|s| s.kind), Some(StepKind::Command { id, .. }) if id == "home.bold"));
assert_eq!(move_step(&mut s, "", 7, 0), None);
// Past the end lands last.
assert_eq!(move_step(&mut s, "", 0, 99).as_deref(), Some("3"));
}
#[test]
fn breakpoints_are_listed_by_path() {
let mut s = steps();
for p in ["1", "2.2", "3.then.1"] {
if let Some(st) = step_mut(&mut s, p) {
st.breakpoint = true;
}
}
let mut out = Vec::new();
breakpoints(&s, "", &mut out);
assert_eq!(out, ["1", "2.2", "3.then.1"]);
}
#[test]
fn summaries_and_categories() {
let s = steps();
assert_eq!(summary(&s[0]), "Set A1 to x");
assert_eq!(summary(&s[1]), "Repeat for each row of Input");
assert_eq!(summary(&s[2]), "If B1 is empty");
assert_eq!(category(&s[0]), (Icon::Sheet, Cat::Blue));
assert_eq!(category(&s[1]).1, Cat::Purple);
let long = Step::command("home.bold", json!({"range": "A1:B2"}));
assert!(summary(&long).contains("range: A1:B2"), "{}", summary(&long));
}
#[test]
fn static_errors_flag_unknown_and_denied_commands() {
let m = Macro::default();
assert!(static_error(&m, &Step::command("no.such", json!({}))).is_some_and(|e| e.contains("no command")));
assert!(static_error(&m, &Step::command("file.save", json!({}))).is_some_and(|e| e.contains("can't run in a macro")));
assert!(static_error(&m, &Step::command("data.getData", json!({"path": "/tmp/x.csv"}))).is_some_and(|e| e.contains("permissions")));
assert_eq!(static_error(&m, &Step::command("cell.set", json!({"cell": "A1"}))), None);
}
#[test]
fn required_keys_come_from_the_params_doc() {
assert_eq!(required_keys("{cell?: \"B2\", input: \"text, number or =formula\", sheet?, array?: bool}"), ["cell", "input"]);
assert_eq!(required_keys("{range?, options: {a, b}, on?: bool}"), ["range", "options"]);
assert!(required_keys("no braces").is_empty());
assert!(required_keys("{").is_empty());
}
#[test]
fn the_picker_offers_control_steps_and_allowed_commands_only() {
let all = picker_items("");
assert_eq!(all.first().map(|x| x.0.as_str()), Some("@repeat"));
// Denied commands aren't offered (exports without a path are allowed).
let all = picker_items("e");
assert!(!all.iter().any(|x| x.0 == "file.save" || x.0 == "edit.undo" || x.0.starts_with("macro.")));
let bold = picker_items("bold");
assert!(bold.iter().any(|x| x.0 == "home.bold"));
assert!(matches!(new_step("@if").kind, StepKind::If { .. }));
assert!(matches!(new_step("cell.set").kind, StepKind::Command { params, .. } if params.get("cell").is_some()));
}
#[test]
fn tokens_for_ranges_resolve_back_to_them() {
let wb = Workbook::default();
let input = RangeRef::parse("B2:D9").unwrap_or(RangeRef::cell(gridcraft_engine::core::CellRef::new(0, 0)));
let inputs = vec![("Input".to_string(), Place { sheet: 0, range: input }, false)];
let env = Env { wb: &wb, active_sheet: 0, inputs: &inputs, output: None, item: None };
for (target, want) in [
("B2:D9", "Input"),
("C2:C9", "Input.col(2)"),
("B2:C9", "Input.cols(1..2)"),
("B3:D9", "Input.rows(2..8)"),
("B4:D4", "Input.row(3)"),
("C3", "Input.cell(2,2)"),
("C3:D4", "Input.cell(2,2).resize(2,2)"),
("F2:H9", "Input.offset(0,4)"),
("E2", "Input.cell(1,1).offset(0,3)"),
("E2:E9", "Input.cell(1,1).offset(0,3).resize(8,1)"),
] {
let r = RangeRef::parse(target).unwrap_or(input);
let tok = token_for("Input", input, r);
assert_eq!(tok, want, "{target}");
assert_eq!(resolve::resolve_ref(&tok, &env).map(|p| p.range), Ok(r), "{tok}");
}
}
#[test]
fn references_parse_with_sheets_and_dollars() {
let refs = parse_refs("'My Sheet'!$B$2:$C$3, D4");
assert_eq!(refs.len(), 2);
assert_eq!(refs[0].0.as_deref(), Some("My Sheet"));
assert_eq!(refs[0].1.a1(), "B2:C3");
assert_eq!(refs[1], (None, RangeRef::parse("D4").unwrap_or(refs[0].1)));
assert!(parse_refs("not a ref").is_empty());
}
#[test]
fn inputs_are_inferred_from_an_example() {
use gridcraft_engine::core::{CellRef, Value};
let mut sh = gridcraft_engine::model::Sheet::new("S");
for (c, h) in ["Item", "Qty"].iter().enumerate() {
sh.set_value(CellRef::new(0, c as u32), Value::Text((*h).into()));
}
for r in 1..4 {
sh.set_value(CellRef::new(r, 0), Value::Text(format!("x{r}").into()));
sh.set_value(CellRef::new(r, 1), Value::Number(f64::from(r)));
}
let (header, types) = infer_input(&sh, RangeRef::parse("A1:B4").unwrap_or(RangeRef::cell(CellRef::new(0, 0))));
assert!(header);
assert_eq!(types, [ColType::Text, ColType::Number]);
}
}
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.