Files
makeCAD/crates/engine/src/cmd/clipboard.rs
T
jyviko dc38349cbf Layer split stage 1: the B-rep record, native body file and Vec/Plane come from solidcore-record (#11496)
* Kernel: the B-rep record and the native body file come from solidcore-record

SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.

What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
  unit revolution axes, non-singular placements). `check::validate` and
  `check::validate_built` are the record's validation and these together, and every caller of
  `Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
  `edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.

The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.

solidcore-record is pinned to its rev on solidcore's `layer-record` branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record

The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

* Kernel: pin solidcore-record to solidcore main f5e8e9a29

solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:04:26 -05:00

883 lines
51 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Copy and paste of timeline features. Pasted features are independent copies: sketches get
//! their own dimension parameters, feature inputs their own names, and references inside the
//! copied set point at the copies.
use std::collections::BTreeMap;
use serde_json::{Value, json};
use solidcraft_doc::{FeatureKind, PlaneRef};
use super::CommandSpec;
use crate::params::{bad, name_or_id_values, vec3};
use crate::{Result, Session};
pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("timeline.copy", "Copy Features", copy).icon("copy").noundo().params("features: [ids or names] (in timeline order on paste)"),
CommandSpec::new("timeline.paste", "Paste Features", paste).icon("paste").params(
"translate?: [x,y,z] (moves the copies' geometry); component?: where the copies go (default: the active one), \
component_path?: its placement (default: the active one, else its only one); the copies go at the marker, each where \
its original is in the world (copies into their own component keep its coordinates); body transfers are left out; \
from_design?: true to paste sketch features from the host's cross-design clipboard snapshot",
),
];
fn copy(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "timeline.copy";
// The features are named or numbered, and both kinds can sit in one list.
let keys = name_or_id_values(cmd, p, "features")?;
if keys.is_empty() || keys.len() > 1000 {
return Err(bad(cmd, "`features` must list 1…1000 features"));
}
let ids = keys.iter().map(|key| super::edit::feature_id(s, Some(key), cmd)).collect::<Result<Vec<_>>>()?;
// Keep timeline order so sketches come before the features that use them.
let copied: Vec<solidcraft_doc::Feature> = s.doc.features.iter().filter(|f| ids.contains(&f.id)).cloned().collect();
let names: Vec<String> = copied.iter().map(|f| f.name.clone()).collect();
s.clipboard = copied;
s.foreign_copy = Some(std::sync::Arc::new(crate::ForeignCopy::of_features(s)));
Ok(json!({"copied": names}))
}
/// Origin planes become explicit planes so a translation can move them.
pub(in crate::cmd) fn explicit_planes(p: &mut PlaneRef) {
match p {
PlaneRef::Origin { name } => {
if let Some(plane) = solidcore_record::Plane::named(name) {
*p = PlaneRef::Custom { plane };
}
}
PlaneRef::Offset { base, .. } | PlaneRef::ThroughPoint { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => {
explicit_planes(base)
}
_ => {}
}
}
fn paste(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "timeline.paste";
match p.get("from_design") {
Some(Value::Bool(true)) => return super::clipboard_foreign::paste(s, p),
None | Some(Value::Bool(false)) => {}
_ => return Err(bad(cmd, "`from_design` must be true or false")),
}
if s.clipboard.is_empty() {
return Err(bad(cmd, "nothing copied (timeline.copy first)"));
}
let translate = match p.get("translate") {
Some(v) => Some(vec3(v).ok_or_else(|| bad(cmd, "`translate` must be [x, y, z]"))?),
None => None,
};
// A body transfer records which component bodies moved to, but the copies go into the
// component they are pasted into: a copy of the transfer would move nothing that is there, and
// it would belong to its destination rather than to the target. It is left out.
let (transfers, feats): (Vec<_>, Vec<_>) = s.clipboard.iter().cloned().partition(|f| matches!(f.kind, FeatureKind::BodyTransfer { .. }));
if feats.is_empty() {
return Err(bad(cmd, "body transfers are not pasted: the copies go into the component they are pasted into"));
}
let comp = match p.get("component") {
None => s.active_component,
Some(v) => {
let key = match v {
Value::Number(n) => n.to_string(),
Value::String(name) => name.clone(),
_ => return Err(bad(cmd, "`component` must be a component id or name")),
};
s.doc.find_component(&key).ok_or_else(|| bad(cmd, format!("no component `{key}`")))?
}
};
let given_path = match p.get("component_path") {
None => None,
Some(v) => Some(
v.as_array()
.filter(|a| a.len() <= 64)
.and_then(|a| a.iter().map(Value::as_u64).collect::<Option<Vec<_>>>())
.ok_or_else(|| bad(cmd, "`component_path` must list 0..64 occurrence ids"))?,
),
};
let mut sketches: BTreeMap<u64, u64> = BTreeMap::new();
let mut bodies: BTreeMap<String, String> = BTreeMap::new();
let mut used: std::collections::BTreeSet<String> = s.model.state().bodies.iter().map(|body| body.name.clone()).collect();
let mut notices: Vec<String> = transfers.iter().map(|f| format!("{} is a body transfer and was not pasted", f.name)).collect();
// The placement the copies are authored in: the one named, the active one (into the active
// component, as before), else the target's only (or active) placement.
let author_path = match given_path {
Some(path) => path,
None if comp == s.active_component => s.active_occurrence_path.clone().unwrap_or_else(|| s.doc.first_path(comp)),
None => super::component::placing::placement_of(s, &s.placed_document(), comp, None, "component_path", cmd)?.0,
};
solidcraft_doc::EmbossFace::component_frame(&s.placed_document(), comp, &author_path)?;
// A copy from another component goes where its original is in the world: its geometry moves
// from its component's frame (its first placement, where its bodies have their own names)
// into the target's.
let placed = s.placed_document();
let target_frame = placed.path_transform(comp, &author_path).ok_or_else(|| bad(cmd, "that path is not a placement of the target"))?;
let to_target = solidcraft_doc::mat_inverse(&target_frame).ok_or_else(|| bad(cmd, "the target's frame is not invertible"))?;
let frame_change: BTreeMap<u64, solidcraft_doc::Mat> = feats
.iter()
.map(|f| f.component)
.filter(|from| *from != comp)
.map(|from| {
let source = placed.path_transform(from, &placed.first_path(from)).unwrap_or(solidcraft_doc::IDENTITY);
(from, solidcraft_doc::mat_mul(&to_target, &source))
})
.collect();
drop(placed);
let mut shift = solidcraft_doc::IDENTITY;
if let Some(t) = translate {
shift[3][0] = t.x;
shift[3][1] = t.y;
shift[3][2] = t.z;
}
let mut names: BTreeMap<String, String> = BTreeMap::new();
let mut made = Vec::new();
for f in feats {
let mut kind = f.kind.clone();
kind.remap_refs(&sketches, &names);
let m = solidcraft_doc::mat_mul(&shift, frame_change.get(&f.component).unwrap_or(&solidcraft_doc::IDENTITY));
let moved = m.iter().enumerate().any(|(i, row)| row.iter().enumerate().any(|(j, v)| (v - if i == j { 1.0 } else { 0.0 }).abs() > 1e-12));
// A body made by an earlier copy is the one this copy acts on (#613).
kind.remap_bodies(&bodies);
if let FeatureKind::Sketch { plane, .. } = &mut kind
&& let Some(anchor) = super::sketch::face::anchor_mut(plane)
{
let internal = bodies.contains_key(&anchor.target.body);
if !internal && moved {
return Err(bad(
cmd,
"a moved paste (translated, or into a component placed elsewhere) retains an external exact face attachment; \
explicitly convert it to a fixed plane first",
));
}
if !internal {
notices.push(format!("pasted sketch retains external exact face attachment to {}", anchor.target.body));
}
if internal {
let source = solidcraft_doc::mat_mul(&shift, frame_change.get(&anchor.component).unwrap_or(&solidcraft_doc::IDENTITY));
anchor.reframe_placement(&m, &source)?;
}
anchor.remap_target(&sketches, &bodies)?;
if internal {
anchor.component = comp;
anchor.path = author_path.clone();
}
anchor.author_path = author_path.clone();
let target = anchor.target.clone();
if let FeatureKind::Sketch { sketch, .. } = &mut kind {
for link in &mut sketch.links {
if link.auto_face {
if let solidcraft_sketch::LinkSource::Face { body, .. } = &mut link.source
&& let Some(mapped) = bodies.get(body)
{
*body = mapped.clone();
}
link.face_name = Some(target.name.clone());
}
}
}
}
let built: Vec<String> = s
.model
.result(f.id)
.map(|result| result.state.bodies.iter().filter(|body| body.feature == f.id).map(|body| body.name.clone()).collect())
.unwrap_or_default();
let outputs = if f.body_names.is_empty() { built.clone() } else { f.body_names.clone() };
// A later feature names a body as the model shows it, and that is not always the name stored
// on the feature: solids that share a label are stored as `X`, `X`, `X` and shown as `X`,
// `X (2)`, `X (3)`, and a second import of a file shows `Aa (2)` for the stored `Aa`. The
// copies are found by the shown names; the stored ones only name the copies.
let shown = if built.len() == outputs.len() { built } else { outputs.clone() };
// Each copy is named after the body as shown, numbered: `Aa` → `Aa (2)`, `Aa (2)` → `Aa (2)(2)`.
let copied_names: Vec<_> = shown
.iter()
.map(|shown| {
let name = solidcraft_doc::copy_name(shown, |n| used.contains(n));
used.insert(name.clone());
bodies.insert(shown.clone(), name.clone());
name
})
.collect();
let doc = s.doc_mut();
if let FeatureKind::Sketch { sketch, .. } = &mut kind {
// Each dimension of the copy gets its own parameter, with the same expression.
for c in &mut sketch.constraints {
if let Some(pn) = c.param.clone() {
let (e, u) = doc.param(&pn).map(|x| (x.expr.clone(), x.unit.clone())).unwrap_or_else(|| (pn.clone(), "mm".into()));
c.param = Some(doc.new_model_param(&e, &u));
}
}
}
if moved {
if let FeatureKind::Sketch { plane, .. } | FeatureKind::ConstructionPlane { plane } = &mut kind {
explicit_planes(plane);
}
kind.transform_geometry(&m);
}
// A cylinder Emboss finds its face only by the persistent name recorded when it was made
// (#1035): the copy keeps that name, pointed at the pasted features and bodies.
let face_names: Vec<String> = if matches!(kind, FeatureKind::Emboss { face: Some(_), .. }) {
f.face_names.iter().map(|n| solidcraft_doc::remap_topology(n, &sketches, &bodies)).collect()
} else {
Vec::new()
};
// A copy keeps its original's name, numbered: `Sketch1` → `Sketch1 (2)`.
let name = solidcraft_doc::copy_name(&f.name, |n| doc.features.iter().any(|x| x.name == n));
let id = doc.add_feature(kind, Some(&name))?;
if let Some(nf) = doc.feature_mut(id) {
nf.component = comp;
nf.body_names = copied_names;
nf.face_names = face_names;
}
let new_name = doc.feature(id).map(|x| x.name.clone()).unwrap_or_default();
sketches.insert(f.id, id);
names.insert(f.name.clone(), new_name.clone());
made.push(json!({"id": id, "name": new_name, "from": f.name}));
}
s.refresh();
let errors: Vec<Value> = made
.iter()
.filter_map(|m| m["id"].as_u64())
.filter_map(|id| s.model.result(id).and_then(|r| r.error.clone()).map(|e| json!({"feature": id, "error": e})))
.collect();
Ok(json!({"pasted": made, "errors": errors, "notices":notices}))
}
#[cfg(test)]
mod tests {
use serde_json::{Value, json};
use solidcraft_geom::prelude::*;
use crate::Session;
fn run(s: &mut Session, id: &str, p: serde_json::Value) -> serde_json::Value {
match s.execute(id, &p) {
Ok(v) => v,
Err(e) => panic!("{id} {p}: {e}"),
}
}
fn volume(s: &mut Session) -> f64 {
run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap_or(f64::NAN)
}
fn dimensioned_sketch() -> Session {
let mut s = Session::default();
run(&mut s, "parameters.change", json!({"name": "base", "expression": "5 mm"}));
run(&mut s, "parameters.change", json!({"name": "width", "expression": "base * 4"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [20, 10]}));
run(&mut s, "sketch.constraint.coincident", json!({"a": "p1", "b": "origin"}));
let width = run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "width"}))["param"].as_str().unwrap().to_string();
run(&mut s, "sketch.dimension", json!({"entities": ["l2"], "value": format!("{width} / 2")}));
run(&mut s, "sketch.finish", json!({}));
s
}
fn sketch_area(s: &Session, id: u64) -> f64 {
s.model.state().sketch(id).unwrap().profiles.iter().map(|p| p.area).sum()
}
#[test]
fn foreign_sketch_paste_keeps_parameter_graph_snapshot_and_undo() {
let mut source = dimensioned_sketch();
run(&mut source, "timeline.copy", json!({"features": ["S"]}));
let mut target = dimensioned_sketch();
run(&mut target, "document.units", json!({"units": "in"}));
run(&mut target, "parameters.change", json!({"name": "base", "expression": "7 mm"}));
target.foreign_copy = source.foreign_copy.clone();
run(&mut source, "parameters.change", json!({"name": "base", "expression": "30 mm"}));
drop(source);
let before = target.doc.to_json();
let undo = target.undo.len();
let result = run(&mut target, "timeline.paste", json!({"from_design": true}));
let id = result["pasted"][0]["id"].as_u64().unwrap();
assert_eq!(result["pasted"][0]["name"], "S (2)");
assert!((sketch_area(&target, id) - 200.).abs() < 1e-6);
assert_eq!(target.doc.param("base").unwrap().expr, "7 mm");
assert_eq!(target.doc.param("base_2").unwrap().expr, "5 mm");
assert_eq!(target.doc.param("width_2").unwrap().expr, "base_2 * 4");
assert_eq!(target.undo.len(), undo + 1);
let after = target.doc.to_json();
run(&mut target, "edit.undo", json!({}));
assert_eq!(target.doc.to_json(), before);
run(&mut target, "edit.redo", json!({}));
assert_eq!(target.doc.to_json(), after);
let second = run(&mut target, "timeline.paste", json!({"from_design": true}))["pasted"][0]["id"].as_u64().unwrap();
assert!((sketch_area(&target, second) - 200.).abs() < 1e-6);
run(&mut target, "parameters.change", json!({"name": "base_2", "expression": "10 mm"}));
assert!((sketch_area(&target, id) - 800.).abs() < 1e-6);
assert!((sketch_area(&target, second) - 200.).abs() < 1e-6, "each paste owns its parameters");
assert!(solidcraft_doc::Document::from_json(&target.doc.to_json()).is_ok());
}
#[test]
fn foreign_sketch_paste_preserves_world_position_in_a_placed_component() {
use solidcore_record::Vec3;
let mut source = dimensioned_sketch();
let arc = [Vec3::new(1., 0., 0.), Vec3::new(0., 0., 1.), Vec3::new(-1., 0., 0.)];
for space in [solidcraft_sketch::WireSpace::World, solidcraft_sketch::WireSpace::Component] {
source.doc_mut().sketch_mut(1).unwrap().add_drawn_arc_in(&arc, space).unwrap();
}
source.refresh();
run(&mut source, "timeline.copy", json!({"features": ["S"]}));
let mut target = Session::default();
let made = run(&mut target, "component.create", json!({"name": "Target", "activate": false}));
let component = made["component"].as_u64().unwrap();
let occurrence = made["occurrence"].as_u64().unwrap();
run(&mut target, "occurrence.ground", json!({"occurrence": occurrence, "grounded": false}));
run(&mut target, "occurrence.move", json!({"occurrence": occurrence, "translate": [100, 20, 30], "axis": [0, 0, 1], "angle": "90 deg"}));
target.foreign_copy = source.foreign_copy.clone();
let id = run(&mut target, "timeline.paste", json!({"from_design": true, "component": component, "component_path": [occurrence]}))["pasted"]
[0]["id"]
.as_u64()
.unwrap();
let original = source.world_state().unwrap().sketch(1).unwrap().plane;
let pasted = target.world_state().unwrap().sketch(id).unwrap().plane;
assert!(pasted.origin.dist(original.origin) < 1e-6, "{original:?} vs {pasted:?}");
assert!(pasted.x.dist(original.x) < 1e-6);
assert!(pasted.y.dist(original.y) < 1e-6);
assert!((sketch_area(&target, id) - 200.).abs() < 1e-6);
assert_eq!(target.doc.feature(id).unwrap().component, component);
for (original, pasted) in
source.world_state().unwrap().sketch(1).unwrap().sketch.wires.iter().zip(&target.world_state().unwrap().sketch(id).unwrap().sketch.wires)
{
for (a, b) in original.pts.iter().chain(&original.fit).zip(pasted.pts.iter().chain(&pasted.fit)) {
assert!(a.dist(*b) < 1e-6, "wire {:?}: {a:?} vs {b:?}", original.space);
}
let (a, b) = (original.arc.unwrap(), pasted.arc.unwrap());
assert!(a.center.dist(b.center) < 1e-6);
assert!(a.normal.dist(b.normal) < 1e-6);
assert!((a.radius - b.radius).abs() < 1e-6);
}
let moved = run(
&mut target,
"timeline.paste",
json!({"from_design": true, "component": component, "component_path": [occurrence], "translate": [2, 3, 4]}),
)["pasted"][0]["id"]
.as_u64()
.unwrap();
let frame = target.placed_document().path_transform(component, &[occurrence]).unwrap();
let delta = solidcraft_doc::apply_vector(&frame, Vec3::new(2., 3., 4.));
for (original, pasted) in source
.world_state()
.unwrap()
.sketch(1)
.unwrap()
.sketch
.wires
.iter()
.zip(&target.world_state().unwrap().sketch(moved).unwrap().sketch.wires)
{
for (a, b) in original.pts.iter().chain(&original.fit).zip(pasted.pts.iter().chain(&pasted.fit)) {
assert!((*a + delta).dist(*b) < 1e-6, "translated wire {:?}: {a:?} vs {b:?}", original.space);
}
}
}
#[test]
fn foreign_sketch_paste_refuses_external_references_and_bad_parameters_atomically() {
let mut source = dimensioned_sketch();
let mut target = dimensioned_sketch();
// The same numeric ID in the target must never become the sketch's missing plane.
if let solidcraft_doc::FeatureKind::Sketch { plane, .. } = &mut source.doc_mut().feature_mut(1).unwrap().kind {
*plane = solidcraft_doc::PlaneRef::Construction { feature: 1.into() };
}
run(&mut source, "timeline.copy", json!({"features": ["S"]}));
target.foreign_copy = source.foreign_copy.clone();
let before = target.doc.to_json();
let undo = target.undo.len();
let error = target.execute("timeline.paste", &json!({"from_design": true})).unwrap_err().to_string();
assert!(error.contains("fixed plane"), "{error}");
assert_eq!(target.doc.to_json(), before);
assert_eq!(target.undo.len(), undo);
for params in
[json!({"from_design":"yes"}), json!({"from_design":true,"translate":"bad"}), json!({"from_design":true,"component_path":["bad"]})]
{
assert!(target.execute("timeline.paste", &params).is_err());
assert_eq!(target.doc.to_json(), before);
}
}
#[test]
fn foreign_sketch_paste_remaps_links_and_rejects_missing_source_sketches() {
let mut source = dimensioned_sketch();
run(&mut source, "sketch.create", json!({"plane":"XY","offset":5,"name":"Projected"}));
run(&mut source, "sketch.project", json!({"refs":[{"sketch":1,"curve":"l1"}]}));
run(&mut source, "sketch.finish", json!({}));
let mut target = dimensioned_sketch();
run(&mut source, "timeline.copy", json!({"features":["Projected"]}));
target.foreign_copy = source.foreign_copy.clone();
let before = target.doc.to_json();
let err = target.execute("timeline.paste", &json!({"from_design":true})).unwrap_err().to_string();
assert!(err.contains("external projected geometry"), "{err}");
assert_eq!(before, target.doc.to_json());
run(&mut source, "timeline.copy", json!({"features":["S","Projected"]}));
target.foreign_copy = source.foreign_copy.clone();
let result = run(&mut target, "timeline.paste", json!({"from_design":true}));
let first = result["pasted"][0]["id"].as_u64().unwrap();
let second = result["pasted"][1]["id"].as_u64().unwrap();
let copied = target.doc.sketch(second).unwrap();
assert!(matches!(copied.links[0].source, solidcraft_sketch::LinkSource::SketchCurve { sketch, .. } if sketch == first));
assert!(target.model.result(second).unwrap().error.is_none());
}
#[test]
fn foreign_sketch_paste_keeps_plane_input_units_and_text_parameters() {
let mut source = Session::default();
run(&mut source, "document.units", json!({"units":"in"}));
run(&mut source, "parameters.add", json!({"name":"height","expression":"2","unit":""}));
run(&mut source, "parameters.add", json!({"name":"Label","expression":"ABC","unit":"text"}));
run(&mut source, "sketch.create", json!({"plane":"XY","offset":"height","name":"Text"}));
run(&mut source, "sketch.text", json!({"text_expression":"Label + '-X'","at":[0,0],"height":"5 mm"}));
run(&mut source, "sketch.finish", json!({}));
run(&mut source, "timeline.copy", json!({"features":["Text"]}));
let mut target = Session::default();
run(&mut target, "parameters.add", json!({"name":"Label","expression":"other","unit":"text"}));
run(&mut target, "parameters.add", json!({"name":"d1","expression":"reserved","unit":"text"}));
target.foreign_copy = source.foreign_copy.clone();
let id = run(&mut target, "timeline.paste", json!({"from_design":true}))["pasted"][0]["id"].as_u64().unwrap();
assert!((target.model.state().sketch(id).unwrap().plane.origin.z - 50.8).abs() < 1e-9);
assert_eq!(target.doc.text_param("Label").unwrap().text, "other");
assert_eq!(target.doc.text_param("Label_2").unwrap().text, "ABC");
assert_eq!(target.doc.text_param("d1").unwrap().text, "reserved");
assert!(target.doc.param("d1").is_none());
let state = target.model.state();
let text = &state.sketch(id).unwrap().sketch.links[0].source;
assert!(matches!(text, solidcraft_sketch::LinkSource::Text { text, .. } if text == "ABC-X"));
assert!(solidcraft_doc::Document::from_json(&target.doc.to_json()).is_ok());
}
#[test]
fn foreign_sketch_paste_copies_equation_parameters_but_not_the_local_variable() {
let mut source = Session::default();
run(&mut source, "parameters.add", json!({"name":"height","expression":"3 mm"}));
run(&mut source, "sketch.create", json!({"plane":"XY","name":"Curve"}));
run(&mut source, "sketch.equation_curve", json!({"x":"t","y":"height + t * t","start":-2,"end":2}));
run(&mut source, "sketch.finish", json!({}));
run(&mut source, "timeline.copy", json!({"features":["Curve"]}));
let mut target = Session::default();
run(&mut target, "parameters.add", json!({"name":"height","expression":"99 mm"}));
target.foreign_copy = source.foreign_copy.clone();
let id = run(&mut target, "timeline.paste", json!({"from_design":true}))["pasted"][0]["id"].as_u64().unwrap();
let state = target.model.state();
let sketch = &state.sketch(id).unwrap().sketch;
let equation = &sketch.equations[0];
assert_eq!(equation.x.as_deref(), Some("t"));
assert_eq!(equation.y, "height_2 + t * t");
let curve = sketch.curves.iter().find(|c| c.id == equation.curve).unwrap();
for point in curve.kind.point_ids() {
let p = sketch.points[point].pos;
assert!((p.y - 3. - p.x * p.x).abs() < 1e-8, "{p:?}");
}
assert!(target.doc.param("t").is_none());
}
/// Features pasted into a component placed elsewhere (offset and turned) are carried into its
/// frame: the pasted body sits where the original is in the world, in that component, and the
/// pasted sketch is named after the original.
#[test]
fn features_pasted_into_a_component_placed_elsewhere_stay_where_they_were() {
let mut s = Session::default();
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"sketch": "S", "distance": 5, "body_name": "Block"}));
let made = run(&mut s, "component.create", json!({"name": "A", "activate": false}));
let (a, at) = (made["component"].as_u64().unwrap(), made["occurrence"].as_u64().unwrap());
run(&mut s, "occurrence.ground", json!({"occurrence": at, "grounded": false}));
run(&mut s, "occurrence.move", json!({"occurrence": at, "translate": [100, 0, 0], "axis": [0, 0, 1], "angle": "90 deg"}));
run(&mut s, "timeline.copy", json!({"features": ["S", "Extrude1"]}));
let r = run(&mut s, "timeline.paste", json!({"component": a, "component_path": [at]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
assert_eq!(r["pasted"][0]["name"], "S (2)");
let world = s.world_state().unwrap();
let (original, copy) = (world.body("Block").unwrap().mesh().bounds(), world.body("Block (2)").unwrap().mesh().bounds());
assert!(copy.min.dist(original.min) < 1e-6 && copy.max.dist(original.max) < 1e-6, "{original:?} vs {copy:?}");
let state = s.model.state();
assert_eq!(s.doc.model_body_component(state.body("Block (2)").unwrap()), a);
}
/// A sketch attached to a face of a body that isn't copied with it can't be carried into a
/// component placed elsewhere: the paste is refused, saying to make its plane fixed first.
#[test]
fn a_face_attached_sketch_is_not_moved_into_a_component_placed_elsewhere() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 20, "body_name": "Block"}));
run(&mut s, "sketch.create", json!({"plane": {"face": [10, 10, 20]}, "name": "OnTop"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [2, 2], "p1": [6, 6]}));
run(&mut s, "sketch.finish", json!({}));
let made = run(&mut s, "component.create", json!({"name": "A", "activate": false}));
let (a, at) = (made["component"].as_u64().unwrap(), made["occurrence"].as_u64().unwrap());
run(&mut s, "occurrence.ground", json!({"occurrence": at, "grounded": false}));
run(&mut s, "occurrence.move", json!({"occurrence": at, "translate": [100, 0, 0]}));
run(&mut s, "timeline.copy", json!({"features": ["OnTop"]}));
let err = s.execute("timeline.paste", &json!({"component": a, "component_path": [at]})).unwrap_err().to_string();
assert!(err.contains("fixed plane"), "{err}");
assert!(s.doc.find_feature("OnTop (2)").is_none(), "nothing was pasted");
}
#[test]
fn copy_paste_sketch_and_extrude() {
let mut s = Session::default();
run(&mut s, "parameters.change", json!({"name": "w", "expression": "10 mm"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]}));
run(&mut s, "sketch.constraint.coincident", json!({"a": "p1", "b": "origin"}));
run(&mut s, "sketch.dimension", json!({"entities": ["l1"], "value": "w"}));
run(&mut s, "sketch.dimension", json!({"entities": ["l2"], "value": 10}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"sketch": "S", "distance": 5}));
assert!((volume(&mut s) - 500.0).abs() < 1e-6);
run(&mut s, "timeline.copy", json!({"features": ["S", "Extrude1"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [30, 0, 0]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
assert_eq!(run(&mut s, "inspect.measure", json!({}))["body_count"], 2);
assert!((volume(&mut s) - 1000.0).abs() < 1e-6);
// The copy's dimensions are its own, still driven by the user parameter.
run(&mut s, "parameters.change", json!({"name": "w", "expression": "20 mm"}));
assert!((volume(&mut s) - 2000.0).abs() < 1e-6);
let pasted_extrude = r["pasted"][1]["name"].as_str().unwrap_or_default().to_string();
let d = s.doc.find_feature(&pasted_extrude).and_then(|f| f.param_names.first().cloned()).unwrap_or_default();
run(&mut s, "parameters.change", json!({"name": d, "expression": "10"}));
assert!((volume(&mut s) - 3000.0).abs() < 1e-6, "only the copy got thicker");
assert!(s.execute("timeline.paste", &json!({"translate": "x"})).is_err());
let mut t = Session::default();
assert!(t.execute("timeline.paste", &json!({})).is_err());
}
#[test]
fn paste_at_a_marker_inside_a_timeline_folder_joins_the_folder() {
let mut s = Session::default();
for (name, body, x) in [("First", "FirstBody", 0), ("Second", "SecondBody", 20), ("Source", "SourceBody", 40)] {
run(
&mut s,
"solid.box",
json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0], "operation": "new_body", "name": name, "body_name": body}),
);
}
let group = run(&mut s, "timeline.group", json!({"name": "Pair", "features": ["First", "Second"]}))["group"].as_u64().unwrap();
run(&mut s, "timeline.copy", json!({"features": ["Source"]}));
run(&mut s, "timeline.roll_to", json!({"position": 1}));
let pasted = run(&mut s, "timeline.paste", json!({}))["pasted"][0]["id"].as_u64().unwrap();
let folder = s.doc.timeline_groups.iter().find(|folder| folder.id == group).unwrap();
let first = s.doc.find_feature("First").unwrap().id;
let second = s.doc.find_feature("Second").unwrap().id;
assert_eq!(folder.features, vec![first, pasted, second]);
assert!(solidcraft_doc::Document::from_json(&s.doc.to_json()).is_ok(), "pasting inside a folder must leave a reopenable design");
}
/// A STEP file of three boxes at x = 0, 30 and 60. With `shared` the three solids carry one
/// label (`X`), as the parts of many assembly files do; otherwise each has its own.
fn three_box_step(tag: &str, shared: bool) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!("solidcraft-paste-{tag}-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let mut s = Session::default();
for (i, label) in ["Aa", "Bb", "Cc"].iter().enumerate() {
let corner = [30.0 * i as f64, 0.0, 0.0];
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": corner, "operation": "new_body", "body_name": label}));
}
let path = dir.join("Three.step");
run(&mut s, "file.export", json!({"path": path.to_string_lossy()}));
if shared {
let mut text = std::fs::read_to_string(&path).unwrap();
for label in ["Aa", "Bb", "Cc"] {
assert!(text.contains(&format!("MANIFOLD_SOLID_BREP('{label}'")), "the file names its solids: {label}");
text = text.replace(&format!("MANIFOLD_SOLID_BREP('{label}'"), "MANIFOLD_SOLID_BREP('X'");
}
std::fs::write(&path, text).unwrap();
}
path
}
/// An OBJ file of three 10 mm cubes at x = 0, 30 and 60, every object called `X`.
fn three_cube_obj(tag: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!("solidcraft-paste-{tag}-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let corners = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]];
let faces =
[[0, 2, 1], [0, 3, 2], [4, 5, 6], [4, 6, 7], [0, 1, 5], [0, 5, 4], [3, 7, 6], [3, 6, 2], [0, 4, 7], [0, 7, 3], [1, 2, 6], [1, 6, 5]];
let mut text = String::new();
for i in 0..3 {
text += "o X\n";
for c in corners {
text += &format!("v {} {} {}\n", 30 * i + 10 * c[0], 10 * c[1], 10 * c[2]);
}
for f in faces {
text += &format!("f {} {} {}\n", 8 * i + f[0] + 1, 8 * i + f[1] + 1, 8 * i + f[2] + 1);
}
}
let path = dir.join("Three.obj");
std::fs::write(&path, text).unwrap();
path
}
fn body_names(s: &Session) -> Vec<String> {
s.model.state().bodies.iter().map(|b| b.name.clone()).collect()
}
/// Where every body is: the lowest corner of its bounding box, rounded, in model order.
fn corners(s: &mut Session) -> Vec<Vec<f64>> {
let m = run(s, "inspect.measure", json!({}));
let bodies = m["bodies"].as_array().cloned().unwrap_or_default();
bodies
.iter()
.map(|b| b["bbox"]["min"].as_array().map(|a| a.iter().filter_map(|v| v.as_f64().map(f64::round)).collect()).unwrap_or_default())
.collect()
}
/// Lifts the first of the three bodies of the import by 20 and the second by 50 (two features),
/// copies the import with both and pastes them: the copies must be lifted, the originals once.
fn paste_import_with_two_lifts(s: &mut Session, import: &Value, bodies: [&str; 3]) {
run(s, "solid.move", json!({"bodies": [bodies[0]], "translate": [0, 0, 20], "name": "Lift first"}));
run(s, "solid.move", json!({"bodies": [bodies[1]], "translate": [0, 0, 50], "name": "Lift second"}));
run(s, "timeline.copy", json!({"features": [import, "Lift first", "Lift second"]}));
let r = run(s, "timeline.paste", json!({}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
}
const LIFTED: [[f64; 3]; 3] = [[0.0, 0.0, 20.0], [30.0, 0.0, 50.0], [60.0, 0.0, 0.0]];
/// A control: three solids with labels of their own. The pasted features act on the pasted bodies.
#[test]
fn pasting_an_import_moves_the_copies_of_the_bodies_its_features_named() {
let path = three_box_step("distinct", false);
let mut s = Session::default();
let import = run(&mut s, "file.insert_step", json!({"path": path.to_string_lossy()}))["feature"].clone();
assert_eq!(body_names(&s), ["Aa", "Bb", "Cc"]);
paste_import_with_two_lifts(&mut s, &import, ["Aa", "Bb", "Cc"]);
assert_eq!(body_names(&s), ["Aa", "Bb", "Cc", "Aa (2)", "Bb (2)", "Cc (2)"]);
let at: Vec<Vec<f64>> = LIFTED.iter().chain(&LIFTED).map(|c| c.to_vec()).collect();
assert_eq!(corners(&mut s), at);
}
/// Solids of a STEP file that share one label are built as `X`, `X (2)`, `X (3)`, and the features
/// made on them name them so. The pasted features act on the copies of those bodies, each on its
/// own: `X (2)` is not left on the original, and `X` does not go to the last copy.
#[test]
fn pasting_an_import_with_one_label_on_all_solids_moves_the_copy_of_each_body() {
let path = three_box_step("shared", true);
let mut s = Session::default();
let import = run(&mut s, "file.insert_step", json!({"path": path.to_string_lossy()}))["feature"].clone();
assert_eq!(body_names(&s), ["X", "X (2)", "X (3)"]);
paste_import_with_two_lifts(&mut s, &import, ["X", "X (2)", "X (3)"]);
let names = body_names(&s);
assert_eq!(names.len(), 6, "{names:?}");
let at: Vec<Vec<f64>> = LIFTED.iter().chain(&LIFTED).map(|c| c.to_vec()).collect();
assert_eq!(corners(&mut s), at, "{names:?}");
// The copies keep their names and their places when the design is saved and opened again.
let design = path.with_file_name("Three.solidcraft");
run(&mut s, "file.save_as", json!({"path": design.to_string_lossy()}));
let mut r = Session::default();
run(&mut r, "doc.open", json!({"path": design.to_string_lossy()}));
assert_eq!(body_names(&r), names);
assert_eq!(corners(&mut r), at);
}
/// The same for the objects of an OBJ file (3MF and STL files give the same kind of import).
#[test]
fn pasting_a_mesh_import_with_one_label_on_all_objects_moves_the_copy_of_each_body() {
let path = three_cube_obj("shared-obj");
let mut s = Session::default();
let import = run(&mut s, "file.insert_mesh", json!({"path": path.to_string_lossy()}))["feature"].clone();
assert_eq!(body_names(&s), ["X", "X (2)", "X (3)"]);
paste_import_with_two_lifts(&mut s, &import, ["X", "X (2)", "X (3)"]);
let at: Vec<Vec<f64>> = LIFTED.iter().chain(&LIFTED).map(|c| c.to_vec()).collect();
assert_eq!(corners(&mut s), at, "{:?}", body_names(&s));
}
/// No shared label is needed: a second import of the same file builds `Aa (2)`, `Bb (2)`, `Cc (2)`
/// from the labels `Aa`, `Bb`, `Cc`, and the features made on those bodies name them so.
#[test]
fn pasting_a_second_import_of_a_file_moves_the_copies_of_its_bodies() {
let path = three_box_step("twice", false);
let mut s = Session::default();
run(&mut s, "file.insert_step", json!({"path": path.to_string_lossy()}));
let second = run(&mut s, "file.insert_step", json!({"path": path.to_string_lossy()}))["feature"].clone();
assert_eq!(body_names(&s), ["Aa", "Bb", "Cc", "Aa (2)", "Bb (2)", "Cc (2)"]);
paste_import_with_two_lifts(&mut s, &second, ["Aa (2)", "Bb (2)", "Cc (2)"]);
// Each import is a component of its own (#1386), shown after the pasted copies: the first
// import's bodies stay where they were, the second's and their copies are lifted.
let plain = [[0.0, 0.0, 0.0], [30.0, 0.0, 0.0], [60.0, 0.0, 0.0]];
let at: Vec<Vec<f64>> = LIFTED.iter().chain(&plain).chain(&LIFTED).map(|c| c.to_vec()).collect();
assert_eq!(corners(&mut s), at, "{:?}", body_names(&s));
let m = run(&mut s, "inspect.measure", json!({}));
let names: Vec<&str> = m["bodies"].as_array().unwrap().iter().filter_map(|b| b["name"].as_str()).collect();
assert_eq!(names, ["Aa (2)(2)", "Bb (2)(2)", "Cc (2)(2)", "Aa", "Bb", "Cc", "Aa (2)", "Bb (2)", "Cc (2)"]);
}
/// A cylinder Emboss finds its face by the persistent name it recorded when it was made. The
/// pasted Emboss keeps that name, moved onto the pasted cylinder, so the copy gets its own
/// badge, with or without a translate (#1035).
#[test]
fn pasted_cylinder_emboss_badges_the_pasted_cylinder() {
for translate in [Some(json!([50, 0, 0])), None] {
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"radius": "10 mm", "height": "20 mm", "body_name": "Sleeve", "name": "Tube"}));
run(&mut s, "sketch.create", json!({"plane": {"origin": [0, 10, 0], "x_dir": [-1, 0, 0], "y_dir": [0, 0, 1]}, "name": "Badge"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [-2, 5], "p1": [2, 10]}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.emboss", json!({"sketch": "Badge", "face": [0, 10, 7.5], "depth": 1, "targets": ["Sleeve"], "name": "Mark"}));
let one = volume(&mut s);
let plain = std::f64::consts::PI * 100.0 * 20.0;
assert!(one > plain + 1.0, "the badge adds material: {one}");
run(&mut s, "timeline.copy", json!({"features": ["Tube", "Badge", "Mark"]}));
let p = translate.clone().map_or(json!({}), |t| json!({"translate": t}));
let r = run(&mut s, "timeline.paste", p);
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{translate:?}: {r}");
let mark = s.doc.find_feature(r["pasted"][2]["name"].as_str().unwrap_or_default()).cloned().unwrap();
let tube = r["pasted"][0]["id"].as_u64().unwrap();
assert!(mark.face_names.first().is_some_and(|n| n.starts_with(&format!("F{tube}:"))), "{:?}", mark.face_names);
assert!((volume(&mut s) - 2.0 * one).abs() < 1e-6, "{translate:?}: both cylinders carry a badge");
if translate.is_some() {
let m = run(&mut s, "inspect.measure", json!({"bodies": ["Sleeve (2)"]}));
let body = &m["bodies"][0];
let x = body["center_of_mass"][0].as_f64().unwrap_or(f64::NAN);
let y = body["bbox"]["max"][1].as_f64().unwrap_or(f64::NAN);
assert!((x - 50.0).abs() < 1e-3 && (y - 11.0).abs() < 1e-6, "the copy's badge sits on the moved cylinder: {m}");
}
}
}
#[test]
fn pasted_fillet_rounds_the_copied_body_it_names() {
let mut s = Session::default();
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 20]}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"sketch": "S", "distance": 10, "operation": "new", "body_name": "Block", "name": "Block"}));
run(&mut s, "solid.fillet", json!({"body": "Block", "radius": 2, "edges": [[20, 0, 10], [20, 20, 10]], "name": "Round"}));
let one = volume(&mut s);
assert!(one < 8000.0 - 1.0, "the fillet removes material: {one}");
run(&mut s, "timeline.copy", json!({"features": ["S", "Block", "Round"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [0, 40, 0]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
let round = r["pasted"][2]["name"].as_str().unwrap_or_default().to_string();
let def = run(&mut s, "timeline.inspect", json!({"feature": round}));
assert_eq!(def["definition"]["body"], "Block (2)", "{def}");
let m = run(&mut s, "inspect.measure", json!({}));
assert_eq!(m["body_count"], 2, "{m}");
assert!((volume(&mut s) - 2.0 * one).abs() < 1e-6, "both blocks are rounded: {m}");
}
/// One body's measures (bounding box, volume).
fn measures(s: &mut Session, body: &str) -> serde_json::Value {
run(s, "inspect.measure", json!({"bodies": [body]}))["bodies"][0].clone()
}
/// Pasting with a translate moves an extrude's `to` and `from` picks with it: the pasted posts
/// run to the pasted roof and from the pasted shelf, not to and from the originals.
#[test]
fn a_pasted_extrude_runs_to_and_from_the_pasted_faces() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 2, "corner": [0, 0, 20], "name": "Roof", "body_name": "Roof"}));
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 2, "corner": [0, 0, 10], "name": "Shelf", "body_name": "Shelf"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [5, 5], "p1": [10, 10]}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"sketch": "S", "distance": 5, "to": [7, 7, 20], "operation": "new", "name": "Up", "body_name": "Up"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "T"}));
run(&mut s, "sketch.rectangle.two_point", json!({"p0": [25, 25], "p1": [30, 30]}));
run(&mut s, "sketch.finish", json!({}));
run(
&mut s,
"solid.extrude",
json!({"sketch": "T", "distance": 5, "from": [27, 27, 12], "operation": "new", "name": "On", "body_name": "On"}),
);
run(&mut s, "timeline.copy", json!({"features": ["Roof", "Shelf", "S", "Up", "T", "On"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [100, 0, 10]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
let up = measures(&mut s, "Up (2)");
assert!((up["bbox"]["min"][2].as_f64().unwrap_or(0.0) - 10.0).abs() < 1e-6, "{up}");
assert!((up["bbox"]["max"][2].as_f64().unwrap_or(0.0) - 30.0).abs() < 1e-6, "it ends on the pasted roof: {up}");
let on = measures(&mut s, "On (2)");
assert!((on["bbox"]["min"][2].as_f64().unwrap_or(0.0) - 22.0).abs() < 1e-6, "it starts on the pasted shelf: {on}");
assert!((on["bbox"]["max"][2].as_f64().unwrap_or(0.0) - 27.0).abs() < 1e-6, "{on}");
}
/// Pasting with a translate moves a hole's `to` pick with it: the pasted through hole still goes
/// through, rather than stopping at the original's depth.
#[test]
fn a_pasted_hole_drills_to_the_moved_point() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "name": "Block", "body_name": "Block"}));
run(&mut s, "solid.hole", json!({"position": [20, 20, 10], "direction": [0, 0, -1], "diameter": 10, "to": [30, 30, -2], "name": "Drill"}));
run(&mut s, "timeline.copy", json!({"features": ["Block", "Drill"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [60, 0, -6]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
let (block, copy) = (measures(&mut s, "Block"), measures(&mut s, "Block (2)"));
let v = |m: &serde_json::Value| m["volume_mm3"].as_f64().unwrap_or(f64::NAN);
assert!((v(&block) - (16000.0 - std::f64::consts::PI * 25.0 * 10.0)).abs() < 1.0, "a through hole: {block}");
assert!((v(&copy) - v(&block)).abs() < 1e-6, "the pasted hole goes through too: {copy}");
}
/// Pasting with a translate moves a revolve's `to` pick with it: the pasted turn ends at the same
/// angle about its moved axis.
#[test]
fn a_pasted_revolve_turns_to_the_moved_point() {
let mut s = Session::default();
run(&mut s, "sketch.create", json!({"plane": "XZ", "name": "S"}));
run(&mut s, "sketch.line", json!({"points": [[10, 0], [15, 0], [15, 5], [10, 5]], "closed": true}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.revolve", json!({"sketch": "S", "axis": "y", "to": [0, 12, 2], "name": "Turn", "body_name": "Arc"}));
run(&mut s, "timeline.copy", json!({"features": ["S", "Turn"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [50, 0, 0]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
let (arc, copy) = (measures(&mut s, "Arc"), measures(&mut s, "Arc (2)"));
let v = |m: &serde_json::Value| m["volume_mm3"].as_f64().unwrap_or(f64::NAN);
// A quarter turn of a 5 × 5 section whose centre is 12.5 from the axis.
let quarter = 25.0 * std::f64::consts::FRAC_PI_2 * 12.5;
assert!((v(&arc) - quarter).abs() < quarter * 1e-3, "{arc}");
assert!((v(&copy) - v(&arc)).abs() < 1e-6, "the pasted arc turns a quarter too: {copy}");
}
/// A pasted coil that joins a body made by an earlier copy joins that copy, not the original.
#[test]
fn a_pasted_coil_joins_the_pasted_body() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 30, "width": 30, "height": 5, "name": "Base", "body_name": "Plate"}));
run(
&mut s,
"solid.coil",
json!({"diameter": 16, "pitch": 6, "revolutions": 3, "section_size": 2, "base": [15, 15, 5], "operation": "join", "targets": ["Plate"], "name": "Spring"}),
);
run(&mut s, "timeline.copy", json!({"features": ["Base", "Spring"]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [50, 0, 0]}));
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
let spring = r["pasted"][1]["name"].as_str().unwrap_or_default().to_string();
let def = run(&mut s, "timeline.inspect", json!({"feature": spring}));
assert_eq!(def["definition"]["targets"], json!(["Plate (2)"]), "{def}");
let st = s.world_state().unwrap();
let v = |name: &str| solidcraft_kernel::measure(&st.body(name).unwrap().body).unwrap().volume;
// A spring on the wrong plate is hundreds of mm³ off. The two plates are measured apart
// (one moved 50 mm), which the boolean and the measure each round in their own way:
// a few 1e-6 mm³ on 5000.
assert!((v("Plate") - v("Plate (2)")).abs() < 1e-8 * v("Plate"), "each plate carries one spring: {} vs {}", v("Plate"), v("Plate (2)"));
}
/// A copied body transfer is left out of a paste: the copies go into the component they are
/// pasted into. A pasted transfer belonged to that component and not to its destination, and
/// the saved design no longer loaded.
#[test]
fn a_copied_body_transfer_is_left_out_of_the_paste() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "name": "Base", "body_name": "Block"}));
let a = run(&mut s, "component.create", json!({"name": "A", "activate": false}))["component"].as_u64().unwrap_or_default();
run(&mut s, "component.move_bodies", json!({"bodies": ["Block"], "component": "A"}));
let transfer = s.doc.features.iter().find(|f| matches!(f.kind, solidcraft_doc::FeatureKind::BodyTransfer { .. })).map(|f| f.name.clone());
let transfer = transfer.unwrap_or_default();
run(&mut s, "timeline.copy", json!({"features": ["Base", transfer]}));
let r = run(&mut s, "timeline.paste", json!({"translate": [20, 0, 0]}));
assert_eq!(r["pasted"].as_array().map(Vec::len), Some(1), "{r}");
assert_eq!(r["notices"], json!([format!("{transfer} is a body transfer and was not pasted")]), "{r}");
let state = s.model.state();
assert_eq!(state.body("Block").map(|b| s.doc.model_body_component(b)), Some(a));
assert_eq!(state.body("Block (2)").map(|b| s.doc.model_body_component(b)), Some(0), "the copy is in the root, where it was pasted");
if let Err(e) = solidcraft_doc::Document::from_json(&s.doc.to_json()) {
panic!("the design loads back: {e}");
}
run(&mut s, "timeline.copy", json!({"features": [transfer]}));
let err = s.execute("timeline.paste", &json!({})).map(|v| v.to_string()).unwrap_or_else(|e| e.to_string());
assert!(err.contains("body transfers are not pasted"), "{err}");
}
}