a770fa5a5e5f
utility.rs
//! Utilities: CAL (expression calculator), FIND (find and replace text), MASSPROP, MEASUREGEOM.
use cadcraft_doc::{EntityKind, Handle};
use cadcraft_geom::{Segment, Vec2};
use serde_json::{Value, json};
use super::{CommandSpec, always, bad, bool_or, point_param, points_param, str_param, targets};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
pub fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("cal", "QuickCalc", run_cal)
.menu(&["Tools", "Inquiry", "Quick"])
.alias(&["quickcalc", "qc"])
.params(
"{expr: \"(3+4)*2^2\" | \"dist([0,0],[3,4])\", vars?: {x: 1, p: [x, y]}} → {value} | {point} | \
{convert: {type?: length|area|volume|angle, from, to, value}} → {value} | {units: true} → unit lists | \
{pick: point|distance|angle|intersection, points}",
)
.enabled(always)
.noundo()
.transparent()
.interactive(|_| Ok(Box::new(CalM))),
CommandSpec::new("quickcalc.pick", "QuickCalc Pick", run_quickcalc_pick)
.params("{mode: point|distance|angle|intersection, points: [[x,y],...]} → {value} | {point}")
.noundo()
.interactive(|_| Ok(Box::<PickM>::default())),
CommandSpec::new("find", "Find...", run_find).menu(&["Edit", "Find..."]).params(
"{find, replace?, matchCase?: bool, wholeWord?: bool, types?: [\"Text\", \"MText\", ...], handles?: [...]} → \
{matches: [{handle, type, count, snippet, hit, hitLen}], total, message}",
),
CommandSpec::new("measuregeom", "Measure Geometry", run_measuregeom)
.params("{mode: distance|radius|angle|area|volume, ...}")
.noundo()
.interactive(|_| Ok(Box::<MeasureM>::default())),
CommandSpec::new("radius.measure", "Radius", run_radius)
.menu(&["Tools", "Inquiry", "Radius"])
.params("{handle, point?}")
.noundo()
.interactive(|_| Ok(Box::new(RadiusM))),
CommandSpec::new("angle.measure", "Angle", run_angle)
.menu(&["Tools", "Inquiry", "Angle"])
.params("{vertex, p1, p2} | {h1, h2}")
.noundo()
.interactive(|_| Ok(Box::<AngleM>::default())),
CommandSpec::new("volume.measure", "Volume", super::inquiry::run_volume)
.menu(&["Tools", "Inquiry", "Volume"])
.params("{points: [[x,y],...] (3 or more) | handle (a closed 2D object), height} → {volume, area, height}")
.noundo()
.interactive(|_| Ok(Box::new(super::inquiry::AreaM::volume()))),
]
}
// ---------------- CAL ----------------
mod calc;
/// What QuickCalc's "get from the drawing" picks put on the command line before the value (the
/// palette reads it back from there).
const PICKED: &str = "QuickCalc: ";
/// Evaluate an arithmetic expression to a number (degrees for trig, `^` power, functions, pi).
/// Expressions with points are evaluated by [`calc::eval_val`].
pub fn eval(expr: &str, vars: &serde_json::Map<String, Value>) -> std::result::Result<f64, String> {
match calc::eval_val(expr, vars)? {
calc::Val::Num(v) => Ok(v),
calc::Val::Pt(_) => Err("the result is a point, not a number".into()),
}
}
fn run_cal(_s: &mut Session, p: &Value) -> Result<Value> {
if bool_or(p, "units", false) {
return Ok(json!({ "units": calc::units_json() }));
}
if let Some(c) = p.get("convert").filter(|v| !v.is_null()) {
let text = |k: &str| c.get(k).and_then(Value::as_str).ok_or_else(|| bad("cal", format!("`convert.{k}` is required")));
let vars = p.get("vars").and_then(Value::as_object).cloned().unwrap_or_default();
let v = match c.get("value") {
Some(Value::String(e)) => eval(e, &vars).map_err(|m| bad("cal", m))?,
Some(v) => v.as_f64().ok_or_else(|| bad("cal", "`convert.value` must be a number or an expression"))?,
None => return Err(bad("cal", "`convert.value` is required")),
};
let (from, to) = (text("from")?, text("to")?);
let r = calc::convert(c.get("type").and_then(Value::as_str), from, to, v).map_err(|m| bad("cal", m))?;
return Ok(json!({ "value": r, "message": format!("{} {from} = {} {to}", calc::num_text(v), calc::num_text(r)) }));
}
if let Some(m) = p.get("pick").filter(|v| !v.is_null()) {
let mode = m.as_str().and_then(calc::Pick::parse).ok_or_else(|| bad("cal", "`pick` must be point, distance, angle or intersection"))?;
let pts = points_param(p, "points").ok_or_else(|| bad("cal", "`points` must be a list of [x, y] points"))?;
let v = mode.value(&pts).map_err(|m| bad("cal", m))?;
let mut r = v.json();
r["message"] = json!(v.text());
return Ok(r);
}
let e = str_param(p, "expr").ok_or_else(|| bad("cal", "`expr` is required"))?;
let vars = p.get("vars").and_then(Value::as_object).cloned().unwrap_or_default();
let v = calc::eval_val(e, &vars).map_err(|m| bad("cal", m))?;
let mut r = v.json();
r["message"] = json!(v.text());
Ok(r)
}
/// CAL at the command line: one expression, its value echoed.
struct CalM;
impl Interactive for CalM {
fn name(&self) -> &'static str {
"CAL"
}
fn prompt(&self, _s: &Session) -> Prompt {
Prompt::new(">> Expression", Accept::TEXT)
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
let Input::Text(t) = i else { return Ok(Step::Done) };
if t.trim().is_empty() {
return Ok(Step::Done);
}
match calc::eval_val(&t, &serde_json::Map::new()) {
Ok(v) => s.echo(v.text()),
Err(m) => s.echo(format!("CAL: {m}")),
}
Ok(Step::Done)
}
}
/// QuickCalc's "get from the drawing": pick the points for a coordinate, distance, angle or
/// intersection; the value is echoed after [`PICKED`].
#[derive(Default)]
struct PickM {
mode: Option<calc::Pick>,
pts: Vec<Vec2>,
}
impl PickM {
fn finish(&self, s: &mut Session, mode: calc::Pick) -> Result<Step> {
match mode.value(&self.pts) {
Ok(v) => s.echo(format!("{PICKED}{}", v.text())),
Err(m) => s.echo(format!("QuickCalc: {m}")),
}
Ok(Step::Done)
}
}
impl Interactive for PickM {
fn name(&self) -> &'static str {
"QUICKCALC"
}
fn prompt(&self, _s: &Session) -> Prompt {
let msg = match (self.mode, self.pts.len()) {
(None, _) => {
return Prompt::new("Get from the drawing or [Point/Distance/Angle/Intersection]", Accept::POINT).kw(&[
"Point",
"Distance",
"Angle",
"Intersection",
]);
}
(Some(calc::Pick::Point), _) => "Specify point",
(Some(calc::Pick::Intersection), 0) => "Specify first point of first line",
(Some(calc::Pick::Intersection), 1) => "Specify second point of first line",
(Some(calc::Pick::Intersection), 2) => "Specify first point of second line",
(Some(calc::Pick::Intersection), _) => "Specify second point of second line",
(Some(_), 0) => "Specify first point",
(Some(_), _) => "Specify second point",
};
let base = if self.pts.len() % 2 == 1 { self.pts.last().copied() } else { None };
Prompt::new(msg, Accept::POINT).base_opt(base)
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match i {
Input::Keyword(k) if self.mode.is_none() => {
self.mode = calc::Pick::parse(&k);
Ok(Step::Continue)
}
Input::Point(p) => {
let mode = *self.mode.get_or_insert(calc::Pick::Point);
self.pts.push(p);
if self.pts.len() >= mode.points() { self.finish(s, mode) } else { Ok(Step::Continue) }
}
Input::Enter => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
fn preview(&self, _s: &Session, c: Vec2) -> Vec<EntityKind> {
match self.pts.last() {
Some(a) if self.pts.len() % 2 == 1 => vec![super::helpers::line(*a, c)],
_ => Vec::new(),
}
}
}
fn run_quickcalc_pick(s: &mut Session, p: &Value) -> Result<Value> {
let mode = str_param(p, "mode").unwrap_or("point");
run_cal(s, &json!({ "pick": mode, "points": p.get("points").cloned().unwrap_or(Value::Null) }))
}
// ---------------- FIND ----------------
/// Characters of context kept on each side of a hit in the Find dialog's result list.
const SNIPPET_CONTEXT: usize = 18;
/// The text around the first hit of `find` in `text`, for the result list: at most
/// [`SNIPPET_CONTEXT`] characters before the hit and as many after it, the hit's offset in the
/// snippet (in characters) and its length (in characters).
///
/// The offset and length are character counts, not bytes: the dialog slices the snippet by
/// character so a Chinese or Vietnamese drawing never splits a glyph. Lower-casing can change a
/// string's character count in rare scripts, so every slice goes through `get` and a snippet that
/// cannot be cut is reported as absent rather than guessed at.
fn snippet_at(text: &str, find: &str, case: bool, whole: bool) -> Option<(String, usize, usize)> {
if find.is_empty() {
return None;
}
let (hay, needle) = if case { (text.to_string(), find.to_string()) } else { (text.to_lowercase(), find.to_lowercase()) };
let mut at = 0;
let pos = loop {
let rest = hay.get(at..)?;
let p = rest.find(&needle)? + at;
let end = p + needle.len();
let boundary = |i: usize| hay.get(..i).and_then(|s| s.chars().last()).is_none_or(|c| !c.is_alphanumeric());
let after = hay.get(end..).and_then(|s| s.chars().next()).is_none_or(|c| !c.is_alphanumeric());
if !whole || (boundary(p) && after) {
break p;
}
at = end.max(p + 1);
if at >= hay.len() {
return None;
}
};
let start = hay.get(..pos)?.chars().count();
let hit_len = needle.chars().count();
let chars: Vec<char> = text.chars().collect();
let from = start.saturating_sub(SNIPPET_CONTEXT);
let to = start.saturating_add(hit_len).saturating_add(SNIPPET_CONTEXT).min(chars.len());
let snippet: String = chars.get(from..to)?.iter().collect();
Some((snippet, start.saturating_sub(from), hit_len))
}
fn replace_in(text: &str, find: &str, rep: &str, case: bool, whole: bool) -> (String, usize) {
if find.is_empty() {
return (text.to_string(), 0);
}
let hay = if case { text.to_string() } else { text.to_lowercase() };
let needle = if case { find.to_string() } else { find.to_lowercase() };
let mut out = String::new();
let mut n = 0;
let mut last = 0;
let mut start = 0;
while let Some(pos) = hay.get(start..).and_then(|h| h.find(&needle)).map(|p| p + start) {
let end = pos + needle.len();
let boundary = |i: usize| hay.get(..i).and_then(|s| s.chars().last()).is_none_or(|c| !c.is_alphanumeric());
let after = hay.get(end..).and_then(|s| s.chars().next()).is_none_or(|c| !c.is_alphanumeric());
if !whole || (boundary(pos) && after) {
out.push_str(text.get(last..pos).unwrap_or(""));
out.push_str(rep);
last = end;
n += 1;
}
start = end.max(pos + 1);
if start >= hay.len() {
break;
}
}
out.push_str(text.get(last..).unwrap_or(""));
(out, n)
}
fn run_find(s: &mut Session, p: &Value) -> Result<Value> {
let find = str_param(p, "find").ok_or_else(|| bad("find", "`find` is required"))?.to_string();
let rep = str_param(p, "replace").map(str::to_string);
let case = bool_or(p, "matchCase", false);
let whole = bool_or(p, "wholeWord", false);
// Only the named object types, when the dialog narrows the search; `type_name()` is the same
// name the result list shows, so a caller never has to guess the spelling.
let types: Option<Vec<String>> =
p.get("types").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_str).map(str::to_ascii_lowercase).collect());
let space = s.space();
let d = s.doc()?;
// The whole current space by default; the Find window narrows it to the objects its result
// list already holds, so Replace All touches exactly what the user can see.
let hs: Vec<Handle> = match p.get("handles").and_then(Value::as_array) {
Some(a) => a.iter().filter_map(|v| v.as_str().and_then(Handle::parse_hex)).collect(),
None => d.space(&space).map(|st| st.handles()).unwrap_or_default(),
};
let mut found: Vec<Value> = Vec::new();
let mut total = 0;
let mut edits: Vec<(Handle, EntityKind)> = Vec::new();
for h in hs {
let Some(e) = d.entity(h) else { continue };
if let Some(names) = &types
&& !names.iter().any(|n| n == &e.kind.type_name().to_ascii_lowercase())
{
continue;
}
let mut k = e.kind.clone();
let mut hits = 0;
// The first hit's surroundings, taken before a replacement rewrites the text.
let mut snippet: Option<(String, usize, usize)> = None;
let r = rep.as_deref().unwrap_or(&find);
let mut apply = |t: &mut String| {
let (nt, n) = replace_in(t, &find, r, case, whole);
if n > 0 {
hits += n;
if snippet.is_none() {
snippet = snippet_at(t, &find, case, whole);
}
if rep.is_some() {
*t = nt;
}
}
};
match &mut k {
EntityKind::Text(t) => apply(&mut t.value),
EntityKind::MText(t) => apply(&mut t.contents),
EntityKind::Insert(i) => i.attribs.iter_mut().for_each(|a| apply(&mut a.text.value)),
EntityKind::Dimension(dm) => apply(&mut dm.text),
EntityKind::MLeader(m) => {
if let Some(t) = &mut m.text {
apply(&mut t.contents)
}
}
EntityKind::Table(t) => t.cells.iter_mut().flatten().for_each(|c| apply(&mut c.text)),
_ => {}
}
if hits > 0 {
total += hits;
let (text, at, len) = snippet.unwrap_or_default();
found.push(json!({
"handle": h.hex(),
"type": e.kind.type_name(),
"count": hits,
"snippet": text,
"hit": at,
"hitLen": len,
}));
if rep.is_some() {
edits.push((h, k));
}
}
}
let n = edits.len();
if rep.is_some() {
let doc = s.doc_mut()?;
for (h, k) in edits {
doc.modify_entity(h, |e| {
e.kind = k;
if let EntityKind::Dimension(dm) = &mut e.kind {
dm.block = None;
}
})?;
}
} else {
let sel: Vec<Handle> = found.iter().filter_map(|v| v["handle"].as_str().and_then(Handle::parse_hex)).collect();
s.set_selection(sel);
}
let msg =
if rep.is_some() { format!("{total} replacement(s) in {n} object(s)") } else { format!("{total} match(es) in {} object(s)", found.len()) };
Ok(json!({ "matches": found, "total": total, "message": msg }))
}
// ---------------- MEASUREGEOM ----------------
// (MASSPROP is in `inquiry/regions.rs`.)
fn run_radius(s: &mut Session, p: &Value) -> Result<Value> {
let h = targets(s, p)?.first().copied().ok_or_else(|| bad("radius.measure", "`handle` is required"))?;
let r = match s.doc()?.entity(h).map(|e| e.kind.clone()) {
Some(EntityKind::Circle(c)) => c.radius,
Some(EntityKind::Arc(a)) => a.radius,
Some(EntityKind::LwPolyline(_)) => {
let at = point_param(p, "point").ok_or_else(|| bad("radius.measure", "`point` on the polyline's arc segment is required"))?;
match super::annotate::segment_at(s, h, at) {
Some(Segment::Arc { arc, .. }) => arc.radius,
_ => return Err(bad("radius.measure", "the polyline segment at `point` is not an arc")),
}
}
_ => return Err(bad("radius.measure", "select an arc, circle or polyline arc")),
};
Ok(json!({ "radius": r, "diameter": 2.0 * r, "message": format!("Radius = {r:.4}\nDiameter = {:.4}", 2.0 * r) }))
}
/// MEASUREGEOM's Radius option and Tools > Inquiry > Radius: the radius and diameter of a picked
/// arc, circle or polyline arc segment. Tools > Inquiry > Radius measures a selected arc or circle
/// at once.
struct RadiusM;
impl RadiusM {
/// Measure the arc, circle or polyline arc segment at the picked point; a pick on anything else keeps the prompt.
fn pick(s: &mut Session, i: Input) -> Result<Step> {
let Input::Point(p) = i else { return Ok(Step::Done) };
let Some(h) = super::curves::pick_at(s, p) else { return Ok(Step::Continue) };
match run_radius(s, &json!({ "handle": h.0, "point": [p.x, p.y] })) {
Ok(r) => {
echo_message(s, &r);
Ok(Step::Done)
}
Err(_) => {
s.echo("Select an arc, circle or polyline arc.");
Ok(Step::Continue)
}
}
}
}
impl Interactive for RadiusM {
fn name(&self) -> &'static str {
"MEASUREGEOM"
}
fn prompt(&self, _s: &Session) -> Prompt {
Prompt::new("Select arc or circle", Accept::POINT)
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
let Some(h) = s.selection().first().copied() else { return Ok(Step::Continue) };
match run_radius(s, &json!({ "handle": h.0 })) {
Ok(r) => {
echo_message(s, &r);
Ok(Step::Done)
}
Err(_) => Ok(Step::Continue),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
Self::pick(s, i)
}
}
/// Echo each line of a result's `message`.
fn echo_message(s: &mut Session, r: &Value) {
for l in r["message"].as_str().unwrap_or_default().lines() {
s.echo(l.to_string());
}
}
fn run_angle(s: &mut Session, p: &Value) -> Result<Value> {
let (v, a, b) = if let (Some(v), Some(a), Some(b)) = (point_param(p, "vertex"), point_param(p, "p1"), point_param(p, "p2")) {
(v, a, b)
} else {
let hp = |k: &str| p.get(k).and_then(Value::as_str).and_then(Handle::parse_hex);
let (Some(h1), Some(h2)) = (hp("h1"), hp("h2")) else { return Err(bad("angle.measure", "give {vertex,p1,p2} or {h1,h2}")) };
let d = s.doc()?;
let line = |h: Handle| match d.entity(h).map(|e| e.kind.clone()) {
Some(EntityKind::Line(l)) => Some((l.a.xy(), l.b.xy())),
_ => None,
};
let (l1, l2) =
(line(h1).ok_or_else(|| bad("angle.measure", "h1 is not a line"))?, line(h2).ok_or_else(|| bad("angle.measure", "h2 is not a line"))?);
lines_vertex(l1, l2).ok_or_else(|| bad("angle.measure", "lines are parallel"))?
};
let ang = vertex_angle(v, a, b);
Ok(json!({ "angle": ang, "message": angle_text(ang) }))
}
/// The point where two lines (extended) meet and the end of each line farther from it; `None` when they are parallel.
fn lines_vertex((a1, a2): (Vec2, Vec2), (b1, b2): (Vec2, Vec2)) -> Option<(Vec2, Vec2, Vec2)> {
let (x, _, _) = cadcraft_geom::line_line_infinite(a1, a2, b1, b2)?;
let far = |p: Vec2, q: Vec2| if p.dist(x) > q.dist(x) { p } else { q };
Some((x, far(a1, a2), far(b1, b2)))
}
/// The angle at `v` between the directions to `a` and `b`, in degrees from 0 to 180.
fn vertex_angle(v: Vec2, a: Vec2, b: Vec2) -> f64 {
let ang = (cadcraft_geom::norm_angle(v.angle_to(b) - v.angle_to(a))).to_degrees();
if ang > 180.0 { 360.0 - ang } else { ang }
}
fn angle_text(ang: f64) -> String {
format!("Angle = {ang:.4}°")
}
fn run_measuregeom(s: &mut Session, p: &Value) -> Result<Value> {
match str_param(p, "mode").unwrap_or("distance").to_ascii_lowercase().as_str() {
"distance" | "d" => s.execute("dist", p),
"radius" | "r" => run_radius(s, p),
"angle" | "a" => run_angle(s, p),
"area" | "ar" => s.execute("area", p),
"volume" | "v" => super::inquiry::run_volume(s, p),
_ => Err(bad("measuregeom", "mode must be distance, radius, angle, area or volume")),
}
}
/// MEASUREGEOM typed or picked: choose what to measure, then continue as DIST, AREA, a radius pick or an angle pick.
#[derive(Default)]
struct MeasureM {
inner: Option<Box<dyn Interactive>>,
/// Waiting for the arc or circle of the Radius option.
radius: bool,
}
impl Interactive for MeasureM {
fn name(&self) -> &'static str {
"MEASUREGEOM"
}
fn prompt(&self, s: &Session) -> Prompt {
match &self.inner {
Some(m) => m.prompt(s),
None if self.radius => Prompt::new("Select arc or circle", Accept::POINT),
None => Prompt::new("Enter an option", Accept { point: false, number: false, text: false, select: false, enter: true })
.kw(&["Distance", "Radius", "Angle", "ARea", "Volume"])
.default("Distance"),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Some(m) = &mut self.inner {
return m.input(s, i);
}
if self.radius {
return RadiusM::pick(s, i);
}
match i {
Input::Enter => self.inner = Some(Box::new(super::inquiry::DistM::default())),
Input::Keyword(k) => match k.as_str() {
"Radius" => self.radius = true,
"Angle" => self.inner = Some(Box::<AngleM>::default()),
"ARea" => self.inner = Some(Box::new(super::inquiry::AreaM::default())),
"Volume" => self.inner = Some(Box::new(super::inquiry::AreaM::volume())),
_ => self.inner = Some(Box::new(super::inquiry::DistM::default())),
},
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, s: &Session, cursor: Vec2) -> Vec<EntityKind> {
self.inner.as_ref().map(|m| m.preview(s, cursor)).unwrap_or_default()
}
}
/// MEASUREGEOM's Angle option and Tools > Inquiry > Angle: the angle of an arc, of two points on a
/// circle about its center, between two lines or polyline line segments, or (Enter) at a vertex
/// between two endpoints.
#[derive(Default)]
struct AngleM {
/// The first line picked.
first: Option<(Vec2, Vec2)>,
/// The vertex and endpoints given so far (Enter, or a circle's center and the point picked on it).
vertex: Option<Vec<Vec2>>,
}
impl AngleM {
fn finish(s: &mut Session, ang: f64) -> Result<Step> {
s.echo(angle_text(ang));
Ok(Step::Done)
}
}
impl Interactive for AngleM {
fn name(&self) -> &'static str {
"MEASUREGEOM"
}
fn prompt(&self, _s: &Session) -> Prompt {
if let Some(pts) = &self.vertex {
let msg = ["Specify angle vertex", "Specify first angle endpoint", "Specify second angle endpoint"].get(pts.len()).copied().unwrap_or("");
return Prompt::new(msg, Accept::POINT).base_opt(pts.first().copied());
}
match self.first {
None => Prompt::new("Select arc, circle, line", Accept::POINT).default("specify vertex"),
Some(_) => Prompt::new("Select second line", Accept::POINT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Some(pts) = &mut self.vertex {
return match i {
Input::Point(p) => {
pts.push(p);
match pts.as_slice() {
[v, a, b] => Self::finish(s, vertex_angle(*v, *a, *b)),
_ => Ok(Step::Continue),
}
}
Input::Enter => Ok(Step::Cancel),
_ => Ok(Step::Continue),
};
}
let p = match i {
Input::Enter if self.first.is_none() => {
self.vertex = Some(Vec::new());
return Ok(Step::Continue);
}
Input::Point(p) => p,
Input::Enter => return Ok(Step::Cancel),
_ => return Ok(Step::Continue),
};
let Some(h) = super::curves::pick_at(s, p) else {
s.echo("*Invalid selection*");
return Ok(Step::Continue);
};
let circle = s
.doc()?
.entity(h)
.and_then(|e| if let EntityKind::Circle(c) = &e.kind { Some(cadcraft_geom::Circle::new(c.center.xy(), c.radius)) } else { None });
if let Some(c) = circle.filter(|_| self.first.is_none()) {
self.vertex = Some(vec![c.center, c.closest(p)]);
return Ok(Step::Continue);
}
match super::annotate::segment_at(s, h, p) {
Some(Segment::Arc { arc, .. }) if self.first.is_none() => Self::finish(s, arc.sweep().to_degrees()),
Some(Segment::Line(l)) => match self.first {
None => {
self.first = Some((l.a, l.b));
Ok(Step::Continue)
}
Some(first) => match lines_vertex(first, (l.a, l.b)) {
Some((v, a, b)) => Self::finish(s, vertex_angle(v, a, b)),
None => {
s.echo("The lines are parallel.");
Ok(Step::Done)
}
},
},
_ => {
s.echo(if self.first.is_none() { "Select an arc, circle or line." } else { "Select a line." });
Ok(Step::Continue)
}
}
}
fn preview(&self, _s: &Session, c: Vec2) -> Vec<EntityKind> {
match self.vertex.as_deref() {
Some([v]) => vec![super::helpers::line(*v, c)],
Some([v, a]) => vec![super::helpers::line(*v, *a), super::helpers::line(*v, c)],
_ => Vec::new(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn calculator() {
let v = serde_json::Map::new();
assert_eq!(eval("(3+4)*2^2", &v), Ok(28.0));
assert!((eval("sin(30)", &v).unwrap() - 0.5).abs() < 1e-12);
assert!((eval("2*pi", &v).unwrap() - std::f64::consts::TAU).abs() < 1e-12);
assert_eq!(eval("-2^2", &v), Ok(-4.0));
assert!(eval("1/0", &v).is_err());
assert!(eval("((((1", &v).is_err());
assert!(eval("foo(1)", &v).is_err());
assert!(eval(&"(".repeat(5000), &v).is_err());
let mut vars = serde_json::Map::new();
vars.insert("x".into(), json!(3));
assert_eq!(eval("x*x", &vars), Ok(9.0));
}
#[test]
fn find_and_replace() {
assert_eq!(replace_in("Bolt bolt BOLTS", "bolt", "Pin", false, true), ("Pin Pin BOLTS".to_string(), 2));
assert_eq!(replace_in("aaa", "a", "b", true, false), ("bbb".to_string(), 3));
assert_eq!(replace_in("x", "", "y", true, false).1, 0);
}
/// `snippet_at` returns the whole text when the hit fills it, with the hit at offset 0.
#[test]
fn snippet_reports_the_hit_offset() {
assert_eq!(snippet_at("BOLT-01", "BOLT-01", true, false), Some(("BOLT-01".to_string(), 0, 7)));
}
/// Matching ignores case but the snippet keeps the text as it is written, so the result list
/// shows the drawing's own spelling.
#[test]
fn snippet_keeps_the_original_case() {
assert_eq!(snippet_at("法兰 bolt-01 安装孔", "BOLT-01", false, false), Some(("法兰 bolt-01 安装孔".to_string(), 3, 7)));
}
/// A long text keeps [`SNIPPET_CONTEXT`] characters on each side of the hit, counted in
/// characters so a CJK hit is never split.
#[test]
fn snippet_is_windowed_in_characters() {
let text = format!("{}命中{}", "前".repeat(30), "后".repeat(30));
let (snippet, hit, len) = snippet_at(&text, "命中", true, false).expect("a hit");
assert_eq!((hit, len), (SNIPPET_CONTEXT, 2));
assert_eq!(snippet.chars().count(), SNIPPET_CONTEXT * 2 + 2);
}
/// A whole-word search skips an embedded hit, and text without a hit has no snippet.
#[test]
fn snippet_respects_whole_word() {
assert_eq!(snippet_at("BOLTS", "BOLT", true, true), None);
assert_eq!(snippet_at("a BOLT b", "BOLT", true, true).map(|s| s.1), Some(2));
assert_eq!(snippet_at("nothing", "BOLT", true, false), None);
}
}
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.