Persistent names read by one parser; four misreadings fixed (#5814) (#5966)

* doc: persistent names read as their structure; joint.inspect splits an edge with a blend face first

`persistent_name::{FaceName, EdgeName}` parse a face or edge name once (blends, inner walls,
copies, pieces, numbered pieces, `~k`) and write it back as the same text, bounded against
hostile input. A suffix after a blend's edge naming a later feature belongs to the blend face.

joint.inspect split an edge at its first `|`, so an edge whose first face is a blend
(`F4:blend:F3:+x|F3:+z#[…]|F5:-y`) came back as a cut-off blend name and a string that is no
face. It now uses `EdgeName::parse`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* doc: persistent names as typed values: features, roles, suffixes, a lexer and errors that say where

`FaceName` is a base (made by a feature in a role, a blend and the edge it rounds, an inner
wall, a body's face by index, other text) and its suffixes (copy, piece, numbered piece).
Roles are typed where the vocabulary is known (top, side:<curve>, +x, face:<k>, …) and kept as
written otherwise. The text form is lexed into tokens and read by the grammar in the module's
doc; a name that doesn't read says where and what was expected.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* names: read what made a face, its kind and its feature ids through persistent_name

The places that took a name apart by hand to find the feature that made a face, whether it is
a blend, a copy, a numbered piece or a wall, or to remap feature ids on copy, now ask the typed
name (`made_by`, `split_feature`, `is_blend`, `is_copy`, `is_numbered_piece`, `is_wall`,
`features`, `map`). A name that doesn't read falls back to the old text check.

- An offset of a face that only names a blend inside it (`F2:top#[F5:blend:…]`) is no longer
  taken for a fillet's.
- Copying a component remaps feature ids inside a piece's `#[…]` too.
- A shell's inner wall split by a later cut keeps the qualifier on the wall.
- joint.inspect finds the sketch curve of a copied side (`side:l1@F7.2`).

Finding a face by name (strip_piece, parent_piece) is unchanged: it reads a trailing
qualifier as the whole name's and moves once the text form says where it belongs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* engine: regression tests for press-pull on a wall that only names a fillet and joint.inspect on a copied side

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* names: an edge holds one face or more; made_by reads only the leading token

An open boundary's edge has one face and an edge several faces meet at has more, so an edge name
is a list of faces (a blend's own edge still takes two at most, as before). `made_by` reads just
the leading `F<n>:`, which every name a feature made starts with, so asking it of every face
each frame stays cheap. Names are read up to 1 MiB: a face engraved with text has piece names
past 4 KiB.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* persistent_name: split into lexer, parser, write, text and tests

No code changed; callers' paths stay the same (`pub use text::*`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
JIJINBEIandClaude Opus 5.5 authored and GitHub committed 2026-10-25 01:48:26 +00:00
1 parent 3f6b9fe89f
commit cdde7d62b2
23 files changed
+1179 -61

No files matched your search

+1 -1
View File
@@ -220,7 +220,7 @@ impl Document {
let (p, look) = (crate::apply_point(&b.source_transform, f.point), f.look.clone());
if f.strict_name {
let Some(name) = f.name.as_ref() else { continue };
let Some(origin_feature) = name.strip_prefix('F').and_then(|name| name.split_once(':')).and_then(|(id, _)| id.parse().ok()) else {
let Some(origin_feature) = crate::persistent_name::made_by(name) else {
continue;
};
let target = crate::config::ConfigFaceTarget {
+9
View File
@@ -3,6 +3,7 @@
use std::collections::BTreeMap;
use crate::persistent_name::{Base, FaceName, FeatureId};
use crate::{FeatureKind, PlaneRef};
/// Remap persistent topology tokens without rewriting arbitrary user expressions or labels.
@@ -22,6 +23,14 @@ pub fn remap_topology(name: &str, ids: &BTreeMap<u64, u64>, bodies: &BTreeMap<St
{
return format!("{new}:face:{suffix}");
}
// A name that reads is remapped by its structure: every feature it names, and a body
// face's body. Text of no known form is remapped token by token below.
if let Ok(face) = FaceName::parse(name)
&& !matches!(face.base, Base::Other(_))
&& let Some(mapped) = face.map(&mut |id, _| Some(ids.get(&id.0).map_or(id, |n| FeatureId(*n))), &mut |b| bodies.get(b).cloned())
{
return mapped.to_string();
}
let mut out = String::new();
let mut at = 0;
while at < name.len() {
+10 -11
View File
@@ -580,18 +580,14 @@ impl Document {
| Some(solidcraft_kernel::FaceSource::ShellPlanar { producer: Some(producer), .. })
| Some(solidcraft_kernel::FaceSource::Box { producer: Some(producer), .. })
| Some(solidcraft_kernel::FaceSource::CylinderCap { producer, .. }) => *producer,
_ => name
.strip_prefix('F')
.and_then(|name| name.split_once(':'))
.and_then(|(id, _)| id.parse().ok())
.ok_or_else(|| DocError::Invalid("face source producer missing".into()))?,
_ => crate::persistent_name::made_by(&name).ok_or_else(|| DocError::Invalid("face source producer missing".into()))?,
};
let certificate = self.configuration_face_certificate(body, index)?;
if let Some(FaceCertificate::ExtrudeSide { curve, .. }) = &certificate {
name = format!("F{origin}:side:{curve}");
} else if let Some(FaceCertificate::ShellPlanar { source, inner, .. }) = &certificate {
name = format!("F{origin}:{}", shell_certificate_role(source, *inner)?);
} else if !name.starts_with(&format!("F{origin}:")) {
} else if crate::persistent_name::made_by(&name) != Some(origin) {
name = format!("F{origin}:face:{index}");
}
let inverse = crate::mat_inverse(&body.source_transform).ok_or_else(|| DocError::Invalid("invalid definition placement".into()))?;
@@ -725,7 +721,7 @@ impl Document {
}
let full = names.faces.get(index)?;
let stem = crate::naming::strip_piece(full);
let origin = stem.strip_prefix('F')?.split_once(':')?.0.parse::<u64>().ok()?;
let origin = crate::persistent_name::made_by(stem)?;
let inverse = crate::mat_inverse(&body.source_transform)?;
let mut candidates = vec![stem];
if full != stem {
@@ -819,10 +815,13 @@ impl Document {
return Ok(indices);
}
let names = crate::naming::names(body);
let own = format!("F{origin}:");
let stem = |index: usize| names.faces.get(index).map(|name| crate::naming::strip_piece(name));
let seed: Vec<usize> =
indices.into_iter().filter(|index| stem(*index).is_some_and(|name| name.starts_with(&own) && !name.contains('@'))).collect();
let seed: Vec<usize> = indices
.into_iter()
.filter(|index| {
stem(*index).is_some_and(|name| crate::persistent_name::made_by(name) == Some(origin) && !crate::persistent_name::is_copy(name))
})
.collect();
let feature = self.feature(origin).map_or_else(|| format!("F{origin}"), |feature| feature.name.clone());
let ambiguous = || DocError::Invalid(format!("the attached flat face of {feature} on `{}` is missing or ambiguous", body.name));
let first = seed.first().and_then(|index| stem(*index)).ok_or_else(ambiguous)?;
@@ -841,7 +840,7 @@ impl Document {
return indices;
}
let names = crate::naming::names(body);
let copy = |index: &usize| names.faces.get(*index).is_some_and(|name| crate::naming::strip_piece(name).contains('@'));
let copy = |index: &usize| names.faces.get(*index).is_some_and(|name| crate::persistent_name::is_copy(name));
if indices.iter().all(copy) {
return indices;
}
+1 -5
View File
@@ -69,11 +69,7 @@ impl ConfigTable {
maps.bodies.get(&target.body).zip(maps.features.get(&target.origin_feature)).map(|(body, origin)| {
let mut target = target.clone();
target.body = body.clone();
target.name = target
.name
.strip_prefix(&format!("F{}:", target.origin_feature))
.map(|role| format!("F{origin}:{role}"))
.unwrap_or_else(|| target.name.clone());
target.name = crate::persistent_name::map_features(&target.name, &maps.features).unwrap_or_else(|| target.name.clone());
target.origin_feature = *origin;
if let Some(certificate) = &mut target.certificate {
certificate.remap_features(&maps.features);
+6 -5
View File
@@ -122,12 +122,13 @@ impl Document {
/// Certify named generator lineage; generic index-derived naming is unsupported.
pub fn certify_config_face(&self, target: &ConfigFaceTarget) -> Result<()> {
target.validate()?;
let prefix = format!("F{}:", target.origin_feature);
let role = target.name.strip_prefix(&prefix).ok_or_else(|| DocError::Invalid("face lineage does not match its feature".into()))?;
let role = crate::persistent_name::split_feature(&target.name)
.filter(|(id, _)| *id == target.origin_feature)
.map(|(_, role)| role)
.ok_or_else(|| DocError::Invalid("face lineage does not match its feature".into()))?;
// An exact history name may name a piece by the faces around it (`F2:top#[F2:side:l4,…]`),
// never by a number (an older design's piece, or a tie the faces around it left).
let numbered =
target.name.match_indices('#').any(|(i, _)| target.name.get(i + 1..).is_some_and(|rest| rest.starts_with(|c: char| c.is_ascii_digit())));
let numbered = crate::persistent_name::is_numbered_piece(&target.name);
let lineage_piece = matches!(target.certificate, Some(super::FaceCertificate::Lineage)) && !numbered;
if crate::naming::strip_piece(&target.name) != target.name && !lineage_piece {
return Err(DocError::Invalid("configure a face lineage, not a numbered split piece".into()));
@@ -316,7 +317,7 @@ impl Document {
}
return Ok(indices);
}
if target.name.ends_with(":side") {
if crate::persistent_name::is_wall(&target.name) {
if indices.len() != 1 {
return Err(DocError::Invalid("split curved face lineage is not yet certified".into()));
}
+3 -3
View File
@@ -3344,9 +3344,9 @@ impl Document {
_ => true,
})
.collect();
self.appearances
.faces
.retain(|face| !face.strict_name || !face.name.as_ref().is_some_and(|name| gone.iter().any(|id| name.starts_with(&format!("F{id}:")))));
self.appearances.faces.retain(|face| {
!face.strict_name || !face.name.as_ref().and_then(|name| crate::persistent_name::made_by(name)).is_some_and(|made| gone.contains(&made))
});
if keep.contains(&false) {
let mut k = keep.iter();
self.configs.columns.retain(|_| k.next().copied().unwrap_or(true));
+1
View File
@@ -43,6 +43,7 @@ mod name_lookup;
mod names;
pub mod naming;
mod params;
pub mod persistent_name;
pub mod physical_material;
mod piece_names;
pub mod pipe_thread_catalog;
+310
View File
@@ -0,0 +1,310 @@
//! Persistent face and edge names as values, and their text form.
//!
//! A face name says what made the face: a feature and its role there (`F2:top`, `F2:side:l4`), a
//! fillet or chamfer and the edge it rounds (`F5:blend:<edge>`), a shell and the face it offsets
//! (`F3:inner:<face>`), or, without history, a body and an index (`Body1:face:3`). Suffixes
//! follow: a pattern copy (`@F7.2`), a piece of a split face told apart by the faces around it
//! (`#[<face>,…]`, `#k` after it for a tie), an older design's numbered piece (`#k`). An edge is
//! the two faces it separates, `~k` for one of several between them.
//!
//! The text form, read by [`FaceName::parse`] and [`EdgeName::parse`] and written by `Display`:
//!
//! ```text
//! edge = face { "|" face } [TIE] one face for an open boundary, more where several meet
//! face = base { suffix }
//! base = FEATURE ":" "blend" ":" ( edge | NUMBER )
//! | FEATURE ":" "inner" ":" face
//! | FEATURE ":" role
//! | text (`<body>:face:<k>`, or any other text)
//! suffix = COPY | "#[" face { "," face } "]" [HASH] | HASH
//! FEATURE = "F" NUMBER COPY = "@F" NUMBER "." NUMBER
//! HASH = "#" NUMBER TIE = "~" NUMBER
//! ```
//!
//! Suffixes after a nested name are ambiguous in the text: in `F5:blend:A|B#[…]` the qualifier
//! may split `B` (the fillet rounds an edge of a piece made before it) or the fillet face itself
//! (a later cut split it), and so for a shell's inner wall `F3:inner:X#[…]`. A suffix naming a
//! feature later than the outer face's belongs to the outer face; any other stays inside, so a
//! later cut told apart only by older faces reads as a piece of the inner name. A `~k` ending an
//! edge numbers that edge, not a blend's edge inside it.
//!
//! Finding a face by name still goes through `naming::strip_piece` and `parent_piece`, which
//! read a trailing qualifier as the whole name's; they move here once the text form says where a
//! qualifier belongs.
//!
//! Reading is bounded in length and depth and never panics; whatever it reads writes back as the
//! same text.
/// The longest name read.
/// The longest name read. Names of pieces list their neighbours and grow with every split: a face
/// engraved with text passes 4 KiB.
pub const MAX_NAME_LEN: usize = 1 << 20;
/// The deepest nesting read (blends of blends, pieces of pieces).
const MAX_DEPTH: usize = 32;
/// A feature of the timeline, as names refer to it (`F12`).
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct FeatureId(pub u64);
/// A persistent face name.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FaceName {
pub base: Base,
/// Innermost first.
pub suffixes: Vec<Suffix>,
}
/// What made a face.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Base {
/// `F<feature>:<role>`.
Made { feature: FeatureId, role: Role },
/// `F<feature>:blend:…`: a fillet or chamfer face.
Blend { feature: FeatureId, rounds: Rounds },
/// `F<feature>:inner:<face>`: a shell's inner wall.
Inner { feature: FeatureId, offsets: Box<FaceName> },
/// `<body>:face:<k>`: a face of a body without history, by index.
BodyFace { body: String, index: u32 },
/// Text of no form above.
Other(String),
}
/// What a blend face rounds.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Rounds {
/// The edge, by name.
Edge(Box<EdgeName>),
/// The edge's index among the feature's edges (no name was known).
Index(u32),
}
/// A face's role in the feature that made it.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Role {
Top,
Bottom,
Start,
End,
Base,
Section,
/// `side`: a cylinder's wall, or a tool's faces swept from its whole profile.
Wall,
/// `side:<curve>`, `side:s<k>.<curve>` for profile `k`: swept from a sketch curve.
Side {
profile: Option<u32>,
curve: String,
},
/// `+x`, `-z`, …: a box's face.
BoxFace {
axis: Axis,
high: bool,
},
/// `face:<k>`: the feature's face `k`, named from geometry.
Index(u32),
/// A role of another form (a cap's, a tool part's, a sheet's), as written.
Other(String),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Axis {
X,
Y,
Z,
}
/// What follows a face's base.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Suffix {
/// `@F<feature>.<instance>`: a pattern or mirror copy.
Copy { feature: FeatureId, instance: u32 },
/// `#[…]`, `#k` after it: a piece of a split face.
Piece(Qualifier),
/// `#k`: a numbered piece of a design saved before format 14.
Numbered(u32),
}
/// The faces only one piece of a split face touches, and its number among pieces they don't
/// tell apart.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Qualifier {
around: Vec<FaceName>,
pub tie: Option<u32>,
}
/// A persistent edge name.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct EdgeName {
/// The faces it separates, in order: two, one for an open boundary, more where several
/// faces meet.
pub faces: Vec<FaceName>,
pub tie: Option<u32>,
}
/// Why a name could not be read.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NameError {
TooLong,
TooDeep,
/// At byte `at`, something else was expected.
Expected {
at: usize,
what: &'static str,
},
}
impl FaceName {
/// The feature that made the face: its base's, a copy's when it is one.
pub fn feature(&self) -> Option<FeatureId> {
let copied = self.suffixes.iter().rev().find_map(|s| match s {
Suffix::Copy { feature, .. } => Some(*feature),
_ => None,
});
copied.or(match &self.base {
Base::Made { feature, .. } | Base::Blend { feature, .. } | Base::Inner { feature, .. } => Some(*feature),
Base::BodyFace { .. } | Base::Other(_) => None,
})
}
/// The face this one is a piece of: the trailing piece suffixes off.
pub fn stem(&self) -> FaceName {
let keep = self.suffixes.iter().rposition(|s| matches!(s, Suffix::Copy { .. })).map_or(0, |i| i + 1);
FaceName { base: self.base.clone(), suffixes: self.suffixes.get(..keep).unwrap_or_default().to_vec() }
}
}
impl Qualifier {
/// A qualifier listing `around`, at least one face.
pub fn new(around: Vec<FaceName>, tie: Option<u32>) -> Option<Qualifier> {
(!around.is_empty()).then_some(Qualifier { around, tie })
}
pub fn around(&self) -> &[FaceName] {
&self.around
}
}
/// Where a feature id sits in a name.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Place {
/// It names what made a face: a base, a nested face's base, a copy.
Name,
/// It names a face around a piece (`#[…]`).
Qualifier,
}
impl FaceName {
/// The feature whose `F<n>:` starts the name.
pub fn made_by(&self) -> Option<FeatureId> {
match &self.base {
Base::Made { feature, .. } | Base::Blend { feature, .. } | Base::Inner { feature, .. } => Some(*feature),
Base::BodyFace { .. } | Base::Other(_) => None,
}
}
/// Every feature id in the name, in the order the text gives them.
pub fn features(&self) -> Vec<FeatureId> {
let mut out = Vec::new();
self.push_features(&mut out);
out
}
fn push_features(&self, out: &mut Vec<FeatureId>) {
match &self.base {
Base::Made { feature, .. } | Base::Blend { feature, rounds: Rounds::Index(_) } => out.push(*feature),
Base::Blend { feature, rounds: Rounds::Edge(e) } => {
out.push(*feature);
e.faces.iter().for_each(|f| f.push_features(out));
}
Base::Inner { feature, offsets } => {
out.push(*feature);
offsets.push_features(out);
}
Base::BodyFace { .. } | Base::Other(_) => {}
}
for s in &self.suffixes {
match s {
Suffix::Copy { feature, .. } => out.push(*feature),
Suffix::Piece(q) => q.around.iter().for_each(|f| f.push_features(out)),
Suffix::Numbered(_) => {}
}
}
}
/// A fillet's or chamfer's face (a piece or copy of one too).
pub fn is_blend(&self) -> bool {
matches!(self.base, Base::Blend { .. })
}
/// A pattern's or mirror's copy of a face (a piece of one too).
pub fn is_copy(&self) -> bool {
self.suffixes.iter().any(|s| matches!(s, Suffix::Copy { .. }))
}
/// A piece told apart by a number: an older design's numbered piece, or a tie.
pub fn is_numbered_piece(&self) -> bool {
self.suffixes.iter().any(|s| matches!(s, Suffix::Numbered(_) | Suffix::Piece(Qualifier { tie: Some(_), .. })))
}
/// The name with each feature id mapped by `f` (given where it sits) and each body face's
/// body by `body`; `None` when `f` refuses one. A role's text is left as written.
pub fn map(&self, f: &mut impl FnMut(FeatureId, Place) -> Option<FeatureId>, body: &mut impl FnMut(&str) -> Option<String>) -> Option<FaceName> {
self.map_in(Place::Name, f, body)
}
fn map_in(
&self,
place: Place,
f: &mut impl FnMut(FeatureId, Place) -> Option<FeatureId>,
body: &mut impl FnMut(&str) -> Option<String>,
) -> Option<FaceName> {
let base = match &self.base {
Base::Made { feature, role } => Base::Made { feature: f(*feature, place)?, role: role.clone() },
Base::Blend { feature, rounds } => {
let rounds = match rounds {
Rounds::Edge(e) => Rounds::Edge(Box::new(e.map_in(place, f, body)?)),
Rounds::Index(k) => Rounds::Index(*k),
};
Base::Blend { feature: f(*feature, place)?, rounds }
}
Base::Inner { feature, offsets } => {
let offsets = Box::new(offsets.map_in(place, f, body)?);
Base::Inner { feature: f(*feature, place)?, offsets }
}
Base::BodyFace { body: b, index } => Base::BodyFace { body: body(b).unwrap_or_else(|| b.clone()), index: *index },
Base::Other(t) => Base::Other(t.clone()),
};
let mut suffixes = Vec::with_capacity(self.suffixes.len());
for s in &self.suffixes {
suffixes.push(match s {
Suffix::Copy { feature, instance } => Suffix::Copy { feature: f(*feature, place)?, instance: *instance },
Suffix::Piece(q) => {
let around = q.around.iter().map(|a| a.map_in(Place::Qualifier, f, body)).collect::<Option<Vec<_>>>()?;
Suffix::Piece(Qualifier { around, tie: q.tie })
}
Suffix::Numbered(k) => Suffix::Numbered(*k),
});
}
Some(FaceName { base, suffixes })
}
}
impl EdgeName {
fn map_in(
&self,
place: Place,
f: &mut impl FnMut(FeatureId, Place) -> Option<FeatureId>,
body: &mut impl FnMut(&str) -> Option<String>,
) -> Option<EdgeName> {
let faces = self.faces.iter().map(|x| x.map_in(place, f, body)).collect::<Option<Vec<_>>>()?;
Some(EdgeName { faces, tie: self.tie })
}
}
mod lexer;
mod parser;
#[cfg(test)]
mod tests;
mod text;
mod write;
pub use text::*;
+93
View File
@@ -0,0 +1,93 @@
//! The lexer: a name's text as tokens.
/// A plain decimal number: digits only, no leading zero (so it writes back the same).
pub(super) fn number<T: std::str::FromStr>(d: &str) -> Option<T> {
let ok = !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()) && (d.len() == 1 || !d.starts_with('0'));
if ok { d.parse().ok() } else { None }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Kind {
/// `F<n>` before a `:`.
Feature(u64),
/// Text between separators.
Word,
Colon,
Pipe,
Comma,
/// `#[`
Open,
/// `]`
Close,
/// `#<n>`
Hash(u32),
/// `~<n>`
Tie(u32),
/// `@F<n>.<k>`
Copy(u64, u32),
}
#[derive(Clone, Copy, Debug)]
pub(super) struct Tok {
pub(super) kind: Kind,
pub(super) start: usize,
pub(super) end: usize,
}
/// The digits of `s` from byte `i` as a number, and where they end.
fn digits_at<T: std::str::FromStr>(s: &str, i: usize) -> Option<(T, usize)> {
let rest = s.get(i..)?;
let n = rest.bytes().take_while(u8::is_ascii_digit).count();
Some((number(rest.get(..n)?)?, i + n))
}
/// The separator token starting at byte `i`, if one does.
fn separator_at(s: &str, i: usize) -> Option<Tok> {
let b = s.as_bytes();
let tok = |kind, end| Some(Tok { kind, start: i, end });
match b.get(i)? {
b':' => tok(Kind::Colon, i + 1),
b'|' => tok(Kind::Pipe, i + 1),
b',' => tok(Kind::Comma, i + 1),
b']' => tok(Kind::Close, i + 1),
b'#' if b.get(i + 1) == Some(&b'[') => tok(Kind::Open, i + 2),
b'#' => digits_at(s, i + 1).and_then(|(k, end)| tok(Kind::Hash(k), end)),
b'~' => digits_at(s, i + 1).and_then(|(k, end)| tok(Kind::Tie(k), end)),
b'@' if b.get(i + 1) == Some(&b'F') => {
let (feature, dot) = digits_at(s, i + 2)?;
if b.get(dot) != Some(&b'.') {
return None;
}
let (instance, end) = digits_at(s, dot + 1)?;
tok(Kind::Copy(feature, instance), end)
}
_ => None,
}
}
pub(super) fn lex(s: &str) -> Vec<Tok> {
let mut toks = Vec::new();
let mut i = 0;
while i < s.len() {
if let Some(t) = separator_at(s, i) {
toks.push(t);
i = t.end;
continue;
}
// `F<n>` right before a `:` names a feature.
if s.as_bytes().get(i) == Some(&b'F')
&& let Some((n, end)) = digits_at::<u64>(s, i + 1)
&& s.as_bytes().get(end) == Some(&b':')
{
toks.push(Tok { kind: Kind::Feature(n), start: i, end });
i = end;
continue;
}
let start = i;
while i < s.len() && separator_at(s, i).is_none() {
i += s.get(i..).and_then(|r| r.chars().next()).map_or(1, char::len_utf8);
}
toks.push(Tok { kind: Kind::Word, start, end: i });
}
toks
}
+245
View File
@@ -0,0 +1,245 @@
//! The parser: the grammar in the module's doc, by recursive descent.
use super::lexer::*;
use super::*;
impl FaceName {
pub fn parse(s: &str) -> Result<FaceName, NameError> {
let mut p = Parser::new(s)?;
let f = p.face(0)?;
p.end()?;
Ok(f)
}
}
impl EdgeName {
pub fn parse(s: &str) -> Result<EdgeName, NameError> {
let mut p = Parser::new(s)?;
// A `~k` ending the text numbers this edge.
let tie = match p.toks.last() {
Some(Tok { kind: Kind::Tie(k), .. }) => {
let k = *k;
p.toks.pop();
Some(k)
}
_ => None,
};
let e = p.edge(0, usize::MAX)?;
p.end()?;
Ok(EdgeName { tie, ..e })
}
}
impl Role {
fn from_text(t: &str) -> Role {
match t {
"top" => return Role::Top,
"bottom" => return Role::Bottom,
"start" => return Role::Start,
"end" => return Role::End,
"base" => return Role::Base,
"section" => return Role::Section,
"side" => return Role::Wall,
_ => {}
}
if let Some(rest) = t.strip_prefix("side:").filter(|r| !r.is_empty()) {
let profiled =
rest.strip_prefix('s').and_then(|r| r.split_once('.')).and_then(|(k, c)| Some((number(k)?, c))).filter(|(_, c)| !c.is_empty());
return match profiled {
Some((k, c)) => Role::Side { profile: Some(k), curve: c.to_string() },
None => Role::Side { profile: None, curve: rest.to_string() },
};
}
if let Some(k) = t.strip_prefix("face:").and_then(number) {
return Role::Index(k);
}
let mut c = t.chars();
let box_face = match (c.next(), c.next(), c.next()) {
(Some(sign @ ('+' | '-')), Some(a), None) => match a {
'x' => Some(Axis::X),
'y' => Some(Axis::Y),
'z' => Some(Axis::Z),
_ => None,
}
.map(|axis| Role::BoxFace { axis, high: sign == '+' }),
_ => None,
};
box_face.unwrap_or_else(|| Role::Other(t.to_string()))
}
}
/// The trailing suffixes of `inner`, the last name nested in a face of `feature`, that name a
/// later feature, taken off it: they are the outer face's (a later cut split it, a later pattern
/// copied it).
fn later_suffixes(feature: FeatureId, inner: &mut FaceName) -> Vec<Suffix> {
let later = |s: &Suffix| match s {
Suffix::Copy { feature: f, .. } => *f > feature,
Suffix::Piece(q) => q.around.iter().filter_map(FaceName::feature).max().is_some_and(|f| f > feature),
Suffix::Numbered(_) => false,
};
let keep = inner.suffixes.iter().rposition(|s| !later(s)).map_or(0, |i| i + 1);
inner.suffixes.split_off(keep)
}
struct Parser<'a> {
s: &'a str,
toks: Vec<Tok>,
at: usize,
}
impl<'a> Parser<'a> {
fn new(s: &'a str) -> Result<Parser<'a>, NameError> {
if s.len() > MAX_NAME_LEN {
return Err(NameError::TooLong);
}
Ok(Parser { s, toks: lex(s), at: 0 })
}
fn peek(&self, ahead: usize) -> Option<Tok> {
self.toks.get(self.at + ahead).copied()
}
fn byte(&self) -> usize {
self.peek(0).map_or(self.s.len(), |t| t.start)
}
fn expected<T>(&self, what: &'static str) -> Result<T, NameError> {
Err(NameError::Expected { at: self.byte(), what })
}
fn end(&self) -> Result<(), NameError> {
if self.peek(0).is_some() { self.expected("the end of the name") } else { Ok(()) }
}
fn word(&self, ahead: usize) -> Option<&'a str> {
self.peek(ahead).filter(|t| t.kind == Kind::Word).and_then(|t| self.s.get(t.start..t.end))
}
/// `<word>:` at the cursor.
fn keyword(&self, w: &str) -> bool {
self.word(0) == Some(w) && self.peek(1).is_some_and(|t| t.kind == Kind::Colon)
}
/// An edge: its faces joined by `|`, at most `max` of them.
fn edge(&mut self, depth: usize, max: usize) -> Result<EdgeName, NameError> {
let mut faces = vec![self.face(depth + 1)?];
while faces.len() < max && self.peek(0).map(|t| t.kind) == Some(Kind::Pipe) {
self.at += 1;
faces.push(self.face(depth + 1)?);
}
let tie = match self.peek(0).map(|t| t.kind) {
Some(Kind::Tie(k)) => {
self.at += 1;
Some(k)
}
_ => None,
};
Ok(EdgeName { faces, tie })
}
fn face(&mut self, depth: usize) -> Result<FaceName, NameError> {
if depth > MAX_DEPTH {
return Err(NameError::TooDeep);
}
let mut face = match (self.peek(0).map(|t| t.kind), self.peek(1).map(|t| t.kind)) {
(Some(Kind::Feature(n)), Some(Kind::Colon)) => {
self.at += 2;
let feature = FeatureId(n);
if self.keyword("blend") {
self.at += 2;
self.blend(feature, depth)?
} else if self.keyword("inner") {
self.at += 2;
let mut offsets = self.face(depth + 1)?;
let moved = later_suffixes(feature, &mut offsets);
FaceName { base: Base::Inner { feature, offsets: Box::new(offsets) }, suffixes: moved }
} else {
let role = Role::from_text(self.text()?);
FaceName { base: Base::Made { feature, role }, suffixes: Vec::new() }
}
}
_ => {
let t = self.text()?;
let body_face = t.rsplit_once(":face:").and_then(|(b, k)| Some((b, number(k)?))).filter(|(b, _)| !b.is_empty());
let base = match body_face {
Some((body, index)) => Base::BodyFace { body: body.to_string(), index },
None => Base::Other(t.to_string()),
};
FaceName { base, suffixes: Vec::new() }
}
};
self.suffixes(&mut face, depth)?;
Ok(face)
}
/// A blend face of `feature`, the cursor after `blend:`.
fn blend(&mut self, feature: FeatureId, depth: usize) -> Result<FaceName, NameError> {
let ends_face = |k: Option<Kind>| !matches!(k, Some(Kind::Word | Kind::Colon | Kind::Feature(_)));
if let Some(k) = self.word(0).and_then(number::<u32>)
&& ends_face(self.peek(1).map(|t| t.kind))
{
self.at += 1;
return Ok(FaceName { base: Base::Blend { feature, rounds: Rounds::Index(k) }, suffixes: Vec::new() });
}
// A blend names the edge it rounds by its faces, two at most: the rest is the outer edge's.
let mut edge = self.edge(depth + 1, 2)?;
let moved = edge.faces.last_mut().map(|b| later_suffixes(feature, b)).unwrap_or_default();
Ok(FaceName { base: Base::Blend { feature, rounds: Rounds::Edge(Box::new(edge)) }, suffixes: moved })
}
/// Words and colons up to the next other token, as written.
fn text(&mut self) -> Result<&'a str, NameError> {
let start = self.byte();
let mut end = start;
while let Some(t) = self.peek(0).filter(|t| matches!(t.kind, Kind::Word | Kind::Colon | Kind::Feature(_))) {
end = t.end;
self.at += 1;
}
match self.s.get(start..end).filter(|t| !t.is_empty()) {
Some(t) => Ok(t),
None => self.expected("a face"),
}
}
fn suffixes(&mut self, face: &mut FaceName, depth: usize) -> Result<(), NameError> {
while let Some(t) = self.peek(0) {
match t.kind {
Kind::Copy(feature, instance) => {
self.at += 1;
face.suffixes.push(Suffix::Copy { feature: FeatureId(feature), instance });
}
Kind::Open => {
self.at += 1;
let mut around = vec![self.face(depth + 1)?];
loop {
match self.peek(0).map(|t| t.kind) {
Some(Kind::Comma) => {
self.at += 1;
around.push(self.face(depth + 1)?);
}
Some(Kind::Close) => {
self.at += 1;
break;
}
_ => return self.expected("`,` or `]` in a piece's faces"),
}
}
let tie = match self.peek(0).map(|t| t.kind) {
Some(Kind::Hash(k)) => {
self.at += 1;
Some(k)
}
_ => None,
};
face.suffixes.push(Suffix::Piece(Qualifier { around, tie }));
}
Kind::Hash(k) => {
self.at += 1;
face.suffixes.push(Suffix::Numbered(k));
}
_ => return Ok(()),
}
}
Ok(())
}
}
+238
View File
@@ -0,0 +1,238 @@
use super::*;
fn face(s: &str) -> FaceName {
let f = FaceName::parse(s).unwrap_or_else(|e| panic!("{s}: {e}"));
assert_eq!(f.to_string(), s, "writes back");
f
}
fn edge(s: &str) -> EdgeName {
let e = EdgeName::parse(s).unwrap_or_else(|e| panic!("{s}: {e}"));
assert_eq!(e.to_string(), s, "writes back");
e
}
fn made(feature: u64, role: Role) -> FaceName {
FaceName { base: Base::Made { feature: FeatureId(feature), role }, suffixes: Vec::new() }
}
fn other(role: &str) -> Role {
Role::Other(role.into())
}
#[test]
fn roles_are_typed_and_the_rest_kept_as_written() {
assert_eq!(face("F2:top"), made(2, Role::Top));
assert_eq!(face("F4:side#1").stem(), made(4, Role::Wall));
assert_eq!(face("F2:side:l4"), made(2, Role::Side { profile: None, curve: "l4".into() }));
assert_eq!(face("F2:side:s1.l4"), made(2, Role::Side { profile: Some(1), curve: "l4".into() }));
assert_eq!(face("F3:+x"), made(3, Role::BoxFace { axis: Axis::X, high: true }));
assert_eq!(face("F3:-z"), made(3, Role::BoxFace { axis: Axis::Z, high: false }));
assert_eq!(face("F2:face:7"), made(2, Role::Index(7)));
assert_eq!(face("F9:cap:high:0"), made(9, other("cap:high:0")));
assert_eq!(face("F12:boss:side:3"), made(12, other("boss:side:3")));
assert_eq!(face("Body1:face:3").base, Base::BodyFace { body: "Body1".into(), index: 3 });
assert_eq!(face("Plate:rim.end").base, Base::Other("Plate:rim.end".into()));
// Numbers that would not write back the same stay text.
assert_eq!(face("F2:side:s01.l4"), made(2, Role::Side { profile: None, curve: "s01.l4".into() }));
}
#[test]
fn pieces_copies_and_numbered_pieces() {
let p = face("F2:top#[F2:side:l2,F4:side:l2]");
let Some(Suffix::Piece(q)) = p.suffixes.first() else { panic!("{p:?}") };
assert_eq!(q.around().len(), 2);
assert_eq!(p.stem(), made(2, Role::Top));
assert!(matches!(face("F2:top#[F4:side:l2]#1").suffixes.as_slice(), [Suffix::Piece(Qualifier { tie: Some(1), .. })]));
assert_eq!(face("F2:top#2").suffixes, vec![Suffix::Numbered(2)]);
let c = face("F2:side:l1@F7.2");
assert_eq!(c.suffixes, vec![Suffix::Copy { feature: FeatureId(7), instance: 2 }]);
assert_eq!(c.feature(), Some(FeatureId(7)));
assert_eq!(face("F2:side:l1@F7.2#[F8:x]").stem(), c);
assert!(Qualifier::new(Vec::new(), None).is_none());
}
/// The fillet rounds an edge of a piece the slot made before it: the qualifier is the
/// piece's (corpus `naming-split-pieces`).
#[test]
fn a_blend_of_an_earlier_piece_keeps_the_qualifier_inside() {
let f = face("F5:blend:F2:side:l2|F2:top#[F2:side:l2,F4:side:l2]");
let Base::Blend { feature: FeatureId(5), rounds: Rounds::Edge(e) } = &f.base else { panic!("{f:?}") };
assert!(f.suffixes.is_empty());
assert_eq!(e.faces[1].stem(), made(2, Role::Top));
assert_eq!(e.faces[1].suffixes.len(), 1);
}
/// A slot cut after the fillet splits the fillet face: the qualifier, naming the later slot,
/// is the fillet face's.
#[test]
fn a_blend_split_by_a_later_cut_takes_the_qualifier() {
let f = face("F4:blend:F3:+x|F3:+z#[F3:-y,F5:-y]");
let Base::Blend { feature: FeatureId(4), rounds: Rounds::Edge(e) } = &f.base else { panic!("{f:?}") };
assert_eq!(e.faces[1], made(3, Role::BoxFace { axis: Axis::Z, high: true }));
assert!(matches!(f.suffixes.as_slice(), [Suffix::Piece(_)]));
// Copied by a later pattern, then split: both are the blend face's, in order.
let g = face("F4:blend:F3:+x|F3:+z@F6.1#[F7:a]");
assert!(matches!(g.suffixes.as_slice(), [Suffix::Copy { feature: FeatureId(6), .. }, Suffix::Piece(_)]));
assert_eq!(g.feature(), Some(FeatureId(6)));
}
/// What the text cannot tell: a later cut told apart only by older faces reads as a piece of
/// the inner face.
#[test]
fn a_later_cut_told_apart_by_older_faces_reads_as_the_inner_faces() {
let f = face("F4:blend:F3:+x|F3:+z#[F3:-y]");
let Base::Blend { rounds: Rounds::Edge(e), .. } = &f.base else { panic!("{f:?}") };
assert!(f.suffixes.is_empty() && e.faces[1].suffixes.len() == 1);
}
#[test]
fn edges_split_into_their_two_faces() {
let e = edge("F2:side:l1|F2:side:l2");
assert_eq!(e.faces[0], made(2, Role::Side { profile: None, curve: "l1".into() }));
assert_eq!(edge("F2:side:l1|F2:top~1").tie, Some(1));
// The blend face first: the whole blend name, then the slot's wall.
let e = edge("F4:blend:F3:+x|F3:+z#[F3:-y,F5:-y]|F5:-y");
assert_eq!(e.faces[0].to_string(), "F4:blend:F3:+x|F3:+z#[F3:-y,F5:-y]");
assert_eq!(e.faces[1], made(5, Role::BoxFace { axis: Axis::Y, high: false }));
// The blend face second.
let e = edge("F2:side:l1|F5:blend:F2:side:l2|F2:top#[F2:side:l2,F4:side:l2]");
assert!(matches!(e.faces[1].base, Base::Blend { feature: FeatureId(5), .. }));
// A blend of a blend's edge.
let e = edge("F6:blend:F4:blend:a|b|c|d");
let Base::Blend { rounds: Rounds::Edge(inner), .. } = &e.faces[0].base else { panic!("{e:?}") };
assert!(matches!(inner.faces[0].base, Base::Blend { feature: FeatureId(4), .. }));
assert_eq!(e.faces[1].base, Base::Other("d".into()));
// A `~k` ending the edge numbers it, not the blend's edge.
let e = edge("F2:x|F5:blend:a|b~1");
assert_eq!(e.tie, Some(1));
assert!(matches!(&e.faces[1].base, Base::Blend { rounds: Rounds::Edge(b), .. } if b.tie.is_none()));
// A blend named by its edge's index.
assert_eq!(edge("F5:blend:3|F2:top").faces[0].base, Base::Blend { feature: FeatureId(5), rounds: Rounds::Index(3) });
}
#[test]
fn inner_walls_nest_a_face() {
let f = face("F3:inner:F2:top#[F2:side:l2]");
let Base::Inner { feature: FeatureId(3), offsets } = &f.base else { panic!("{f:?}") };
assert_eq!(offsets.stem(), made(2, Role::Top));
}
#[test]
fn what_made_a_face_and_its_kind() {
assert_eq!(made_by("F2:side:l1@F7.2"), Some(2));
assert_eq!(made_by("F3:inner:F5:blend:a|b"), Some(3));
assert_eq!(made_by("Body1:face:3"), None);
assert_eq!(split_feature("F12:boss:side:3"), Some((12, "boss:side:3")));
// A blend named only inside another name is not one.
assert!(is_blend("F5:blend:F2:x|F2:y#[F6:z]"));
assert!(!is_blend("F2:top#[F5:blend:a|b]"));
assert!(!is_blend("F3:inner:F5:blend:a|b"));
// A copy only inside a blend's edge doesn't make the blend face a copy.
assert!(is_copy("F2:side:l1@F7.2#[F8:x]"));
assert!(!is_copy("F5:blend:F2:x@F3.1|F2:y"));
assert!(is_numbered_piece("F2:top#2") && is_numbered_piece("F2:top#[F4:x]#1"));
assert!(!is_numbered_piece("F5:blend:F2:top#2|F2:x") && !is_numbered_piece("F2:top#[F4:x]"));
assert!(is_wall("F4:side") && !is_wall("F4:side#1") && !is_wall("F5:blend:F2:x|F4:side"));
}
/// A shell's inner wall split by a later cut: the qualifier, naming the cut, is the wall's.
#[test]
fn an_inner_wall_split_by_a_later_cut_takes_the_qualifier() {
let f = face("F3:inner:F2:top#[F2:side:l2,F6:x]");
assert!(matches!(f.suffixes.as_slice(), [Suffix::Piece(_)]));
assert_eq!(f.stem().to_string(), "F3:inner:F2:top");
}
#[test]
fn features_in_text_order() {
let ids = |s: &str| face(s).features().into_iter().map(|f| f.0).collect::<Vec<_>>();
assert_eq!(ids("F3:inner:F2:blend:F1:+y|F1:-x"), vec![3, 2, 1, 1]);
assert_eq!(ids("F82:-z@F84.2"), vec![82, 84]);
assert_eq!(ids("F2:top#[F2:side:l2,F4:side:l2]"), vec![2, 2, 4]);
assert_eq!(ids("F1:side:曲線F10"), vec![1]);
assert!(ids("Body1:face:3").is_empty());
}
#[test]
fn feature_ids_map_everywhere_but_role_text() {
let ids = std::collections::BTreeMap::from([(2, 12), (5, 15)]);
let mapped = map_features("F5:blend:F2:side:l2|F2:top#[F2:side:l2,F4:side:l2]@F2.1", &ids);
assert_eq!(mapped.as_deref(), Some("F15:blend:F12:side:l2|F12:top#[F12:side:l2,F4:side:l2]@F12.1"));
// Where an id sits: a name's ids must map, a qualifier's may stay.
let f = face("F2:top#[F9:x]");
let strict = f.map(
&mut |id, place| match place {
Place::Name => ids.get(&id.0).map(|n| FeatureId(*n)),
Place::Qualifier => Some(ids.get(&id.0).map_or(id, |n| FeatureId(*n))),
},
&mut |_| None,
);
assert_eq!(strict.map(|f| f.to_string()).as_deref(), Some("F12:top#[F9:x]"));
assert!(face("F9:top").map(&mut |id, _| ids.get(&id.0).map(|n| FeatureId(*n)), &mut |_| None).is_none());
let body = face("Body1:face:3").map(&mut |id, _| Some(id), &mut |b| (b == "Body1").then(|| "Body2".to_string()));
assert_eq!(body.map(|f| f.to_string()).as_deref(), Some("Body2:face:3"));
}
#[test]
fn errors_say_where() {
assert_eq!(EdgeName::parse("F2:top|"), Err(NameError::Expected { at: 7, what: "a face" }));
assert_eq!(FaceName::parse("F2:top#[F3:x"), Err(NameError::Expected { at: 12, what: "`,` or `]` in a piece's faces" }));
assert_eq!(FaceName::parse("a|b"), Err(NameError::Expected { at: 1, what: "the end of the name" }));
assert_eq!(FaceName::parse(""), Err(NameError::Expected { at: 0, what: "a face" }));
}
#[test]
fn hostile_names_never_panic() {
let long = "x".repeat(MAX_NAME_LEN + 1);
let deep = format!("{}x", "F1:inner:".repeat(64));
let deep_pieces = format!("x{}{}", "#[x".repeat(64), "]".repeat(64));
for s in [
"",
"|",
"||",
"#[",
"#[]",
"x#[",
"x#[]",
"x#[y",
"x#[y,",
"]",
"x]",
"F1:blend:",
"F1:blend:x",
"F1:blend:x|",
"@F",
"x@F1.",
"x@F",
"x~",
"x|y~",
"x|y~01",
"F01:top",
"x#0x",
"F99999999999999999999999:top",
"x#99999999999",
"\u{1F600}|\u{1F601}",
long.as_str(),
deep.as_str(),
deep_pieces.as_str(),
] {
if let Ok(f) = FaceName::parse(s) {
assert_eq!(f.to_string(), s);
}
if let Ok(e) = EdgeName::parse(s) {
assert_eq!(e.to_string(), s);
}
}
assert_eq!(FaceName::parse(&long), Err(NameError::TooLong));
assert_eq!(FaceName::parse(&deep), Err(NameError::TooDeep));
assert_eq!(FaceName::parse(&deep_pieces), Err(NameError::TooDeep));
// An open boundary's edge has one face; an edge three faces meet at, three.
assert_eq!(edge("F2:top").faces.len(), 1);
assert_eq!(edge("x|y|z").faces.len(), 3);
// A blend's edge has two faces at most; a third is the outer edge's.
let e = edge("F5:blend:a|b|c");
assert!(matches!(&e.faces[0].base, Base::Blend { rounds: Rounds::Edge(inner), .. } if inner.faces.len() == 2) && e.faces.len() == 2);
// A fillet on an open boundary's edge.
assert!(matches!(face("F1:blend:F10:start").base, Base::Blend { rounds: Rounds::Edge(ref e), .. } if e.faces.len() == 1));
}
+53
View File
@@ -0,0 +1,53 @@
//! Questions callers ask of a name kept as a `String`.
use super::lexer::number;
use super::*;
/// The feature whose `F<n>:` starts the face name `name` (a copy's is its source's). Every name a
/// feature made starts so (`F2:top`, `F5:blend:…`, `F3:inner:…`), so only that token is read:
/// cheap enough to ask of every face each frame.
pub fn made_by(name: &str) -> Option<u64> {
let rest = name.strip_prefix('F')?;
let end = rest.find(|c: char| !c.is_ascii_digit())?;
if rest.get(end..end + 1) != Some(":") {
return None;
}
number(rest.get(..end)?)
}
/// `name` without the `F<n>:` of the feature that made it, and `n`.
pub fn split_feature(name: &str) -> Option<(u64, &str)> {
let id = made_by(name)?;
Some((id, name.strip_prefix(&format!("F{id}:"))?))
}
/// Whether `name` is a pattern's or mirror's copy of a face.
pub fn is_copy(name: &str) -> bool {
FaceName::parse(name).map_or_else(|_| name.contains('@'), |f| f.is_copy())
}
/// Whether `name` is a fillet's or chamfer's face.
pub fn is_blend(name: &str) -> bool {
FaceName::parse(name).map_or_else(|_| name.contains(":blend:"), |f| f.is_blend())
}
/// Whether `name` is a piece told apart by a number (an older design's piece, or a tie).
pub fn is_numbered_piece(name: &str) -> bool {
FaceName::parse(name).map_or_else(
|_| name.match_indices('#').any(|(i, _)| name.get(i + 1..).is_some_and(|rest| rest.starts_with(|c: char| c.is_ascii_digit()))),
|f| f.is_numbered_piece(),
)
}
/// Whether `name` is a whole `side` face: a cylinder's wall, or a tool's faces swept from its
/// whole profile.
pub fn is_wall(name: &str) -> bool {
FaceName::parse(name).map_or_else(|_| name.ends_with(":side"), |f| f.suffixes.is_empty() && matches!(f.base, Base::Made { role: Role::Wall, .. }))
}
/// `name` with every feature id `ids` maps replaced, the rest kept; `None` when it doesn't read.
pub fn map_features(name: &str, ids: &std::collections::BTreeMap<u64, u64>) -> Option<String> {
let f = FaceName::parse(name).ok()?;
let mapped = f.map(&mut |id, _| Some(ids.get(&id.0).map_or(id, |n| FeatureId(*n))), &mut |_| None)?;
Some(mapped.to_string())
}
+91
View File
@@ -0,0 +1,91 @@
//! Writing names back as text: `Display`.
use std::fmt;
use super::*;
impl fmt::Display for Role {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Role::Top => f.write_str("top"),
Role::Bottom => f.write_str("bottom"),
Role::Start => f.write_str("start"),
Role::End => f.write_str("end"),
Role::Base => f.write_str("base"),
Role::Section => f.write_str("section"),
Role::Wall => f.write_str("side"),
Role::Side { profile: Some(k), curve } => write!(f, "side:s{k}.{curve}"),
Role::Side { profile: None, curve } => write!(f, "side:{curve}"),
Role::BoxFace { axis, high } => {
let a = match axis {
Axis::X => 'x',
Axis::Y => 'y',
Axis::Z => 'z',
};
write!(f, "{}{a}", if *high { '+' } else { '-' })
}
Role::Index(k) => write!(f, "face:{k}"),
Role::Other(t) => f.write_str(t),
}
}
}
impl fmt::Display for FaceName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.base {
Base::Made { feature, role } => write!(f, "F{}:{role}", feature.0)?,
Base::Blend { feature, rounds: Rounds::Edge(e) } => write!(f, "F{}:blend:{e}", feature.0)?,
Base::Blend { feature, rounds: Rounds::Index(k) } => write!(f, "F{}:blend:{k}", feature.0)?,
Base::Inner { feature, offsets } => write!(f, "F{}:inner:{offsets}", feature.0)?,
Base::BodyFace { body, index } => write!(f, "{body}:face:{index}")?,
Base::Other(t) => f.write_str(t)?,
}
for s in &self.suffixes {
match s {
Suffix::Copy { feature, instance } => write!(f, "@F{}.{instance}", feature.0)?,
Suffix::Piece(q) => {
f.write_str("#[")?;
for (i, a) in q.around.iter().enumerate() {
if i > 0 {
f.write_str(",")?;
}
write!(f, "{a}")?;
}
f.write_str("]")?;
if let Some(k) = q.tie {
write!(f, "#{k}")?;
}
}
Suffix::Numbered(k) => write!(f, "#{k}")?,
}
}
Ok(())
}
}
impl fmt::Display for EdgeName {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for (i, face) in self.faces.iter().enumerate() {
if i > 0 {
f.write_str("|")?;
}
write!(f, "{face}")?;
}
match self.tie {
Some(k) => write!(f, "~{k}"),
None => Ok(()),
}
}
}
impl fmt::Display for NameError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
NameError::TooLong => write!(f, "a name is at most {MAX_NAME_LEN} bytes"),
NameError::TooDeep => write!(f, "a name nests at most {MAX_DEPTH} deep"),
NameError::Expected { at, what } => write!(f, "expected {what} at byte {at}"),
}
}
}
impl std::error::Error for NameError {}
@@ -5,6 +5,7 @@ use std::collections::{BTreeMap, BTreeSet};
use solidcraft_doc::Document;
use solidcraft_doc::joints::cam::CamProfile;
use solidcraft_doc::joints::{Assembly, Coupling, JointOrigin, Size};
use solidcraft_doc::persistent_name::{Base, FaceName, FeatureId, Place};
use crate::{EngineError, Result};
@@ -182,6 +183,27 @@ fn validate_map<K: Ord, V: Ord>(map: &BTreeMap<K, V>) -> Result<()> {
/// alter F10). Body-based legacy names are remapped only through an explicit identity map.
fn face_name(name: &str, features: &BTreeMap<u64, u64>, bodies: &BTreeMap<String, String>) -> Option<String> {
let body = name.match_indices(':').filter_map(|(end, _)| bodies.get_key_value(name.get(..end)?)).next_back();
// A name that reads, on no copied body's prefix (whose name may look like a feature token),
// is remapped by its structure: every feature that made a face must map; one around a piece
// (`#[…]`) maps when it was copied too.
if body.is_none()
&& let Ok(face) = FaceName::parse(name)
&& !matches!(face.base, Base::Other(_))
{
let mut body_mapped = false;
let out = face.map(
&mut |id, place| match place {
Place::Name => features.get(&id.0).map(|n| FeatureId(*n)),
Place::Qualifier => Some(features.get(&id.0).map_or(id, |n| FeatureId(*n))),
},
&mut |b| {
let n = bodies.get(b).cloned();
body_mapped |= n.is_some();
n
},
)?;
return (body_mapped || face.made_by().is_some()).then(|| out.to_string());
}
let mut out = String::new();
let mut last = 0usize;
let mut mapped = false;
@@ -153,6 +153,9 @@ fn naming_remaps_exact_tokens_unicode_and_legacy_body_identity() {
assert!(face_name("F1:start@F99.1", &features, &bodies).is_none());
assert!(face_name("Foreign:face:0", &features, &bodies).is_none());
assert!(face_name("Foreign:face:0@F1.1", &features, &bodies).is_none());
// A piece's faces around it are copied too; one from a feature not copied stays.
assert_eq!(face_name("F1:top#[F1:side:l2,F10:side:l2]", &features, &bodies).as_deref(), Some("F21:top#[F21:side:l2,F30:side:l2]"));
assert_eq!(face_name("F1:top#[F99:x]", &features, &bodies).as_deref(), Some("F21:top#[F99:x]"));
let bodies = BTreeMap::from([("F1:Housing".into(), "F1:Housing (copy)".into())]);
assert_eq!(face_name("F1:Housing:face:0@F10.1", &features, &bodies).as_deref(), Some("F1:Housing (copy):face:0@F30.1"));
}
+5 -1
View File
@@ -180,7 +180,11 @@ fn show(s: &mut Session, _p: &Value) -> Result<Value> {
format!("Component: {}", s.doc.components.iter().find(|c| c.id == *id).map(|c| c.name.clone()).unwrap_or_else(|| id.to_string()))
}
Column::FaceAppearance(target) => {
format!("Face: {} / {}", target.body, target.name.split_once(':').map(|(_, role)| role).unwrap_or(&target.name))
format!(
"Face: {} / {}",
target.body,
solidcraft_doc::persistent_name::split_feature(&target.name).map(|(_, role)| role).unwrap_or(&target.name)
)
}
_ => s.doc.config_key(column),
};
+2 -2
View File
@@ -1203,8 +1203,8 @@ fn press_pull(s: &mut Session, p: &Value) -> Result<Value> {
&& super::face::face_is_planar(s, fp) == Some(false)
{
let name = solidcraft_doc::naming::face_names_at(&s.model.state(), &[fp]).into_iter().next().unwrap_or_default();
let fid = name.strip_prefix('F').and_then(|r| r.split(':').next()).and_then(|x| x.parse::<u64>().ok());
if name.contains(":blend") {
let fid = solidcraft_doc::persistent_name::made_by(&name);
if solidcraft_doc::persistent_name::is_blend(&name) {
let f = fid.and_then(|id| s.doc.feature(id)).cloned().ok_or_else(|| bad(cmd, "the blend's feature is gone"))?;
let (key, old) = match &f.kind {
FeatureKind::Fillet { radius, .. } => ("radius", radius.clone()),
+12 -28
View File
@@ -5,7 +5,8 @@
use serde_json::{Value, json};
use solidcraft_doc::joints::{self, Joint, JointOrigin, Snap, XRef};
use solidcraft_doc::naming::{legacy_name, strip_piece};
use solidcraft_doc::naming::legacy_name;
use solidcraft_doc::persistent_name::{Base, EdgeName, FaceName, Role};
use solidcraft_doc::{Document, MAX_PLACEMENT_DEPTH, ModelState};
use super::{component_of, joint_id, link_json, named_values, occurrence_name};
@@ -171,26 +172,20 @@ fn face_ref(doc: &Document, name: &str) -> Value {
}
None => name,
};
let stem = strip_piece(bare);
let Some((fid, role)) = stem.strip_prefix('F').and_then(|r| r.split_once(':')).and_then(|(id, role)| Some((id.parse::<u64>().ok()?, role)))
else {
return v;
};
v["role_in_feature"] = json!(role);
let Ok(face) = FaceName::parse(bare) else { return v };
let Some(fid) = face.made_by().map(|id| id.0) else { return v };
let stem = face.stem().to_string();
v["role_in_feature"] = json!(stem.strip_prefix(&format!("F{fid}:")).unwrap_or(&stem));
let Some(f) = doc.feature(fid) else {
v["feature"] = json!({"id": fid, "error": format!("feature {fid} is gone")});
return v;
};
v["feature"] = json!({"id": f.id, "name": f.name, "type": f.kind.type_name()});
if let Some(curve) = role.strip_prefix("side:") {
// A later profile's side is `s<k>.<curve>`.
let curve = curve
.split_once('.')
.filter(|(k, _)| k.strip_prefix('s').is_some_and(|n| !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())))
.map_or(curve, |(_, c)| c);
// A side swept from a sketch curve (a later profile's too, `side:s<k>.<curve>`).
if let Base::Made { role: Role::Side { curve, .. }, .. } = &face.base {
let found = f.kind.input_sketches().into_iter().find_map(|id| {
let sk = doc.sketch(id).ok()?;
let c = sk.curves.iter().find(|c| c.id == curve)?;
let c = sk.curves.iter().find(|c| c.id == *curve)?;
let curve_type = serde_json::to_value(&c.kind).ok().and_then(|k| k.get("type").cloned()).unwrap_or(Value::Null);
let name = doc.feature(id).map(|f| f.name.clone()).unwrap_or_default();
Some(json!({"id": id, "name": name, "curve": curve, "curve_type": curve_type}))
@@ -204,20 +199,9 @@ fn face_ref(doc: &Document, name: &str) -> Value {
/// what each of its faces refers to.
fn edge_ref(doc: &Document, name: &str) -> Value {
let bare = legacy_name(name).unwrap_or(name);
let bare = bare.rsplit_once('~').filter(|(_, k)| !k.is_empty() && k.bytes().all(|b| b.is_ascii_digit())).map_or(bare, |(e, _)| e);
// Split at the `|` outside a piece's `#[…]`.
let mut depth = 0i32;
let split = bare.char_indices().find(|(_, c)| {
match c {
'[' => depth += 1,
']' => depth -= 1,
_ => {}
}
*c == '|' && depth == 0
});
let faces: Vec<Value> = match split {
Some((i, _)) => [bare.get(..i), bare.get(i + 1..)].into_iter().flatten().map(|f| face_ref(doc, f)).collect(),
None => Vec::new(),
let faces: Vec<Value> = match EdgeName::parse(bare) {
Ok(e) => e.faces.iter().map(|f| face_ref(doc, &f.to_string())).collect(),
Err(_) => Vec::new(),
};
let mut v = json!({"name": name, "faces": faces});
if legacy_name(name).is_some() {
+59
View File
@@ -1937,6 +1937,65 @@ fn joint_inspect_reports_a_lost_origin() {
assert_eq!(hinge["a"]["resolves"], true);
}
/// An edge whose first face is a fillet's: the fillet face's name holds the edge it rounds
/// (`F2:blend:<face>|<face>`), so the edge's two faces are the whole blend name and the slot's
/// wall, not the blend name cut at its own `|`.
#[test]
fn joint_inspect_splits_an_edge_of_a_blend_face_into_its_two_faces() {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Base"}));
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "corner": [0, 0, 0]}));
run(&mut s, "solid.fillet", json!({"edges": [[40, 20, 10]], "radius": 3}));
run(&mut s, "solid.box", json!({"length": 10, "width": 4, "height": 20, "corner": [32, 18, -5], "operation": "cut"}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Cap"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "corner": [200, 0, 0]}));
// On the slot's wall y = 18, halfway round the fillet (axis x = 37, z = 7, r = 3).
let h = 3.0 * std::f64::consts::FRAC_1_SQRT_2;
run(
&mut s,
"joint.create",
json!({"type": "rigid", "name": "OnBlend", "a": {"occurrence": "Base", "edge": [37.0 + h, 18, 7.0 + h]},
"b": {"occurrence": "Cap", "face": [205, 5, 5]}}),
);
let j = run(&mut s, "joint.inspect", json!({"joint": "OnBlend"}))["joints"][0].clone();
let edge = reference(&j, "a", "edge");
let name = edge["name"].as_str().unwrap_or_default().to_string();
let faces: Vec<String> = edge["faces"].as_array().into_iter().flatten().filter_map(|f| f["name"].as_str().map(str::to_string)).collect();
// `F4:blend:F3:+x|F3:+z#[F3:-y,F5:-y]|F5:-y`: the blend piece beside the slot, and the slot's wall.
assert!(name.split_once(':').is_some_and(|(_, r)| r.starts_with("blend:")), "the blend face comes first: {name}");
assert_eq!(faces.len(), 2, "{edge}");
assert_eq!(format!("{}|{}", faces[0], faces[1]), name, "{edge}");
assert!(faces[0].contains(":blend:") && faces[0].contains('|'), "{edge}");
assert!(!faces[1].contains('|'), "{edge}");
}
/// A joint on a pattern's copy of a pin: the copy's wall (`F3:side:c1@F4.1`) still names the
/// sketch curve it was swept from, `c1`.
#[test]
fn joint_inspect_finds_the_sketch_curve_of_a_copied_side() {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Pins"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "PinSketch"}));
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 5, "id": "c1"}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"distance": 20, "name": "Pin"}));
run(&mut s, "solid.pattern.rectangular", json!({"features": ["Pin"], "dir1": [1, 0, 0], "count1": 2, "spacing1": 30}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Cap"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "corner": [200, 0, 0]}));
run(
&mut s,
"joint.create",
json!({"type": "revolute", "name": "OnCopy", "a": {"occurrence": "Pins", "circle": [35, 0, 20]}, "b": {"occurrence": "Cap", "face": [205, 5, 5]}}),
);
let j = run(&mut s, "joint.inspect", json!({"joint": "OnCopy"}))["joints"][0].clone();
let wall = reference(&j, "a", "face");
assert!(wall["name"].as_str().is_some_and(|n| n.contains(":side:c1@F")), "a copy's wall: {j}");
assert_eq!((&wall["sketch"]["curve"], &wall["sketch"]["name"]), (&json!("c1"), &json!("PinSketch")), "{j}");
assert!(wall["sketch"]["error"].is_null(), "{j}");
}
/// `joint.inspect` reads only: no undo step, the design unchanged, and the id agents' gates
/// treat as reading (`*.inspect`).
#[test]
+12
View File
@@ -2699,6 +2699,18 @@ fn press_pull_on_curved_faces() {
run(&mut s, "solid.press_pull", json!({"face": [25, 15, 10], "distance": 1}));
let v1 = volume(&mut s);
assert!(rel(v1 - v0, PI * (25.0 - 16.0) * 20.0) < 1e-3, "{v0} {v1}");
// A shell's inner wall behind a fillet (`F3:inner:F2:blend:…`) only names the fillet: it is
// offset like any curved face, not taken for the shell's fillet. (The offset itself is
// refused: the wall is tangent to its neighbours.)
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 20}));
run(&mut s, "solid.fillet", json!({"edges": [[40, 40, 10]], "radius": 5}));
run(&mut s, "solid.shell", json!({"faces": [[20, 20, 20]], "thickness": 2}));
let on = Vec3::new(35.0, 35.0, 10.0) + Vec3::new(1.0, 1.0, 0.0).normalized().unwrap() * 3.0;
let err =
s.execute("solid.press_pull", &json!({"face": [on.x, on.y, on.z], "distance": 0.5})).map(|v| v.to_string()).unwrap_or_else(|e| e.to_string());
assert!(!err.contains("not a fillet's or a chamfer's"), "{err}");
assert!(err.contains("offset"), "{err}");
}
/// A cut in one component leaves other components' bodies alone unless they are named as
+1 -1
View File
@@ -381,7 +381,7 @@ fn column_menu(app: &mut SolveApp, ui: &mut egui::Ui, error: &mut Option<String>
if !supported || !seen.insert(target.name.clone()) {
continue;
}
let Some((_, role)) = target.name.split_once(':') else { continue };
let Some((_, role)) = solidcraft_engine::doc::persistent_name::split_feature(&target.name) else { continue };
if ui_kit::button(ui, role, ui_kit::Button::Normal).clicked() {
pick = Some(json!({"face_appearance":{"target":target}}));
ui.close();
+1 -2
View File
@@ -451,8 +451,7 @@ fn picked_face_feature(app: &SolveApp) -> Option<u64> {
let body = state.body(body)?;
let names = solidcraft_engine::doc::naming::face_names(body);
let name = names.get(index)?;
let (creator, _) = name.strip_prefix('F')?.split_once(':')?;
let id = creator.parse::<u64>().ok()?;
let id = solidcraft_engine::doc::persistent_name::made_by(name)?;
let owner = app.session.doc.feature(body.feature)?;
if matches!(owner.kind, solidcraft_engine::doc::FeatureKind::Import { .. } | solidcraft_engine::doc::FeatureKind::MeshImport { .. })
&& id != owner.id
+1 -2
View File
@@ -1873,7 +1873,6 @@ fn feature_parts(app: &SolveApp, id: u64, shown_only: bool) -> Vec<Sel> {
return Vec::new();
}
let st = crate::open_meshing::shown_world(app);
let prefix = format!("F{id}:");
let mut out = Vec::new();
for b in &st.bodies {
if shown_only && (!app.session.body_visible(&b.name) || app.preview.effective_replaced().contains(&b.name)) {
@@ -1885,7 +1884,7 @@ fn feature_parts(app: &SolveApp, id: u64, shown_only: bool) -> Vec<Sel> {
}
let names = solidcraft_engine::doc::naming::face_names(b);
let m = b.mesh();
for (index, _) in names.iter().enumerate().filter(|(_, n)| n.starts_with(&prefix)) {
for (index, _) in names.iter().enumerate().filter(|(_, n)| solidcraft_engine::doc::persistent_name::made_by(n) == Some(id)) {
if let Some(point) = m.triangles.iter().zip(&m.tri_face).find_map(|(t, f)| {
if *f as usize != index {
return None;