a770fa5a5e5f
attedit.rs
//! ATTEDIT / EATTEDIT: one block reference's attribute values, asked for one after another.
//! -ATTEDIT: the attributes picked by block name, tag and value specifications, edited one at a
//! time or by replacing a string in all of them. Attribute tags match in any case, as in AutoCAD.
use cadcraft_doc::color::Color;
use cadcraft_doc::{AttribProps, Common, EntityKind, HAlign, Handle, Text, VAlign};
use serde_json::{Map, Value, json};
use crate::cmd::curves::KW;
use crate::cmd::machines::{SelOutcome, SelectPhase};
use crate::cmd::qselect::wildcard;
use crate::cmd::{CommandSpec, bad, str_param, targets};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
/// Longest attribute value a string replacement may produce (bytes).
const MAX_VALUE: usize = 65_536;
pub(super) fn attedit_spec() -> CommandSpec {
CommandSpec::new("attedit", "Single...", run)
.menu(&["Modify", "Object", "Attribute", "Single..."])
.alias(&["ate", "eattedit"])
.params("{handle, values: {TAG: value} (tags in any case)} โ {changed, unknownTags?}")
.interactive(|_| Ok(Box::new(AtteditM::default())))
}
pub(super) fn dash_attedit_spec() -> CommandSpec {
CommandSpec::new("-attedit", "Global", run_global)
.menu(&["Modify", "Object", "Attribute", "Global"])
.alias(&["-ate", "atte"])
.params("{find, replace?, block?, tag?, value? (wildcard specifications, default *), handles? (default: every block reference in the current space)} โ {changed}")
.interactive(|_| Ok(Box::new(DashAtteditM::default())))
}
/// The value `values` gives for `tag`, matching the tag in any case. Numbers and booleans count
/// as their text.
pub(super) fn value_for(values: &Map<String, Value>, tag: &str) -> Option<String> {
let v = values.get(tag).or_else(|| values.iter().find(|(k, _)| k.eq_ignore_ascii_case(tag)).map(|(_, v)| v))?;
match v {
Value::String(t) => Some(t.clone()),
Value::Number(n) => Some(n.to_string()),
Value::Bool(b) => Some(b.to_string()),
_ => None,
}
}
/// `r` with `unknownTags`: the keys of `values` that block reference `h` has no attribute for
/// (left out when there are none).
pub(super) fn with_unknown_tags(s: &Session, h: Handle, values: &Map<String, Value>, mut r: Value) -> Value {
let tags: Vec<&str> = match s.doc().ok().and_then(|d| d.entity(h)).map(|e| &e.kind) {
Some(EntityKind::Insert(i)) => i.attribs.iter().map(|a| a.tag.as_str()).collect(),
_ => Vec::new(),
};
let unknown: Vec<&String> = values.keys().filter(|k| !tags.iter().any(|t| t.eq_ignore_ascii_case(k))).collect();
if !unknown.is_empty()
&& let Some(o) = r.as_object_mut()
{
o.insert("unknownTags".into(), json!(unknown));
}
r
}
fn run(s: &mut Session, p: &Value) -> Result<Value> {
let h = targets(s, p)?.first().copied().ok_or_else(|| bad("attedit", "`handle` is required"))?;
let vals = p.get("values").and_then(Value::as_object).cloned().unwrap_or_default();
let mut n = 0;
s.doc_mut()?.modify_entity(h, |e| {
if let EntityKind::Insert(i) = &mut e.kind {
for a in &mut i.attribs {
if let Some(v) = value_for(&vals, &a.tag) {
set_value(&mut a.text, v);
n += 1;
}
}
}
})?;
Ok(with_unknown_tags(s, h, &vals, json!({ "changed": n })))
}
/// A block name, tag or value specification: comma-separated wildcard patterns, any case. For
/// values, `\` matches an empty value.
fn spec_matches(spec: &str, text: &str) -> bool {
spec.split(',').any(|p| if p.trim() == "\\" { text.is_empty() } else { wildcard(p.trim(), text) })
}
/// Specifications choosing attributes: block name, tag, value.
#[derive(Clone, Debug)]
struct Specs {
block: String,
tag: String,
value: String,
}
impl Default for Specs {
fn default() -> Self {
Specs { block: "*".into(), tag: "*".into(), value: "*".into() }
}
}
/// The attributes of block references `hs` that match `specs`, as (block reference, attribute
/// index). Invisible attributes count only with `invisible` (or while ATTMODE shows them).
fn matching(s: &Session, hs: &[Handle], specs: &Specs, invisible: bool) -> Result<Vec<(Handle, usize)>> {
let d = s.doc()?;
let invisible = invisible || d.header.i64("ATTMODE", 1) == 2;
let mut out = Vec::new();
for h in hs {
let Some(EntityKind::Insert(ins)) = d.entity(*h).map(|e| &e.kind) else { continue };
if !spec_matches(&specs.block, &ins.block) {
continue;
}
for (k, a) in ins.attribs.iter().enumerate() {
if !a.constant && (invisible || !a.invisible) && spec_matches(&specs.tag, &a.tag) && spec_matches(&specs.value, &a.text.value) {
out.push((*h, k));
}
}
}
Ok(out)
}
/// Every object in the current space.
fn all_in_space(s: &Session) -> Result<Vec<Handle>> {
let d = s.doc()?;
Ok(d.space(&s.space()).map(|st| st.iter().map(|e| e.handle).collect()).unwrap_or_default())
}
/// Change attribute `k` of block reference `h`; returns whether its value changed.
fn edit(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&str) -> Option<String>) -> Result<bool> {
let mut changed = false;
s.doc_mut()?.modify_entity(h, |e| {
if let EntityKind::Insert(ins) = &mut e.kind
&& let Some(a) = ins.attribs.get_mut(k)
&& let Some(v) = f(&a.text.value).filter(|v| *v != a.text.value)
{
set_value(&mut a.text, v);
changed = true;
}
})?;
Ok(changed)
}
/// Refresh the derived baseline after a value change, even one within the writer's
/// imported-font tolerance. Equal XY points request recomputation on export; retain
/// both elevations and the independent endpoints used by Aligned/Fit text.
fn set_value(text: &mut Text, value: String) {
if text.value == value {
return;
}
text.value = value;
if !matches!((text.halign, text.valign), (HAlign::Left, VAlign::Baseline) | (HAlign::Aligned | HAlign::Fit, _))
&& let Some(anchor) = text.align_pt
{
text.insert.x = anchor.x;
text.insert.y = anchor.y;
}
}
/// Change the properties set on attribute `k` of block reference `h`.
fn set_props(s: &mut Session, (h, k): (Handle, usize), f: impl FnOnce(&mut AttribProps)) -> Result<()> {
s.doc_mut()?.modify_entity(h, |e| {
if let EntityKind::Insert(ins) = &mut e.kind
&& let Some(a) = ins.attribs.get_mut(k)
{
f(&mut a.props);
}
})?;
Ok(())
}
/// The layer and colour attribute `k` of block reference `h` is drawn with: its own, else its
/// definition's (layer 0 is the reference's layer).
fn current_props(s: &Session, (h, k): (Handle, usize)) -> Option<(String, Color)> {
let d = s.doc().ok()?;
let e = d.entity(h)?;
let EntityKind::Insert(ins) = &e.kind else { return None };
let a = ins.attribs.get(k)?;
let def = d
.block(&ins.block)
.and_then(|b| b.entities.iter().find(|be| matches!(&be.kind, EntityKind::AttDef(ad) if ad.tag.eq_ignore_ascii_case(&a.tag))));
let c = a.props.over(&def.map(|de| de.common.clone()).unwrap_or_else(Common::default));
let layer = if c.layer == "0" { e.common.layer.clone() } else { c.layer };
Some((layer, c.color))
}
/// Replace every `find` in `value` with `with`, unless the result would be too long.
fn replaced(value: &str, find: &str, with: &str) -> Option<String> {
if find.is_empty() || !value.contains(find) {
return None;
}
let n = value.matches(find).count();
let len = value.len().checked_sub(n.checked_mul(find.len())?)?.checked_add(n.checked_mul(with.len())?)?;
(len <= MAX_VALUE).then(|| value.replace(find, with))
}
/// Replace `find` with `with` in the given attributes; returns how many changed.
fn replace_all(s: &mut Session, items: &[(Handle, usize)], find: &str, with: &str) -> Result<usize> {
let mut n = 0;
for it in items {
if edit(s, *it, |v| replaced(v, find, with))? {
n += 1;
}
}
Ok(n)
}
fn run_global(s: &mut Session, p: &Value) -> Result<Value> {
let find = str_param(p, "find").filter(|f| !f.is_empty()).ok_or_else(|| bad("-attedit", "`find` (a non-empty string) is required"))?;
let with = str_param(p, "replace").unwrap_or("");
let spec = |k| str_param(p, k).unwrap_or("*").to_string();
let specs = Specs { block: spec("block"), tag: spec("tag"), value: spec("value") };
let hs = if p.get("handles").is_some() || p.get("handle").is_some() { targets(s, p)? } else { all_in_space(s)? };
let items = matching(s, &hs, &specs, true)?;
let (find, with) = (find.to_string(), with.to_string());
Ok(json!({ "changed": replace_all(s, &items, &find, &with)? }))
}
// ---------------- ATTEDIT / EATTEDIT ----------------
#[derive(Default)]
struct AtteditM {
block: Option<Handle>,
/// Index, tag and current value of each editable attribute of the picked block reference.
attribs: Vec<(usize, String, String)>,
/// The values answered so far, in attribute order.
values: Vec<String>,
}
impl AtteditM {
fn pick(&mut self, s: &Session, hs: &[Handle]) -> Result<()> {
let d = s.doc()?;
let mut msg = "Select a block reference.";
for h in hs {
let Some(EntityKind::Insert(ins)) = d.entity(*h).map(|e| &e.kind) else { continue };
let atts: Vec<(usize, String, String)> =
ins.attribs.iter().enumerate().filter(|(_, a)| !a.constant).map(|(k, a)| (k, a.tag.clone(), a.text.value.clone())).collect();
if atts.is_empty() {
msg = "That block reference has no editable attributes.";
continue;
}
self.block = Some(*h);
self.attribs = atts;
return Ok(());
}
Err(EngineError::Other(msg.into()))
}
}
impl Interactive for AtteditM {
fn name(&self) -> &'static str {
"ATTEDIT"
}
fn prompt(&self, _s: &Session) -> Prompt {
match self.attribs.get(self.values.len()) {
Some((_, tag, cur)) if self.block.is_some() => Prompt::new(format!("Enter value for {tag}"), Accept::TEXT).default(cur.clone()),
_ => Prompt::new("Select block reference", Accept::SELECT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let Some(h) = self.block else {
return match i {
Input::Pick(hs) => self.pick(s, &hs).map(|_| Step::Continue),
Input::Enter => Ok(Step::Done),
Input::Text(_) | Input::Keyword(_) => Err(EngineError::Other("Select a block reference.".into())),
_ => Ok(Step::Continue),
};
};
let cur = self.attribs.get(self.values.len()).map(|a| a.2.clone()).unwrap_or_default();
self.values.push(match i {
Input::Text(t) => t,
Input::Enter => cur,
_ => return Ok(Step::Continue),
});
if self.values.len() < self.attribs.len() {
return Ok(Step::Continue);
}
// All answered: apply them together (one undo step).
for ((k, _, _), v) in self.attribs.iter().zip(&self.values) {
edit(s, (h, *k), |_| Some(v.clone()))?;
}
Ok(Step::Done)
}
}
// ---------------- -ATTEDIT ----------------
#[derive(Clone, Copy, Debug, Default, PartialEq)]
enum Stage {
#[default]
OneAtATime,
VisibleOnly,
BlockSpec,
TagSpec,
ValueSpec,
Select,
/// One at a time: what to do with the current attribute.
Option,
ValueKind,
NewValue,
Layer,
Color,
TrueColor,
Find,
Replace,
}
#[derive(Default)]
struct DashAtteditM {
stage: Stage,
one_at_a_time: bool,
visible_only: bool,
specs: Specs,
sel: SelectPhase,
items: Vec<(Handle, usize)>,
/// The attribute being edited one at a time (index into `items`).
cur: usize,
find: String,
}
/// A colour name, number or `r,g,b` (typed numbers are answers, not distances).
const NAME: Accept = Accept { number: true, ..Accept::TEXT };
fn invalid_keyword() -> EngineError {
EngineError::Other("Invalid option keyword.".into())
}
impl DashAtteditM {
fn yes(i: &Input) -> Result<bool> {
match i {
Input::Keyword(k) => Ok(k == "Yes"),
Input::Enter => Ok(true),
_ => Err(invalid_keyword()),
}
}
/// The attributes are chosen: start editing them.
fn chosen(&mut self, s: &mut Session, hs: &[Handle]) -> Result<Step> {
self.items = matching(s, hs, &self.specs, !self.visible_only && !self.one_at_a_time)?;
s.set_selection(Vec::new());
let n = self.items.len();
s.echo(format!("{n} attribute{} selected.", if n == 1 { "" } else { "s" }));
if n == 0 {
return Ok(Step::Done);
}
if self.one_at_a_time {
self.cur = 0;
self.show_current(s);
self.stage = Stage::Option;
} else {
self.stage = Stage::Find;
}
Ok(Step::Continue)
}
fn show_current(&self, s: &mut Session) {
let Some((h, k)) = self.items.get(self.cur).copied() else { return };
if let Ok(d) = s.doc()
&& let Some(EntityKind::Insert(ins)) = d.entity(h).map(|e| &e.kind)
&& let Some(a) = ins.attribs.get(k)
{
let line = format!("{} = {}", a.tag, a.text.value);
s.echo(line);
}
}
}
impl Interactive for DashAtteditM {
fn name(&self) -> &'static str {
"-ATTEDIT"
}
fn prompt(&self, s: &Session) -> Prompt {
let cur = self.items.get(self.cur).and_then(|it| current_props(s, *it));
match self.stage {
Stage::OneAtATime => Prompt::new("Edit attributes one at a time?", KW).kw(&["Yes", "No"]).default("Y"),
Stage::VisibleOnly => Prompt::new("Edit only attributes visible on screen?", KW).kw(&["Yes", "No"]).default("Y"),
Stage::BlockSpec => Prompt::new("Enter block name specification", Accept::TEXT).default("*"),
Stage::TagSpec => Prompt::new("Enter attribute tag specification", Accept::TEXT).default("*"),
Stage::ValueSpec => Prompt::new("Enter attribute value specification", Accept::TEXT).default("*"),
Stage::Select => Prompt::new("Select attributes", Accept::SELECT),
Stage::Option => Prompt::new("Enter an option", KW).kw(&["Value", "Layer", "Color", "Next"]).default("N"),
Stage::ValueKind => Prompt::new("Enter type of value modification", KW).kw(&["Change", "Replace"]).default("R"),
Stage::NewValue => Prompt::new("Enter new attribute value", Accept::TEXT),
Stage::Layer => {
let p = Prompt::new("Enter new layer name", Accept::TEXT);
match cur {
Some((layer, _)) => p.default(layer),
None => p,
}
}
Stage::Color => {
let p = Prompt::new("Enter new color", NAME).kw(&["Truecolor", "COlorbook"]);
match cur {
Some((_, c)) => p.default(c.name()),
None => p,
}
}
Stage::TrueColor => Prompt::new("Red, Green, Blue", NAME),
Stage::Find => Prompt::new("Enter string to change", Accept::TEXT),
Stage::Replace => Prompt::new("Enter new string", Accept::TEXT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
// Free-text answers; Enter gives "" (the specifications then take their default "*").
let text = match &i {
Input::Text(t) => Some(t.clone()),
Input::Enter => Some(String::new()),
_ => None,
};
match self.stage {
Stage::OneAtATime => {
self.one_at_a_time = Self::yes(&i)?;
self.stage = if self.one_at_a_time {
Stage::BlockSpec
} else {
s.echo("Performing global editing of attribute values.");
Stage::VisibleOnly
};
}
Stage::VisibleOnly => {
self.visible_only = Self::yes(&i)?;
self.stage = Stage::BlockSpec;
}
Stage::BlockSpec | Stage::TagSpec | Stage::ValueSpec => {
let Some(t) = text else { return Ok(Step::Continue) };
let t = if t.trim().is_empty() { "*".to_string() } else { t.trim().to_string() };
match self.stage {
Stage::BlockSpec => {
self.specs.block = t;
self.stage = Stage::TagSpec;
}
Stage::TagSpec => {
self.specs.tag = t;
self.stage = Stage::ValueSpec;
}
_ => {
self.specs.value = t;
if !self.one_at_a_time && !self.visible_only {
let hs = all_in_space(s)?;
return self.chosen(s, &hs);
}
self.stage = Stage::Select;
}
}
}
Stage::Select => {
return match self.sel.feed(s, &i)? {
SelOutcome::More => Ok(Step::Continue),
SelOutcome::Empty => self.chosen(s, &[]),
SelOutcome::Done(hs) => self.chosen(s, &hs),
};
}
Stage::Option => match &i {
Input::Keyword(k) if k == "Value" => self.stage = Stage::ValueKind,
Input::Keyword(k) if k == "Layer" => self.stage = Stage::Layer,
Input::Keyword(k) if k == "Color" => self.stage = Stage::Color,
Input::Keyword(_) | Input::Enter => {
self.cur += 1;
if self.cur >= self.items.len() {
return Ok(Step::Done);
}
self.show_current(s);
}
Input::Text(t) => {
let tl = t.trim().to_ascii_lowercase();
let later = ["Position", "Height", "Angle", "Style"];
return match later.iter().find(|k| !tl.is_empty() && k.to_ascii_lowercase().starts_with(&tl)) {
Some(k) => Err(EngineError::Other(format!("{k} is not available yet."))),
None => Err(invalid_keyword()),
};
}
_ => {}
},
Stage::ValueKind => match &i {
Input::Keyword(k) if k == "Change" => self.stage = Stage::Find,
Input::Keyword(_) | Input::Enter => self.stage = Stage::NewValue,
_ => return Err(invalid_keyword()),
},
Stage::NewValue => {
let Some(v) = text else { return Ok(Step::Continue) };
if let Some(it) = self.items.get(self.cur).copied() {
edit(s, it, |_| Some(v))?;
}
self.show_current(s);
self.stage = Stage::Option;
}
Stage::Layer => {
let Some(t) = text else { return Ok(Step::Continue) };
let t = t.trim();
if !t.is_empty() {
let name = s.doc()?.layer(t).map(|l| l.name.clone()).ok_or_else(|| EngineError::Other(format!("Cannot find layer \"{t}\".")))?;
if let Some(it) = self.items.get(self.cur).copied() {
set_props(s, it, |p| p.layer = Some(name))?;
}
}
self.stage = Stage::Option;
}
Stage::Color | Stage::TrueColor => {
if self.stage == Stage::Color
&& let Input::Keyword(k) = &i
{
if k == "Truecolor" {
self.stage = Stage::TrueColor;
return Ok(Step::Continue);
}
return Err(EngineError::Other("Color books are not available yet.".into()));
}
let Some(t) = text else { return Ok(Step::Continue) };
if !t.trim().is_empty() {
let c = match (self.stage, Color::parse(&t)) {
(Stage::TrueColor, Some(c @ Color::True(_))) | (Stage::Color, Some(c)) => c,
(Stage::TrueColor, _) => return Err(EngineError::Other("Enter three values from 0 to 255, separated by commas.".into())),
_ => return Err(EngineError::Other("Enter a color name or a number from 0 to 256.".into())),
};
if let Some(it) = self.items.get(self.cur).copied() {
set_props(s, it, |p| p.color = Some(c))?;
}
}
self.stage = Stage::Option;
}
Stage::Find => match text {
Some(t) if !t.is_empty() => {
self.find = t;
self.stage = Stage::Replace;
}
Some(_) => return Err(EngineError::Other("Requires the string to change.".into())),
None => {}
},
Stage::Replace => {
let Some(with) = text else { return Ok(Step::Continue) };
let find = std::mem::take(&mut self.find);
if self.one_at_a_time {
let items: Vec<(Handle, usize)> = self.items.get(self.cur).copied().into_iter().collect();
replace_all(s, &items, &find, &with)?;
self.show_current(s);
self.stage = Stage::Option;
} else {
let n = replace_all(s, &self.items, &find, &with)?;
s.echo(format!("{n} attribute{} changed.", if n == 1 { "" } else { "s" }));
return Ok(Step::Done);
}
}
}
Ok(Step::Continue)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn replacement_is_bounded_and_specs_take_lists() {
assert_eq!(replaced("a-b-c", "-", "+").as_deref(), Some("a+b+c"));
assert_eq!(replaced("abc", "x", "y"), None);
assert_eq!(replaced("aaaa", "a", &"x".repeat(MAX_VALUE)), None);
assert!(spec_matches("door,WIN*", "window"));
assert!(spec_matches("\\", ""));
assert!(!spec_matches("\\", "x"));
}
}
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.