Compare commits

..
37 Commits
Author SHA1 Message Date
Tanish Manku 129dd86ef2 Stack d2: #2648: an arc's pick off its sweep goes through seg_param
#2648 sent an arc pick outside its sweep to the nearer end with its own copy of the rule that
#2693 put in curves::seg_param. TRIM of an arc now uses seg_param, so the rule is in one place.
No change in behaviour: an_arc_picked_just_off_one_end_loses_the_piece_at_that_end covers it.
2026-11-19 15:17:16 -07:00
Tanish Manku 451caaac32 Stack d2: #2759: EXTEND's params name the open-polyline end rule
#2693 extends the end of an open polyline on the pick's side of its middle parameter, not the
nearer end; the EXTEND params doc from #2759 said only "the nearer end".
2026-11-19 15:15:33 -07:00
Tanish Manku 0cd36ad172 Stack d2: #2759: a pick on a line far from the origin is on it
The JSON TRIM diagnostic told a pick on the line from one off it within an absolute 1e-9. At
survey coordinates rounding alone moves the pick further than that, so a pick on the line was
reported as off it. The tolerance is now rounding of the coordinates, at least 1e-9.
2026-11-19 15:15:20 -07:00
Tanish Manku 63347dbf12 Stack d2: #2759: explain a line TRIM picked on its only cut
#2648 refuses a line trim picked within 5e-7 of its only cut with its own message, and Quick mode
leaves the line in place. The JSON form now explains that refusal as it explains the generic one,
and the Quick-mode test expects the line kept, as #2648 measured in AutoCAD 2024.
2026-11-19 15:15:12 -07:00
Tanish Manku 05cfcaa249 Merge branch 'pr/2759' into stack/d2
# Conflicts:
#	crates/engine/src/cmd/modify.rs
#	crates/engine/src/cmd/modify/trim.rs
#	crates/engine/src/cmd/trimextend.rs
#	crates/engine/tests/it/main.rs
2026-11-19 14:47:50 -07:00
Tanish Manku 6ed36aa844 Merge branch 'pr/3183' into stack/d2 2026-11-19 14:47:09 -07:00
Tanish Manku cd4e04a0d1 Merge branch 'pr/2104' into stack/d2 2026-11-19 14:47:09 -07:00
Tanish Manku 76b13c7ed2 Merge branch 'pr/2693' into stack/d2
# Conflicts:
#	crates/engine/tests/it/main.rs
2026-11-19 14:47:08 -07:00
Tanish Manku 26819d3a68 Merge branch 'pr/2648' into stack/d2 2026-11-19 14:46:59 -07:00
Tanish Manku 777ebededb Merge branch 'pr/2550' into stack/d2 2026-11-19 14:46:59 -07:00
Tanish Manku 41368223db Merge branch 'pr/2548' into stack/d2 2026-11-19 14:46:59 -07:00
jayzed80 8db82ebf7c TRIM/EXTEND: Space enters an option at the mode, projection and edge prompts (#3092) 2026-11-15 09:38:01 +00:00
Zaxaerith 149ba217ef fix(engine): distinguish TRIM pick failures and unblock formatting 2026-11-15 16:23:24 +08:00
Zaxaerith 41c2a99a22 Merge upstream main into the TRIM and EXTEND pick fix
Keep the TRIM handle-return contract and clarify the projected cutting-intersection diagnostic.
2026-11-15 14:13:58 +08:00
Zaxaerith 96a9fa615c fix(engine): clarify JSON TRIM and EXTEND pick diagnostics (#2750) 2026-11-04 12:13:46 +08:00
2ez4gcxandClaude Opus 5.5 cf46d11e27 BREAK and BREAKATPOINT: test the measured ends, closing side and undo
Pins AutoCAD 2024's results (accoreconsole, entget of every object after
the command) for the cases that are easy to get wrong:

- BREAKATPOINT at either end of a line, or at the end vertex of an open
  polyline, leaves the object whole;
- at an open polyline's middle vertex it splits it there, the original
  keeping the first part;
- BREAK of a closed polyline at two points of one side, either way round
  and on the side that closes it too, opens it with its own handle;
- a circle trimmed or broken becomes an arc with its own handle.

Undo after each break restores the object under its handle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 20:37:26 +07:00
2ez4gcxandClaude Opus 5.5 1b7cf50fbe Arc points a hair outside the sweep take the nearer end
EXTEND, TRIM, BREAK, DIVIDE and MEASURE place a point on an arc segment by
its angle from the arc's start. A point the closest-point search accepts
just before the start (within the 1e-12 sweep tolerance) wrapped round to
nearly a full turn and was clamped to the far end:

- EXTEND on a polyline picked there extended the wrong end;
- TRIM put a second cut at the far end of an arc span when a cutting edge
  ran through the vertex where the span starts (63 of 400 angles through
  that vertex on main), and took out the arc alone;
- DIVIDE and MEASURE ran from the wrong end.

`curves::seg_param` now sends an angle outside the sweep to the nearer end.
TRIM's `param_on` is that function, and EXTEND takes its pick parameter from
`curves::vertex_param_of`, the walk DIVIDE uses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 14:15:56 +07:00
2ez4gcxandClaude Opus 5.5 f6a97d273f EXTEND: a polyline extends the end on the pick's side of its middle
Measured in AutoCAD 2024 (accoreconsole): EXTEND on an open polyline
extends the end on the pick's side of the polyline's middle parameter,
not the end vertex nearer the pick. The pick's parameter is the segment
it is nearest, counted from 0, plus how far along it; from half the
number of segments on, the last end extends. (0,220) (20,220) (20,230)
(15,221) picked at (16,220) is 0.8 of 3, so the first end extends,
though the last vertex is 1.4 from the pick.

A repeated vertex counts as a segment, so the parameter is computed
over the vertex pairs rather than Polyline::segments.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 12:20:28 +07:00
2ez4gcxandClaude Opus 5.5 1415bb7fe1 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's measured pass-over rule: a cut by another edge at the
pick is passed over; a pick on the polyline's own cut trims nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 00:05:33 +07:00
2ez4gcxandClaude Opus 5.5 f370a5580e TRIM: lines, arcs and circles pass over a cut at the pick
Measured in AutoCAD 2024 (accoreconsole). A line, an arc or a circle
picked within 5e-7 of a cut by another edge runs the trim on across
that cut, as a polyline does: a line cut at x = 3 and 7 and picked on
3 loses 0 to 7; a circle cut at 60, 120, 240 and 300 degrees and
picked on 60 loses the arc from 300 round to 120. With no cut left,
nothing is trimmed, and Quick mode leaves the object in place, as it
meets an edge.

An arc picked just off its start is now trimmed at its start: the pick
was taken as being at the arc's end, round the circle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 23:23:59 +07:00
2ez4gcxandClaude Opus 5.5 3a9b653b51 TRIM: a cut by another edge at the pick is passed over
Measured in AutoCAD 2024 (accoreconsole): a pick within 5e-7 of a cut
by another edge doesn't leave the polyline as it is. AutoCAD runs the
piece on across that cut to the next one either side: with lines at
x = 3 and 7, a pick on 3 removes 0 to 7; with lines at 3, 5 and 7, a
pick on 5 removes 3 to 7. A pick that near one of the polyline's own
cuts (a vertex, where it is one of its own edges) still trims nothing.

When every cut is passed over, the refusal doesn't say "intersect", so
Quick mode doesn't erase the polyline as one no edge crosses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 23:19:42 +07:00
2ez4gcxandClaude Opus 5.5 b1fa96a690 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's measured TRIM rules: a pick on a cut trims nothing,
vertices in line don't cut, an edge through a closed polyline's start
vertex cuts it, and a closed polyline cut once is refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 22:31:53 +07:00
2ez4gcxandClaude Opus 5.5 061ecd1cd6 TRIM: a pick on a cut trims nothing; vertices in line don't cut
Measured in AutoCAD 2024 (accoreconsole) and followed here:

- A pick within 5e-7 of a cut along the polyline trims nothing, at any
  size; this replaces picking a side by cut index.
- An edge through a closed polyline's start vertex cuts it there.
- A closed polyline cut at one point is refused ("Curve must intersect
  cutting edges at least twice."); Quick mode leaves it in place.
- A vertex between two line segments within 1e-8 of parallel, straight
  on or doubling back, is not a cut.
- Crossing picks stay just inside a segment, off its vertices.

A polyline's own crossings are searched only on the segment picked and
those it runs straight on into, against the segments near them; past
2^24 pairs or 65,536 crossings the trim is refused instead of being made
at some of its cuts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 22:31:38 +07:00
ZachAR3 7619133bd6 docs: leave geometry-parity.md unchanged in this PR (#1594) 2026-11-02 16:07:30 +01:00
ZachAR3 596b9fe2ca Merge remote-tracking branch 'origin/main' into extend-trim-quick-fence
# Conflicts:
#	crates/engine/src/cmd/trimextend.rs
#	docs/geometry-parity.md
2026-11-02 15:37:54 +01:00
2ez4gcxandClaude Opus 5.5 c039fee2df Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's index-based choice of the piece next to a picked cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:15:52 +07:00
2ez4gcxandClaude Opus 5.5 9c2b8a2589 TRIM: a pick on a cut takes the piece next to that cut, by index
The split point was moved 2 x 4 ULP off a cut the pick was on. When two
cuts are closer than that (1e9 out, a segment a few ULP long) it moved
past the other cut too, and the long segment before was trimmed instead
of the short one picked. The cut the pick is on (the nearest within
rounding) now bounds the piece directly: with the next cut when the pick
is at its segment's start, with the previous one otherwise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:15:46 +07:00
2ez4gcxandClaude Opus 5.5 189b1810f4 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's fix keeping a pick inside a segment on its side of a cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:22:30 +07:00
2ez4gcxandClaude Opus 5.5 45d84f1090 TRIM: only a pick on a cut picks a side of it
A pick within 1e-9 of the polyline's length from a cut was moved across
it. On a long polyline that window is wide: 10000 long, a pick inside a
segment a millionth long was moved before the cut ahead of it, and
1e9 long, a pick half a unit up the second segment was moved onto the
first, so the wrong segment was trimmed. Only a pick on a cut within
rounding (4 ULP of the length) now picks a side of it; any other pick
splits the cuts where it is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:22:24 +07:00
2ez4gcxandClaude Opus 5.5 0f645f1275 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's fixes for a pick on a vertex and for closing pieces.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:46:31 +07:00
2ez4gcxandClaude Opus 5.5 e35dfe6533 TRIM: a pick on a vertex keeps the polyline; close only meeting ends
A pick exactly on a cut (a vertex, now that a polyline cuts itself at
each) found no piece on either side, and the whole polyline was erased.
It now takes the piece of the segment it was found on: the one before a
vertex the segment ends at, the one after a vertex it starts at.

A piece was closed when its ends were within 1e-9 of the coordinates'
size: about one unit 1e9 from the origin, so ends 0.58 apart closed. It
is now rounding error only, 64 ULP of the larger coordinate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:46:23 +07:00
2ez4gcxandClaude Opus 5.5 179e946a70 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's touch points and Quick-mode self-cuts for TRIM of a
polyline into this stacked branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 11:11:49 +07:00
2ez4gcxandClaude Opus 5.5 a70223e25f TRIM: a polyline cuts itself where it touches itself, in Quick mode too
A polyline that is one of the cutting edges was cut at its vertices and
where two of its segments cross, not where a vertex of it (an end
included) touches another of its segments. Trimmed there, a polyline
whose end returns onto its own segment lost the stretch past the touch
too. In Quick mode with every object it didn't cut itself at all.

As AutoCAD 2024 does (Standard mode by accoreconsole; Quick mode in
AutoCAD itself, picking on screen):
- a vertex touching another segment of the same polyline cuts that
  segment, in Standard and in Quick mode;
- a piece whose two ends meet is left closed, without the repeated
  vertex, its arcs kept.

Edges::quick is gone: nothing reads it any more.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 11:11:31 +07:00
2ez4gcxandClaude Opus 5.5 032a5dc3c7 feat(modify): BREAKATPOINT at the command line, as AutoCAD does
BREAKATPOINT gets AutoCAD 2024's prompts ("Select object:", then
"Specify break point:") and splits the object there; before, it only
had its JSON form, so typing it, a script or the menu failed. BREAK
and BREAKATPOINT now end the command when the break can't be made
("Arc cannot be full 360 degrees", no full stop, as measured), refuse
an object on a locked layer when it is picked, and leave nothing
selected after Enter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 18:19:01 +07:00
2ez4gcxandClaude Opus 5.5 4c875d949e fix(modify): BREAK and TRIM on closed and self-cutting polylines, keeping Z
BREAK on a closed polyline removes the stretch between the two points
that doesn't run through the start vertex, whichever point comes first;
at one point (or BREAKATPOINT) it splits the polyline in two, and at the
start vertex leaves it closed. In Standard mode, or when picked as an
edge, a polyline that is one of the cutting edges is also cut at its own
vertices and crossings. Pieces keep a line's Z, an arc's centre Z and a
polyline's elevation, constant width and linetype generation, for TRIM
as for BREAK. All measured in AutoCAD 2024 except Quick mode's implicit
edges, which keep leaving the polyline out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 17:12:08 +07:00
ZachAR3 683dd0bfec TRIM and EXTEND: test Quick-mode EXTEND through its fence (#1594)
The empty-space fence test now drives EXTEND through the second fence
point and checks the extended lines, not only the prompt.
2026-10-25 02:09:31 +01:00
ZachAR3 61483802a1 TRIM and EXTEND: a pick in empty space starts a fence in Quick mode (fixes #1594)
In Quick mode AutoCAD reads two picks in empty space as a crossing
fence: everything the fence crosses is trimmed or extended, without
choosing the Fence option first. CADCraft opened a crossing window
there. A pick in empty space now starts that two-point fence in Quick
mode; the next point applies it and the command asks for the next
object again. Standard mode keeps the crossing window.
2026-10-25 00:19:11 +02:00
80 changed files with 2294 additions and 3835 deletions
Generated
-1
View File
@@ -668,7 +668,6 @@ dependencies = [
"pollster 1.0.1",
"rfd",
"ron",
"serde",
"serde_json",
"sys-locale",
"thiserror 2.0.21",
+1 -1
View File
@@ -47,7 +47,7 @@ clap_mangen = { version = "0.3.3", features = ["env"] }
thiserror = "2"
same-file = "1"
serde = { version = "1", features = ["derive", "rc"] }
serde_json = { version = "1", features = ["float_roundtrip", "raw_value"] }
serde_json = { version = "1", features = ["float_roundtrip"] }
log = "0.4"
# All date/time conversion goes through chrono (no hand-rolled calendar code beyond the 400-year range extension; AGENTS.md).
chrono = { version = "0.4.45", default-features = false, features = ["std"] }
-2
View File
@@ -208,8 +208,6 @@ The logger is `apps/cadcraft/src/logging.rs`; the web build logs to the browser
cadcraft-cli mcp
# …or bridged to the running app (start it with --control 7979):
cadcraft-cli mcp --connect 127.0.0.1:7979
# …or headless, with the agent confined to a work folder:
cadcraft-cli mcp --automation-read-root ~/work --automation-write-root ~/work/out
# One-shot headless runs:
cadcraft-cli run --sample --script 'CIRCLE 22,3 1\n' --save out.dxf --export out.png
+6 -42
View File
@@ -276,13 +276,6 @@ pub(crate) struct McpArgs {
/// port first (macOS)
#[arg(long, requires = "connect")]
pub(crate) launch: bool,
/// The only folder the agent's commands may read from; reads are also allowed under the write
/// root (headless only)
#[arg(long, value_name = "DIR")]
pub(crate) automation_read_root: Option<String>,
/// The only folder the agent's commands may write to, never the folder itself (headless only)
#[arg(long, value_name = "DIR")]
pub(crate) automation_write_root: Option<String>,
#[command(flatten)]
pub(crate) settings: Settings,
}
@@ -415,18 +408,12 @@ enum UsageError {
/// The output is one of the input files, so writing it would replace the original.
#[error("{} is an input file, so the result would replace the original: choose another output, or pass --in-place to overwrite it", .0.display())]
OutIsInput(PathBuf),
/// The automation roots confine the headless server; a running app enforces its own access.
#[error(
"--automation-read-root and --automation-write-root confine the headless MCP server; a running app enforces its own file access (not yet available: see issue #1585)"
)]
AutomationRootsNeedHeadless,
}
impl UsageError {
/// This error in clap's form, so it prints with the usual usage text.
fn into_clap(self, cmd: &mut clap::Command) -> clap::Error {
let kind = match self {
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) | Self::AutomationRootsNeedHeadless => ErrorKind::ArgumentConflict,
Self::FramingNeedsImage { .. } | Self::OutIsInput(_) => ErrorKind::ArgumentConflict,
};
cmd.error(kind, self)
}
@@ -498,13 +485,6 @@ fn framing_error(cli: &Cli) -> Option<UsageError> {
(!cadcraft_io::is_image(out)).then(|| UsageError::FramingNeedsImage { flag, out: out.to_path_buf() })
}
/// The automation roots confine the headless server only, as the other Craft apps' do.
fn roots_need_headless(cli: &Cli) -> Option<UsageError> {
let Command::Mcp(m) = &cli.command else { return None };
(m.connect.is_some() && (m.automation_read_root.is_some() || m.automation_write_root.is_some()))
.then_some(UsageError::AutomationRootsNeedHeadless)
}
/// An output that is the same file as an input, without `--in-place`. An output that doesn't exist
/// can't be an input, and an I/O error in the comparison is left to the open or write that follows.
fn out_is_input(cli: &Cli) -> Option<UsageError> {
@@ -523,20 +503,19 @@ fn out_is_input(cli: &Cli) -> Option<UsageError> {
/// The backend `cadcraft-cli mcp` serves from.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum McpTarget {
/// An in-process drawing session (no `--connect`), optionally confined to the two folders.
Headless { read_root: Option<String>, write_root: Option<String> },
/// An in-process drawing session (no `--connect`).
Headless,
/// The running app's control channel at `HOST:PORT`; `lazy`: reached at the first call;
/// `launch`: opened then if it isn't running.
Connect { addr: String, lazy: bool, launch: bool },
}
impl McpArgs {
/// What these arguments ask the server to talk to.
pub(crate) fn target(&self) -> McpTarget {
match &self.connect {
// `--launch` connects at the first call too (the app opens then).
Some(addr) => McpTarget::Connect { addr: addr.clone(), lazy: self.lazy || self.launch, launch: self.launch },
None => McpTarget::Headless { read_root: self.automation_read_root.clone(), write_root: self.automation_write_root.clone() },
None => McpTarget::Headless,
}
}
}
@@ -609,7 +588,7 @@ fn parse_with(mut cmd: clap::Command, args: &[OsString]) -> Result<Cli, clap::Er
if let (Command::Run(r), Some((_, m))) = (&mut cli.command, matches.subcommand()) {
(r.drawings, r.steps) = run_order(m);
}
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)).or_else(|| roots_need_headless(&cli)) {
if let Some(e) = framing_error(&cli).or_else(|| out_is_input(&cli)) {
if let Some(sub) = matches.subcommand_name().and_then(|n| cmd.find_subcommand_mut(n)) {
return Err(e.into_clap(sub));
}
@@ -665,24 +644,9 @@ mod tests {
}
}
/// Without `--connect` the server runs headless, confining nothing unless asked.
#[test]
fn mcp_without_connect_is_headless() {
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless { read_root: None, write_root: None });
}
/// The automation roots confine a headless server; `--connect` is refused with the reason
/// (the running app's control channel is not confined yet, #1585).
#[test]
fn mcp_automation_roots_confine_a_headless_server_only() {
assert_eq!(
mcp(&["--automation-read-root", "/work", "--automation-write-root=/work/out"]).unwrap(),
McpTarget::Headless { read_root: Some("/work".into()), write_root: Some("/work/out".into()) }
);
let e = mcp(&["--connect", "127.0.0.1:7979", "--automation-read-root", "/work"]).unwrap_err().to_string();
assert!(e.contains("headless MCP server") && e.contains("#1585"), "{e}");
let e = mcp(&["--automation-write-root=/work", "--connect", "127.0.0.1:7979"]).unwrap_err().to_string();
assert!(e.contains("headless MCP server"), "{e}");
assert_eq!(mcp(&[]).unwrap(), McpTarget::Headless);
}
#[test]
-3
View File
@@ -27,9 +27,6 @@ pub(crate) enum CliError {
NotUnicode(std::path::PathBuf),
#[error("cannot connect to {addr}: {source}")]
McpConnect { addr: String, source: std::io::Error },
/// An `--automation-*-root` that cannot be opened (missing, a file, a link that escapes).
#[error("{0}")]
AutomationRoots(String),
}
pub(crate) type Result<T = (), E = CliError> = std::result::Result<T, E>;
+1 -9
View File
@@ -1,7 +1,6 @@
use super::args::{McpArgs, McpTarget};
use super::error::{CliError, Result};
/// Serve MCP on stdin and stdout against the running app or a headless session held to any roots given.
pub(crate) fn mcp(a: &McpArgs) -> Result {
let backend: Box<dyn cadcraft_mcp::Backend> = match a.target() {
McpTarget::Connect { addr, lazy: true, launch } => Box::new(cadcraft_mcp::Remote::lazy(&addr, launch)),
@@ -9,14 +8,7 @@ pub(crate) fn mcp(a: &McpArgs) -> Result {
Ok(r) => Box::new(r),
Err(source) => return Err(CliError::McpConnect { addr, source }),
},
McpTarget::Headless { read_root, write_root } => {
let roots = cadcraft_engine::file_access::AutomationRoots::new(
read_root.as_deref().map(std::path::Path::new),
write_root.as_deref().map(std::path::Path::new),
)
.map_err(CliError::AutomationRoots)?;
Box::new(cadcraft_mcp::Headless::default().with_automation_roots(roots))
}
McpTarget::Headless => Box::new(cadcraft_mcp::Headless::default()),
};
let stdin = std::io::stdin();
let stdout = std::io::stdout();
-404
View File
@@ -1,404 +0,0 @@
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` (#1472): through
//! the MCP protocol, files open only from inside the read root and are saved, exported, plotted and
//! rendered only inside the write root; `..` and links that leave a root are refused, and nothing is
//! written outside. Without roots nothing changes.
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};
use serde_json::{Value, json};
const INIT: &str = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}"#;
/// A folder of a test's own, removed when the test ends, also when it fails.
struct TestDir(PathBuf);
impl std::ops::Deref for TestDir {
type Target = Path;
/// The folder itself.
fn deref(&self) -> &Path {
&self.0
}
}
impl Drop for TestDir {
/// Removes the folder and all it holds; a failure here must not hide the test's own.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-mcp-roots-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// A folder holding `in` (the read root, with `a.dxf`), `out` (the write root), `outside` (with
/// `b.dxf`) and `in2` (a sibling with the same prefix as `in`).
fn folders(tag: &str) -> TestDir {
let base = fresh_dir(tag);
for d in ["in", "out", "outside", "in2"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
for p in ["in/a.dxf", "outside/b.dxf", "in2/c.dxf"] {
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
std::fs::write(base.join(p), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
}
base
}
/// `p` as the text a tool call passes.
fn s(p: &Path) -> String {
p.to_string_lossy().into_owned()
}
/// One tool call's result: `isError` and its first text block.
struct Tool {
error: bool,
text: String,
}
/// Run `cadcraft-cli mcp` with `args`, initialise, then make each call in order.
fn run(args: &[&str], calls: &[(&str, Value)]) -> (Output, Vec<Tool>) {
run_env(args, calls, &[])
}
/// [`run`], with `env` set for the server process (a private settings folder).
fn run_env(args: &[&str], calls: &[(&str, Value)], env: &[(&str, &str)]) -> (Output, Vec<Tool>) {
let mut input = format!("{INIT}\n");
for (i, (name, arguments)) in calls.iter().enumerate() {
let req = json!({"jsonrpc": "2.0", "id": i + 2, "method": "tools/call", "params": {"name": name, "arguments": arguments}});
input.push_str(&req.to_string());
input.push('\n');
}
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.envs(env.iter().copied())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn cadcraft-cli");
if let Some(mut stdin) = child.stdin.take() {
stdin.write_all(input.as_bytes()).unwrap();
}
let out = child.wait_with_output().expect("wait for cadcraft-cli");
let replies: Vec<Value> = String::from_utf8_lossy(&out.stdout).lines().filter_map(|l| serde_json::from_str(l).ok()).collect();
let tools = calls
.iter()
.enumerate()
.map(|(i, (name, arguments))| {
let id = (i + 2) as u64;
let reply = replies.iter().find(|v| v["id"] == id).unwrap_or_else(|| panic!("no reply to {name} {arguments}: {replies:?}"));
assert!(reply.get("error").is_none() && reply["result"].is_object(), "{name} {arguments} got an error reply, not a tool result: {reply}");
let result = &reply["result"];
Tool { error: result["isError"] == true, text: result["content"][0]["text"].as_str().unwrap_or_default().to_string() }
})
.collect();
(out, tools)
}
/// The call succeeded.
fn ok(t: &Tool) {
assert!(!t.error, "should be allowed: {}", t.text);
}
/// The call was refused, saying `why`.
fn refused(t: &Tool, why: &str) {
assert!(t.error, "should be refused ({why}): {}", t.text);
assert!(t.text.contains(why), "should say `{why}`: {}", t.text);
}
/// `open` and every other read stay inside the read root or the write root.
#[test]
fn files_open_only_from_inside_the_read_root() {
let base = folders("open");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("open", json!({"path": s(&base.join("outside/b.dxf"))})),
("open", json!({"path": s(&base.join("in2/c.dxf"))})),
("open", json!({"path": format!("{}/../outside/b.dxf", s(&base.join("in")))})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
refused(&t[1], "outside the read root");
refused(&t[2], "outside the read root");
refused(&t[3], "outside the read root");
// A refused path is an ordinary tool error; the session keeps working.
ok(&t[4]);
}
/// Writes stay inside the write root, the root itself is refused, and no temporary file is left outside.
#[test]
fn writes_go_only_into_the_write_root_and_leave_no_temp_file_outside() {
let base = folders("write");
let out = s(&base.join("out"));
let (out_run, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &out],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": s(&base.join("out/saved.dxf"))})),
("save", json!({"path": s(&base.join("outside/saved.dxf"))})),
("save", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": format!("{}/../outside/up.dxf", s(&base.join("out")))})),
("save", json!({"path": out})),
("save", json!({"path": format!("{out}/../out")})),
("execute", json!({"command": "export", "params": {"path": s(&base.join("out/art.png")), "format": "png"}})),
("execute", json!({"command": "export", "params": {"path": s(&base.join("outside/art.png")), "format": "png"}})),
("render", json!({"path": s(&base.join("out/view.png"))})),
("render", json!({"path": s(&base.join("outside/view.png"))})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out_run.status.success(), "stderr: {}", String::from_utf8_lossy(&out_run.stderr));
ok(&t[0]);
ok(&t[1]);
assert!(base.join("out/saved.dxf").is_file());
refused(&t[2], "outside the write root");
refused(&t[3], "outside the write root");
refused(&t[4], "outside the write root");
refused(&t[5], "the write root itself cannot be written");
refused(&t[6], "the write root itself cannot be written");
ok(&t[7]);
assert!(base.join("out/art.png").is_file());
refused(&t[8], "outside the write root");
ok(&t[9]);
assert!(base.join("out/view.png").is_file());
refused(&t[10], "outside the write root");
ok(&t[11]);
assert!(!base.join("outside/saved.dxf").exists());
assert!(!base.join("outside/art.png").exists());
assert!(!base.join("outside/view.png").exists());
// The save's temporary file is beside the destination, inside the root; none is outside.
assert!(!base.join("outside/saved.dxf.cadcraft-tmp").exists());
assert!(!base.join("outside/up.dxf.cadcraft-tmp").exists());
assert!(!base.join("out.cadcraft-tmp").exists(), "writing to the root must not leave its temporary file beside it");
let leftovers: Vec<String> =
std::fs::read_dir(base.join("outside")).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
assert_eq!(leftovers, ["b.dxf"], "nothing was written outside the roots");
let temps: Vec<String> =
std::fs::read_dir(&*base).unwrap().filter_map(|e| e.ok()?.file_name().into_string().ok()).filter(|n| n.ends_with(".cadcraft-tmp")).collect();
assert!(temps.is_empty(), "no temporary file beside or outside the roots: {temps:?}");
}
/// A root left out grants none of its own access: a read root allows no writes, while a write root also allows reads.
#[test]
fn a_root_left_out_grants_none_of_its_access() {
let base = folders("left-out");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in"))],
&[("open", json!({"path": s(&base.join("in/a.dxf"))})), ("save", json!({"path": s(&base.join("out/a.dxf"))})), ("save", json!({}))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
refused(&t[1], "write authority is absent");
// QSAVE writes over the opened drawing's own path, which is not writable either.
refused(&t[2], "write authority is absent");
let (out, t) = run(
&["--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
("save", json!({"path": s(&base.join("out/new.dxf"))})),
// Reads are allowed under the write root: the agent can reopen what it saved.
("open", json!({"path": s(&base.join("out/new.dxf"))})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root (or the write root)");
ok(&t[1]);
assert!(base.join("out/new.dxf").is_file());
ok(&t[2]);
}
/// The shared plotter settings folder is outside the roots: every action refuses and it is unchanged.
#[test]
fn plotter_settings_outside_the_roots_are_refused() {
let base = folders("plotters");
let config = base.join("config");
let settings = config.join("plotters");
std::fs::create_dir_all(&settings).unwrap();
let device = cadcraft_engine::doc::PlotterConfig {
name: "Office".into(),
description: "not the agent's".into(),
papers: vec![cadcraft_engine::doc::DevicePaper { name: "A4".into(), width: 210.0, height: 297.0, margins: [5.0; 4] }],
..Default::default()
};
let file = settings.join("Office.plotter.json");
let original = device.to_file_text();
std::fs::write(&file, &original).unwrap();
let text = original.clone();
let (out, t) = run_env(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("execute", json!({"command": "plottermanager", "params": {}})),
("execute", json!({"command": "plottermanager", "params": {"action": "get", "name": "Office"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "new", "name": "Leak", "output": "pdf"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "set", "name": "Office", "description": "changed"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "load", "text": text, "name": "Leaked Copy"}})),
("execute", json!({"command": "plottermanager", "params": {"action": "delete", "name": "Office"}})),
],
&[("CADCRAFT_CONFIG_DIR", &s(&config))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root (or the write root)");
refused(&t[1], "unknown plotter");
refused(&t[2], "outside the write root");
refused(&t[3], "unknown plotter");
refused(&t[4], "outside the write root");
refused(&t[5], "unknown plotter");
assert_eq!(std::fs::read_to_string(&file).unwrap(), original, "the shared file is unchanged");
let names: Vec<String> = std::fs::read_dir(&settings).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
assert_eq!(names, ["Office.plotter.json"], "nothing was created or deleted in the settings folder");
assert!(!settings.join("Office.plotter.json.cadcraft-tmp").exists());
}
/// With no roots nothing changes: files anywhere can be reached.
#[test]
fn without_roots_files_are_reachable_as_before() {
let base = folders("none");
let (out, t) =
run(&[], &[("open", json!({"path": s(&base.join("outside/b.dxf"))})), ("save", json!({"path": s(&base.join("outside/new.dxf"))}))]);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
ok(&t[1]);
assert!(base.join("outside/new.dxf").is_file());
}
/// A link inside a root leading out is refused for reads and writes.
#[cfg(unix)]
#[test]
fn links_out_of_a_root_are_refused() {
let base = folders("links");
std::os::unix::fs::symlink(base.join("outside"), base.join("out/away")).unwrap();
std::os::unix::fs::symlink(base.join("outside/b.dxf"), base.join("in/leak.dxf")).unwrap();
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[("open", json!({"path": s(&base.join("in/leak.dxf"))})), ("save", json!({"path": s(&base.join("out/away/new.dxf"))}))],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
refused(&t[0], "outside the read root");
refused(&t[1], "outside the write root");
assert!(!base.join("outside/new.dxf").exists());
}
/// Each kind of command that touches a file is refused outside the roots.
#[test]
fn every_file_a_command_touches_is_held_to_the_roots() {
let base = folders("commands");
let drawing = cadcraft_engine::doc::Drawing::new_imperial();
std::fs::write(base.join("in/x.dxf"), cadcraft_io::write(&drawing, "x.dxf").unwrap()).unwrap();
std::fs::write(base.join("in/ok.scr"), "CIRCLE 0,0 1\n").unwrap();
std::fs::write(base.join("outside/bad.scr"), "CIRCLE 0,0 1\n").unwrap();
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": s(&base.join("in/a.dxf"))})),
// SCRIPT
("execute", json!({"command": "script", "params": {"path": s(&base.join("in/ok.scr"))}})),
("execute", json!({"command": "script", "params": {"path": s(&base.join("outside/bad.scr"))}})),
// XATTACH reads the referenced drawing, INSERT and IMPORT read their files.
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("in/x.dxf")), "name": "ok"}})),
("execute", json!({"command": "xattach", "params": {"path": s(&base.join("outside/b.dxf")), "name": "bad"}})),
("execute", json!({"command": "insert", "params": {"name": "blk", "file": s(&base.join("outside/b.dxf")), "at": [0, 0]}})),
("execute", json!({"command": "import", "params": {"path": s(&base.join("outside/b.dxf"))}})),
// Support files (a linetype file here) and a plot style table.
("execute", json!({"command": "linetype", "params": {"file": s(&base.join("outside/b.dxf"))}})),
("execute", json!({"command": "stylesmanager", "params": {"action": "load", "path": s(&base.join("outside/b.dxf"))}})),
// PLOT writes only inside the write root; the inside plot works.
("execute", json!({"command": "plot", "params": {"path": s(&base.join("out/plot.pdf"))}})),
("execute", json!({"command": "plot", "params": {"path": s(&base.join("outside/plot.pdf"))}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
ok(&t[0]);
ok(&t[1]);
refused(&t[2], "outside the read root");
ok(&t[3]);
refused(&t[4], "outside the read root");
refused(&t[5], "outside the read root");
refused(&t[6], "outside the read root");
refused(&t[7], "outside the read root");
refused(&t[8], "outside the read root");
ok(&t[9]);
assert!(base.join("out/plot.pdf").is_file());
refused(&t[10], "outside the write root");
assert!(!base.join("outside/plot.pdf").exists());
}
/// A root that can't be opened, or roots with `--connect`, stop the server at startup.
#[test]
fn missing_roots_and_roots_with_connect_fail_at_startup() {
let base = folders("bad-roots");
let input = format!("{INIT}\n");
let start = |args: &[&str]| {
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn cadcraft-cli");
if let Some(mut stdin) = child.stdin.take() {
let _ = stdin.write_all(input.as_bytes());
}
child.wait_with_output().expect("wait for cadcraft-cli")
};
let out = start(&["--automation-read-root", &s(&base.join("nope"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation read root"));
let out = start(&["--automation-write-root", &s(&base.join("in/a.dxf"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("cannot open the automation write root"));
let out = start(&["--connect", "127.0.0.1:1", "--automation-read-root", &s(&base.join("in"))]);
assert!(!out.status.success() && out.stdout.is_empty());
assert!(String::from_utf8_lossy(&out.stderr).contains("headless MCP server"));
}
/// A UNC, device or non-disk verbatim path is refused by the server before it is opened.
/// The reply names the prefix. It is not an operating-system error from opening the path.
#[cfg(windows)]
#[test]
fn a_network_path_is_refused_before_it_is_opened() {
let base = folders("unc");
let (out, t) = run(
&["--automation-read-root", &s(&base.join("in")), "--automation-write-root", &s(&base.join("out"))],
&[
("open", json!({"path": r"\\203.0.113.5\s\x.dwg"})),
("open", json!({"path": r"\\?\UNC\203.0.113.5\s\x.dwg"})),
("open", json!({"path": r"\\host@SSL\share\x.dwg"})),
("open", json!({"path": r"\\.\PhysicalDrive0"})),
("open", json!({"path": r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg"})),
("execute", json!({"command": "circle", "params": {"center": [0, 0], "radius": 1}})),
],
);
assert!(out.status.success(), "stderr: {}", String::from_utf8_lossy(&out.stderr));
let kinds = ["UNC", "UNC", "UNC", "device path", "verbatim path"];
for (tool, kind) in t.iter().zip(kinds) {
refused(tool, kind);
assert!(!tool.text.contains("cannot resolve") && !tool.text.to_ascii_lowercase().contains("os error"), "{}", tool.text);
}
ok(&t[5]);
}
-749
View File
@@ -1,749 +0,0 @@
//! Walks every command in the registry through the real MCP server with paths outside the
//! automation roots (#1472). Reads show as a changed access time and writes as a changed size or
//! modification time, a removed file, or a file that was not there before, whatever the command
//! does with the path. The same walk without roots has to find escapes, or finding none under
//! roots would prove nothing.
#![cfg(unix)]
// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Never crash).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::collections::{BTreeMap, BTreeSet};
use std::fs::{File, FileTimes};
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, ChildStdin, Command, Stdio};
use std::sync::mpsc::{Receiver, channel};
use std::time::{Duration, SystemTime};
use serde_json::{Value, json};
/// Longest a call may take before the server counts as hung.
const CALL_TIMEOUT: Duration = Duration::from_secs(60);
/// The extensions commands choose their behaviour by.
const EXTENSIONS: &[&str] = &["dxf", "dwg", "dwt", "scr", "lsp", "lin", "pat", "pgp", "csv", "txt", "png", "pdf", "svg", "ctb"];
/// The parameter names a command might take a path under.
const PATH_KEYS: &[&str] =
&["path", "file", "template", "patternFile", "from", "to", "source", "target", "output", "folder", "dir", "filename", "document"];
/// A valid 1x1 PNG.
const PNG: &[u8] = &[
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0, 0, 0, 0x0D, 0x49, 0x48, 0x44, 0x52, 0, 0, 0, 1, 0, 0, 0, 1, 8, 6, 0, 0, 0, 0x1F, 0x15, 0xC4,
0x89, 0, 0, 0, 0x0A, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0, 1, 0, 0, 5, 0, 1, 0x0D, 0x0A, 0x2D, 0xB4, 0, 0, 0, 0, 0x49, 0x45, 0x4E, 0x44,
0xAE, 0x42, 0x60, 0x82,
];
/// `p` as the text a tool call passes.
fn s(p: &Path) -> String {
p.to_string_lossy().into_owned()
}
/// A running `cadcraft-cli mcp`.
struct Server {
child: Child,
stdin: ChildStdin,
replies: Receiver<Value>,
next: u64,
}
impl Server {
/// Start the real binary as an MCP server and initialize it.
fn start(args: &[String], cwd: &Path, config: &Path) -> Self {
let mut child = Command::new(env!("CARGO_BIN_EXE_cadcraft-cli"))
.arg("mcp")
.args(args)
.current_dir(cwd)
.env("CADCRAFT_CONFIG_DIR", config)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()
.expect("spawn cadcraft-cli");
let stdin = child.stdin.take().unwrap();
let stdout = child.stdout.take().unwrap();
let (tx, replies) = channel();
std::thread::spawn(move || {
for line in BufReader::new(stdout).lines().map_while(Result::ok) {
if let Ok(v) = serde_json::from_str::<Value>(&line)
&& tx.send(v).is_err()
{
break;
}
}
});
let mut server = Self { child, stdin, replies, next: 1 };
server.request("initialize", json!({"protocolVersion": "2025-06-18"})).expect("initialize");
server
}
/// Send one JSON-RPC request; `None` if the server stopped answering.
fn request(&mut self, method: &str, params: Value) -> Option<Value> {
let id = self.next;
self.next += 1;
let req = json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params});
writeln!(self.stdin, "{req}").ok()?;
loop {
let reply = self.replies.recv_timeout(CALL_TIMEOUT).ok()?;
if reply["id"] == id {
return Some(reply);
}
}
}
/// A tool's first text block, or `None` when the server hung or stopped.
fn tool(&mut self, name: &str, arguments: Value) -> Option<String> {
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments}))?;
Some(reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string())
}
/// Like [`Self::tool`] for a call that must work: an error reply, or a result flagged as an
/// error, fails the test.
fn tool_ok(&mut self, name: &str, arguments: Value) -> String {
let reply = self.request("tools/call", json!({"name": name, "arguments": arguments})).expect("the server answered");
assert!(reply.get("error").is_none() && reply["result"]["isError"] != true, "{name} should have worked: {reply}");
reply["result"]["content"][0]["text"].as_str().unwrap_or_default().to_string()
}
/// Run an engine command through the `execute` tool.
fn execute(&mut self, command: &str, params: Value) -> Option<String> {
self.tool("execute", json!({"command": command, "params": params}))
}
}
impl Drop for Server {
/// Stops the server it started.
fn drop(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
}
}
/// The folders of one walk: `in` and `out` are the roots, nothing under `outside` may be touched.
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> PathBuf {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-walk-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return dir,
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Remove the file or folder at `p`.
fn remove(p: &Path) {
let _ = if p.is_dir() { std::fs::remove_dir_all(p) } else { std::fs::remove_file(p) };
}
/// Remove what `dir` holds, if it exists.
fn clear(dir: &Path) {
for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {
remove(&entry.path());
}
}
struct Fixture {
base: PathBuf,
outside: PathBuf,
/// Each path under `outside`, with its size, modification time and access time.
baseline: BTreeMap<PathBuf, (u64, SystemTime, SystemTime)>,
/// Whether this file system records reads at all (`noatime` doesn't).
sees_reads: bool,
}
impl Fixture {
/// A new fixture, finding out whether this file system records reads.
fn new(tag: &str) -> Self {
let base = fresh_dir(tag);
for d in ["in", "out"] {
std::fs::create_dir(base.join(d)).unwrap();
}
let probe = base.join("probe");
std::fs::write(&probe, "x").unwrap();
age_access_time(&probe);
let before = std::fs::metadata(&probe).unwrap().accessed().unwrap();
std::fs::read(&probe).unwrap();
let sees_reads = std::fs::metadata(&probe).unwrap().accessed().unwrap() != before;
let outside = base.join("outside");
let mut f = Self { base, outside, baseline: BTreeMap::new(), sees_reads };
f.reset();
f
}
/// Lay out `outside` afresh and start watching it.
fn reset(&mut self) {
let o = self.outside.clone();
// The running server's working directory stays: without it a relative path can't be resolved.
clear(&o.join("cwd"));
for entry in std::fs::read_dir(&o).into_iter().flatten().flatten() {
if entry.file_name() != "cwd" {
remove(&entry.path());
}
}
for d in ["cwd", "config/plotters", "recover"] {
std::fs::create_dir_all(o.join(d)).unwrap();
}
let dxf = cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap();
for ext in EXTENSIONS {
let body: &[u8] = match *ext {
"dxf" | "dwg" | "dwt" => &dxf,
"scr" => b"CIRCLE 0,0 5\n",
"lsp" => b"(princ 1)\n",
"lin" => b"*WALK,walk\nA,1,-1\n",
"pat" => b"*WALK,walk\n0,0,0,0,1\n",
"pgp" => b"W,*LINE\n",
"csv" | "txt" => b"a,b\n1,2\n",
"png" => PNG,
_ => b"canary",
};
std::fs::write(o.join(format!("canary.{ext}")), body).unwrap();
}
// Two images, so that a drawing naming both loads them on threads of their own.
std::fs::write(o.join("second.png"), PNG).unwrap();
let device = cadcraft_engine::doc::PlotterConfig { name: "Office".into(), ..Default::default() };
std::fs::write(o.join("config/plotters/Office.plotter.json"), device.to_file_text()).unwrap();
self.watch();
}
/// Start watching what is under `outside` now.
fn watch(&mut self) {
let o = self.outside.clone();
self.baseline.clear();
for p in tree(&o) {
age_access_time(&p);
let m = std::fs::metadata(&p).unwrap();
self.baseline.insert(p, (m.len(), m.modified().unwrap(), m.accessed().unwrap()));
}
}
/// What happened under `outside` since [`Self::reset`]. Metadata is read before any directory
/// listing, and directory access times are put back afterwards: the listing is how a new file
/// is seen when the folder's modification time has not moved, and it must not look like a read.
fn touched(&self) -> Vec<String> {
let mut seen = Vec::new();
for (p, (len, modified, accessed)) in &self.baseline {
let name = p.strip_prefix(&self.outside).unwrap_or(p).display();
match std::fs::metadata(p) {
Err(_) => seen.push(format!("removed {name}")),
Ok(m) if m.modified().unwrap() != *modified || (!m.is_dir() && m.len() != *len) => seen.push(format!("wrote {name}")),
Ok(m) if self.sees_reads && m.accessed().unwrap() != *accessed => seen.push(format!("read {name}")),
Ok(_) => {}
}
}
for p in tree(&self.outside) {
if !self.baseline.contains_key(&p) {
let name = p.strip_prefix(&self.outside).unwrap_or(&p).display();
seen.push(format!("created {name}"));
}
}
for (p, (_, _, accessed)) in &self.baseline {
if p.is_dir() {
let _ = File::open(p).and_then(|f| f.set_times(FileTimes::new().set_accessed(*accessed)));
}
}
seen
}
}
impl Drop for Fixture {
/// Removes the fixture folder when the test ends, also when it fails.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.base);
}
}
/// Every file and folder under `dir`.
fn tree(dir: &Path) -> Vec<PathBuf> {
let mut out = vec![dir.to_path_buf()];
for e in std::fs::read_dir(dir).unwrap().flatten() {
if e.path().is_dir() {
out.extend(tree(&e.path()));
} else {
out.push(e.path());
}
}
out
}
/// Put `p`'s access time in the past, so that the next read updates it even under `relatime`.
fn age_access_time(p: &Path) {
let past = SystemTime::now() - Duration::from_secs(3 * 24 * 3600);
File::open(p).unwrap().set_times(FileTimes::new().set_accessed(past)).unwrap();
}
/// The `action` or `option` values a parameter doc lists: `action?: list|open|discard (…)`.
fn actions(doc: &str) -> Vec<String> {
let mut out = Vec::new();
for key in ["action", "option"] {
let Some(at) = doc.find(key) else { continue };
let rest = doc[at + key.len()..].trim_start_matches(['?', ':', ' ']);
let end = rest.find([',', '}', '(']).unwrap_or(rest.len());
out.extend(rest[..end].split('|').map(|w| w.trim().trim_matches('"').to_string()).filter(|w| !w.is_empty()));
}
out
}
/// The calls to try for command `id`: every path-like key set to `target`, with each action.
fn variants(doc: &str, target: &str, handle: &str, table: &str) -> Vec<Value> {
let mut base = json!({"handle": table, "handles": [handle], "at": [0, 0], "name": "walk"});
for key in PATH_KEYS {
base[*key] = json!(target);
}
let mut named = base.clone();
named["name"] = json!(target);
let mut device = base.clone();
device["name"] = json!("Office");
// Commands refuse parameters that don't go together, so each key the doc names goes on its own too.
let lower = doc.to_ascii_lowercase();
let documented = PATH_KEYS.iter().filter(|key| **key == "path" || lower.contains(&key.to_ascii_lowercase()));
let alone = documented.flat_map(|key| {
[
json!({*key: target}),
json!({*key: target, "handles": [handle]}),
json!({*key: target, "handle": table}),
json!({*key: target, "name": "Office"}),
]
});
let mut out = Vec::new();
for v in [base, named, device].into_iter().chain(alone) {
out.push(v.clone());
for a in actions(doc) {
let mut with = v.clone();
with["action"] = json!(a);
with["option"] = json!(a);
out.push(with);
}
}
out
}
/// Whether a command's doc says it takes a file. These get every extension; the rest, one.
fn takes_a_file(doc: &str) -> bool {
let d = doc.to_ascii_lowercase();
["path", "file", "template", "folder", "action", "option"].iter().any(|w| d.contains(w))
}
/// A fresh drawing with a circle and a table, selected; the circle's and table's handles.
fn seed(server: &mut Server) -> Option<(String, String)> {
// Closed first: the walk starts tens of thousands of drawings, and they would all stay open.
server.execute("closeall", json!({}))?;
server.execute("new", json!({}))?;
let handle_of = |text: &str| serde_json::from_str::<Value>(text).ok().and_then(|v| v["handle"].as_str().map(str::to_string)).unwrap_or_default();
let circle = server.execute("circle", json!({"center": [0, 0], "radius": 1}))?;
let table = server.execute("table", json!({"at": [5, 5], "rows": 2, "columns": 2}))?;
server.execute("selectall", json!({}))?;
Some((handle_of(&circle), handle_of(&table)))
}
/// What one walk saw.
struct Walk {
/// The command and the call that touched each file outside.
escapes: BTreeMap<String, Vec<String>>,
calls: usize,
commands: usize,
/// Calls that hung or stopped the server.
lost: Vec<String>,
sees_reads: bool,
}
/// Run the walk, under `in` and `out` as roots or with no roots at all.
fn walk(tag: &str, roots: bool) -> Walk {
let mut f = Fixture::new(tag);
let args = if roots {
vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))]
} else {
vec![]
};
let cwd = f.outside.join("cwd");
let config = f.outside.join("config");
let start = |f: &mut Fixture| {
let server = Server::start(&args, &cwd, &config);
f.reset();
server
};
let mut server = start(&mut f);
let listed = server.tool("list_commands", json!({})).expect("list_commands");
let specs: Vec<Value> = serde_json::from_str(&listed).expect("the command list");
assert!(specs.len() > 400, "the walk has to see the registry: {} commands", specs.len());
let mut result = Walk { escapes: BTreeMap::new(), calls: 0, commands: specs.len(), lost: Vec::new(), sees_reads: f.sees_reads };
let mut steps: Vec<(String, Value)> = Vec::new();
let o = f.outside.clone();
let canary = |ext: &str| s(&o.join(format!("canary.{ext}")));
let (circle, table) = seed(&mut server).expect("seed");
assert!(!circle.is_empty(), "the seed circle has no handle");
assert!(!table.is_empty(), "the seed table has no handle");
for spec in &specs {
let id = spec["id"].as_str().unwrap().to_string();
let doc = spec["params"].as_str().unwrap_or_default();
let mut targets: Vec<String> = if takes_a_file(doc) { EXTENSIONS.iter().map(|e| canary(e)).collect() } else { vec![canary("dxf")] };
if takes_a_file(doc) {
// A file that isn't there yet, in a folder that isn't there yet, and a relative path.
targets.extend(["dxf", "png", "pdf", "csv"].iter().map(|e| s(&o.join(format!("fresh/x.{e}")))));
targets.push("../canary.dxf".to_string());
}
for target in targets {
for v in variants(doc, &target, &circle, &table) {
steps.push((id.clone(), v));
}
}
}
let run_step =
|server: &mut Server, f: &mut Fixture, result: &mut Walk, id: &str, label: String, call: &mut dyn FnMut(&mut Server) -> Option<String>| {
result.calls += 1;
let done = call(server);
let touched = f.touched();
if !touched.is_empty() {
for what in touched {
result.escapes.entry(id.to_string()).or_default().push(format!("{what}: {label}"));
}
}
if done.is_none() {
result.lost.push(format!("{id}: {label}"));
}
done.is_some()
};
for (id, params) in &steps {
let label = params.to_string();
let params = params.clone();
let alive = run_step(&mut server, &mut f, &mut result, id, label, &mut |sv| sv.execute(id, params.clone()));
let dirty = !f.touched().is_empty();
if !alive {
server = start(&mut f);
} else if dirty {
f.reset();
}
// A command can stop the server without its own reply being lost.
if seed(&mut server).is_none() {
result.lost.push(format!("after {id}: {params}"));
server = start(&mut f);
seed(&mut server);
}
}
// The ways in that aren't one command with a path parameter.
let dxf = canary("dxf");
let png = canary("png");
let scr = canary("scr");
let lsp = canary("lsp");
let tools: Vec<(&str, &str, Value)> = vec![
("tool:open", "open", json!({"path": dxf})),
("tool:save", "save", json!({"path": dxf})),
("tool:save-new", "save", json!({"path": s(&o.join("fresh/y.dxf"))})),
("tool:render", "render", json!({"path": png})),
("tool:command_line", "command_line", json!({"text": format!("SCRIPT {scr}")})),
("tool:command_line", "command_line", json!({"text": format!("OPEN {dxf}")})),
("tool:command_line", "command_line", json!({"text": format!("SAVEAS {dxf}")})),
("tool:script", "script", json!({"text": format!("OPEN {dxf}\n")})),
];
for (label, name, a) in tools {
let text = a.to_string();
let a = a.clone();
let alive = run_step(&mut server, &mut f, &mut result, label, text, &mut |sv| sv.tool(name, a.clone()));
if alive {
f.reset();
} else {
server = start(&mut f);
}
seed(&mut server);
}
let lisp = [
format!("(setq f (open {dxf:?} \"r\")) (read-line f) (close f)"),
format!("(setq f (open {dxf:?} \"w\")) (write-line \"x\" f) (close f)"),
format!("(setq f (open {:?} \"w\")) (write-line \"x\" f) (close f)", s(&o.join("new.txt"))),
format!("(load {lsp:?})"),
];
for code in lisp {
let label = code.clone();
run_step(&mut server, &mut f, &mut result, "lisp:code", label, &mut |sv| sv.execute("lisp", json!({"code": code})));
f.reset();
seed(&mut server);
}
// Settings that name a file or a folder, then the commands that use them.
let chained: Vec<(&str, Vec<(&str, Value)>)> = vec![
(
"stylesmanager",
vec![
("stylesmanager", json!({"action": "new", "name": "walk.ctb"})),
("stylesmanager", json!({"action": "save", "name": "walk.ctb", "path": canary("ctb")})),
("stylesmanager", json!({"action": "load", "path": canary("ctb")})),
],
),
(
"pdfbook",
vec![("pline", json!({"points": [[0, 0], [210, 0], [210, 297], [0, 297]], "closed": true})), ("pdfbook", json!({"path": canary("pdf")}))],
),
("setvar:SAVEFILEPATH", vec![("setvar", json!({"name": "SAVEFILEPATH", "value": s(&o.join("recover"))})), ("drawingrecovery", json!({}))]),
("setvar:QNEWTEMPLATE", vec![("setvar", json!({"name": "QNEWTEMPLATE", "value": dxf})), ("new", json!({}))]),
];
for (label, calls) in chained {
for (id, params) in calls {
run_step(&mut server, &mut f, &mut result, label, format!("{id} {params}"), &mut |sv| sv.execute(id, params.clone()));
}
f.reset();
seed(&mut server);
}
result
}
/// One line saying what a walk saw.
fn summary(w: &Walk) -> String {
format!(
"{} commands, {} calls, reads seen: {}, {} commands touched files outside, {} calls lost the server",
w.commands,
w.calls,
w.sees_reads,
w.escapes.len(),
w.lost.len()
)
}
/// Under roots, nothing in the registry reaches a file outside them.
#[test]
fn no_command_escapes_the_roots() {
let w = walk("roots", true);
println!("under roots: {}", summary(&w));
let found: Vec<String> = w.escapes.iter().flat_map(|(id, what)| what.iter().take(3).map(move |l| format!("{id}: {l}"))).collect();
assert!(found.is_empty(), "escapes under the roots:\n{}", found.join("\n"));
assert!(w.lost.is_empty(), "calls that lost the server: {:?}", w.lost);
}
/// The control: without roots the same walk finds these commands reaching the same files. If this
/// fails, the walk has stopped reaching them and [`no_command_escapes_the_roots`] proves nothing.
#[test]
fn the_walk_finds_escapes_without_roots() {
let w = walk("control", false);
println!("without roots: {}", summary(&w));
let found: BTreeSet<&str> = w.escapes.keys().map(String::as_str).collect();
println!("touched files outside: {}", found.iter().copied().collect::<Vec<_>>().join(" "));
let writers = [
"saveas",
"export",
"plot",
"exportpdf",
"publish",
"pdfbook",
"wblock",
"-wblock",
"layout.saveas",
"layout",
"stylesmanager",
"tableexport",
"dataextraction",
"tool:save",
"tool:save-new",
"tool:render",
"lisp:code",
];
// What a command touched is kept with its kind (`wrote`, `created`, `removed`, `read`): a writer
// must show a write, not just a read, or a writer that only reads would still pass.
let kinds = |id: &str, kinds: &[&str]| w.escapes.get(id).is_some_and(|e| e.iter().any(|l| kinds.iter().any(|k| l.starts_with(k))));
let not_writing: Vec<&str> = writers.into_iter().filter(|id| !kinds(id, &["wrote ", "created ", "removed "])).collect();
assert!(not_writing.is_empty(), "the walk no longer finds these writing outside: {not_writing:?}; touched: {:?}", w.escapes);
if w.sees_reads {
for id in [
"open",
"new",
"recover",
"script",
"import",
"insert",
"minsert",
"xattach",
"-xref",
"compare",
"imageattach",
"attach",
"aliasedit",
"linetype",
"hatch.patterns",
"plottermanager",
"appload",
"datalink",
"tool:open",
"setvar:QNEWTEMPLATE",
"setvar:SAVEFILEPATH",
] {
assert!(kinds(id, &["read "]), "the walk no longer finds `{id}` reading outside: {found:?}");
}
}
}
/// A drawing inside the roots can't bring in what it names outside them: an image or an xref saved
/// with a path outside stays unloaded, and nothing outside is read.
#[test]
fn a_drawing_cannot_reach_files_it_names_outside_the_roots() {
let mut f = Fixture::new("named");
let host = f.base.join("in/host.dxf");
{
// Made without roots: a drawing someone hands the agent.
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
let image = free.execute("imageattach", json!({"path": s(&f.outside.join("canary.png"))})).unwrap();
assert!(image.contains("handle"), "the image attaches: {image}");
let second = free.execute("imageattach", json!({"path": s(&f.outside.join("second.png"))})).unwrap();
assert!(second.contains("handle"), "the second image attaches: {second}");
let xref = free.execute("xattach", json!({"path": s(&f.outside.join("canary.dxf")), "name": "walk"})).unwrap();
assert!(xref.contains("handle"), "the xref attaches: {xref}");
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
let opened = server.tool("open", json!({"path": s(&host)})).unwrap();
let images = server.execute("image", json!({})).unwrap();
let xrefs = server.execute("xref", json!({})).unwrap();
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}\nopen: {opened}\nimage: {images}\nxref: {xrefs}");
assert!(images.contains("canary.png") && !images.contains("\"Loaded\""), "the image stays unloaded: {images}");
assert!(images.contains("\"foundAt\": null") || images.contains("\"foundAt\":null"), "and it isn't said to exist: {images}");
assert!(!xrefs.contains("\"Loaded\""), "the xref stays unloaded: {xrefs}");
}
/// A font linked into the drawing's folder isn't read from where the link leads.
#[test]
fn a_font_linked_beside_a_drawing_is_not_followed_out() {
let mut f = Fixture::new("font");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
free.execute("style", json!({"name": "Walk", "font": "walkfont.shx"})).unwrap();
free.execute("style.current", json!({"name": "Walk"})).unwrap();
let text = free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
assert!(text.contains("handle"), "the text is drawn: {text}");
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let saved = std::fs::read_to_string(&host).unwrap();
assert!(saved.to_ascii_lowercase().contains("walkfont.shx"), "the drawing names the font");
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
std::os::unix::fs::symlink(f.outside.join("walkfont.shx"), f.base.join("in/walkfont.shx")).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
std::fs::write(f.outside.join("walkfont.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
f.watch();
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
}
/// Saving through a link that stands outside the roots and points in doesn't leave a backup
/// beside the link.
#[test]
fn a_backup_stays_inside_the_roots() {
let f = Fixture::new("backup");
let target = f.base.join("out/t.dxf");
std::fs::write(&target, cadcraft_io::write(&cadcraft_engine::doc::Drawing::new_imperial(), "x.dxf").unwrap()).unwrap();
let link = f.outside.join("link.dxf");
std::os::unix::fs::symlink(&target, &link).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
server.tool("new_drawing", json!({})).unwrap();
let saved = server.tool("save", json!({"path": s(&link)})).unwrap();
assert!(saved.contains("outside the write root"), "{saved}");
assert!(!f.outside.join("link.dxf.bak").exists() && !f.outside.join("link.bak").exists(), "{saved}");
}
/// Deleting a plotter acts on the entry in the settings folder, whatever it points at.
#[test]
fn a_plotter_link_outside_the_roots_is_not_removed() {
let f = Fixture::new("plotter");
let inside = f.base.join("out/kept.plotter.json");
std::fs::write(&inside, cadcraft_engine::doc::PlotterConfig { name: "Kept".into(), ..Default::default() }.to_file_text()).unwrap();
let entry = f.outside.join("config/plotters/Kept.plotter.json");
std::os::unix::fs::symlink(&inside, &entry).unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
let reply = server.execute("plottermanager", json!({"action": "delete", "name": "Kept"})).unwrap();
assert!(std::fs::symlink_metadata(&entry).is_ok(), "the link is still there: {reply}");
}
/// Without roots, a settings folder that can't be read leaves the built-in devices listed.
#[test]
fn without_roots_an_unreadable_settings_folder_still_lists_devices() {
let f = Fixture::new("devices");
let not_a_folder = f.outside.join("canary.txt");
let mut server = Server::start(&[], &f.outside.join("cwd"), &not_a_folder);
let list = server.execute("plottermanager", json!({"action": "list"})).unwrap();
assert!(list.contains("devices"), "{list}");
}
/// A font beside a drawing inside the roots is still used.
#[test]
fn a_font_beside_a_drawing_inside_the_roots_is_used() {
let f = Fixture::new("font-inside");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
free.execute("style", json!({"name": "Walk", "font": "walkinside.shx"})).unwrap();
free.execute("style.current", json!({"name": "Walk"})).unwrap();
free.execute("text", json!({"at": [0, 0], "height": 5, "text": "walk"})).unwrap();
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let font = f.base.join("in/walkinside.shx");
std::fs::write(&font, b"AutoCAD-86 shapes 1.0").unwrap();
age_access_time(&font);
let before = std::fs::metadata(&font).unwrap().accessed().unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
if f.sees_reads {
assert_ne!(std::fs::metadata(&font).unwrap().accessed().unwrap(), before, "the font was read");
}
}
/// One font that is a link leading out doesn't cost the drawing the other fonts beside it, and
/// nothing outside is touched.
#[test]
fn a_font_link_leading_out_does_not_cost_the_fonts_beside_it() {
let mut f = Fixture::new("font-mixed");
let host = f.base.join("in/host.dxf");
{
let mut free = Server::start(&[], &f.outside.join("cwd"), &f.outside.join("config"));
free.execute("new", json!({})).unwrap();
for (style, font) in [("Good", "walkgood.shx"), ("Bad", "walkbad.shx")] {
free.execute("style", json!({"name": style, "font": font})).unwrap();
free.execute("style.current", json!({"name": style})).unwrap();
free.execute("text", json!({"at": [0, 0], "height": 5, "text": style})).unwrap();
}
free.execute("saveas", json!({"path": s(&host)})).unwrap();
}
let good = f.base.join("in/walkgood.shx");
std::fs::write(&good, b"AutoCAD-86 shapes 1.0").unwrap();
age_access_time(&good);
let before = std::fs::metadata(&good).unwrap().accessed().unwrap();
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
std::fs::write(f.outside.join("walkbad.shx"), b"AutoCAD-86 shapes 1.0").unwrap();
std::os::unix::fs::symlink(f.outside.join("walkbad.shx"), f.base.join("in/walkbad.shx")).unwrap();
f.watch();
server.tool_ok("open", json!({"path": s(&host)}));
server.tool_ok("render", json!({}));
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
if f.sees_reads {
assert_ne!(std::fs::metadata(&good).unwrap().accessed().unwrap(), before, "the good font was read");
}
}
/// The fixture leaves the server's working directory in place, so a relative path meets the roots
/// and not a folder that has gone.
#[test]
fn a_relative_path_is_refused_by_the_roots() {
let mut f = Fixture::new("relative");
let roots = vec!["--automation-read-root".into(), s(&f.base.join("in")), "--automation-write-root".into(), s(&f.base.join("out"))];
let mut server = Server::start(&roots, &f.outside.join("cwd"), &f.outside.join("config"));
f.reset();
let reply = server.tool("open", json!({"path": "../canary.dxf"})).unwrap();
assert!(reply.contains("outside the read root"), "{reply}");
let touched = f.touched();
assert!(touched.is_empty(), "{touched:?}");
}
-2
View File
@@ -20,8 +20,6 @@ cadcraft-mcp = { workspace = true }
eframe = { workspace = true, features = ["clipboard", "wgpu", "accesskit", "wayland", "x11", "links", "persistence"] }
egui = { workspace = true }
serde_json = { workspace = true }
# The control request parser reads only its own keys (control_server.rs `Fields`).
serde = { workspace = true }
log = { workspace = true }
clap = { workspace = true }
thiserror = { workspace = true }
+15 -116
View File
@@ -221,17 +221,12 @@ fn read_bounded_line(reader: &mut impl BufRead, buf: &mut Vec<u8>, max: usize, h
}
}
/// Longest request `id` (it is copied into the reply).
const MAX_ID_BYTES: usize = 4096;
/// One request line, parsed.
enum Line<'a> {
enum Line {
Request {
id: Value,
method: String,
/// Left as text until the token is checked: decoding it first would let an unauthenticated
/// peer turn a flat array into many owned JSON values.
params: Option<&'a serde_json::value::RawValue>,
params: Value,
token: Option<String>,
},
Blank,
@@ -240,7 +235,7 @@ enum Line<'a> {
}
/// Parse a UTF-8 JSON request and its optional token, distinguishing blank lines from rejected input.
fn parse_line(bytes: &[u8]) -> Line<'_> {
fn parse_line(bytes: &[u8]) -> Line {
let Ok(text) = std::str::from_utf8(bytes) else {
return Line::Reject("not a control request (invalid UTF-8); closing the connection".into());
};
@@ -251,78 +246,22 @@ fn parse_line(bytes: &[u8]) -> Line<'_> {
if is_http_request_line(text) {
return Line::Reject("HTTP is not served here: this port takes JSON lines; closing the connection".into());
}
// Checked without building values; then only the object's own keys are read, each value kept as text.
if let Err(e) = serde_json::from_str::<&serde_json::value::RawValue>(text) {
return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection"));
}
let Ok(obj) = serde_json::from_str::<Fields<'_>>(text) else {
let msg = match serde_json::from_str::<Value>(text) {
Ok(v) => v,
Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
};
let Value::Object(mut obj) = msg else {
return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
};
// `method` and `token` are decoded as strings only (anything else is no string); `id` is echoed back
// in replies, so it is decoded but bounded.
let string = |v: Option<&serde_json::value::RawValue>| v.and_then(|r| serde_json::from_str::<String>(r.get()).ok());
let Some(method) = string(obj.method) else {
let Some(Value::String(method)) = obj.remove("method") else {
return Line::Reject("not a control request (missing string `method`); closing the connection".into());
};
let id = match obj.id {
None => Value::Null,
Some(r) if r.get().len() <= MAX_ID_BYTES => match serde_json::from_str(r.get()) {
Ok(v) => v,
Err(e) => return Line::Reject(format!("bad `id` ({e}); closing the connection")),
},
Some(_) => return Line::Reject(format!("`id` is longer than {MAX_ID_BYTES} bytes; closing the connection")),
};
Line::Request { id, method, params: obj.params, token: string(obj.token) }
}
/// The request object's own keys, each value kept as JSON text. Other keys are skipped without
/// being stored: collecting them (in a map) would let an unauthenticated peer turn a line of many
/// short distinct keys into many owned strings and map nodes. A repeated key takes the last value.
#[derive(Default)]
struct Fields<'a> {
id: Option<&'a serde_json::value::RawValue>,
method: Option<&'a serde_json::value::RawValue>,
params: Option<&'a serde_json::value::RawValue>,
token: Option<&'a serde_json::value::RawValue>,
}
impl<'de> serde::Deserialize<'de> for Fields<'de> {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
#[derive(serde::Deserialize)]
#[serde(field_identifier, rename_all = "lowercase")]
enum Key {
Id,
Method,
Params,
Token,
#[serde(other)]
Other,
}
struct Object;
impl<'de> serde::de::Visitor<'de> for Object {
type Value = Fields<'de>;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a JSON object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
let mut fields = Fields::default();
while let Some(key) = map.next_key::<Key>()? {
let slot = match key {
Key::Id => &mut fields.id,
Key::Method => &mut fields.method,
Key::Params => &mut fields.params,
Key::Token => &mut fields.token,
Key::Other => {
map.next_value::<serde::de::IgnoredAny>()?;
continue;
}
};
*slot = Some(map.next_value()?);
}
Ok(fields)
}
}
d.deserialize_map(Object)
// Moved out of the parsed object, not cloned: `params` can be most of the line.
Line::Request {
id: obj.remove("id").unwrap_or(Value::Null),
method,
params: obj.remove("params").unwrap_or(json!({})),
token: obj.remove("token").and_then(|t| if let Value::String(t) = t { Some(t) } else { None }),
}
}
@@ -366,16 +305,6 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
let _ = writeln!(out, "{r}");
break;
}
// Absent `params` is `{}`; ones that cannot be decoded (an unpaired surrogate escape) are an
// error, not a request run with defaults.
let params = match params.map(|r| serde_json::from_str::<Value>(r.get())) {
None => json!({}),
Some(Ok(v)) => v,
Some(Err(e)) => {
let _ = writeln!(out, "{}", json!({"ok": false, "error": format!("bad params ({e}); closing the connection"), "id": id}));
break;
}
};
let (req, pending) = ControlRequest::new(method, params);
let mut r = match tx.try_send(req) {
Ok(()) => {
@@ -443,36 +372,6 @@ mod tests {
assert_eq!(input.len(), 100 - 11, "the rest of the line is left unread");
}
/// The parameters stay text until the token is checked, and a request decodes as before.
#[test]
fn params_are_decoded_only_as_text_by_the_parser() {
let line = br#"{"id":7,"method":"m","token":"t","params":[1,2,{"a":[3]}],"extra":null}"#;
let Line::Request { id, method, params, token } = parse_line(line) else { panic!("a request") };
assert_eq!((id, method.as_str(), token.as_deref()), (json!(7), "m", Some("t")));
assert_eq!(params.map(|p| p.get()), Some(r#"[1,2,{"a":[3]}]"#));
assert!(matches!(parse_line(b"[1,2,3]"), Line::Reject(e) if e.contains("expected a JSON object")));
assert!(matches!(parse_line(b"{\"method\":"), Line::Reject(e) if e.contains("bad JSON")));
assert!(matches!(parse_line(br#"{"id":[1],"method":5}"#), Line::Reject(e) if e.contains("missing string `method`")));
let long_id = format!(r#"{{"id":"{}","method":"m"}}"#, "x".repeat(MAX_ID_BYTES));
assert!(matches!(parse_line(long_id.as_bytes()), Line::Reject(e) if e.contains("`id` is longer")));
assert!(matches!(parse_line(br#"{"id":"\ud800","method":"m"}"#), Line::Reject(e) if e.contains("bad `id`")));
assert!(matches!(parse_line(br#"{"id":1}"#), Line::Reject(e) if e.contains("missing string `method`")));
}
/// Keys other than the request's own are skipped, not kept, however many there are; a repeated
/// key still takes the last value, and an escaped key name is the same key.
#[test]
fn unknown_keys_are_skipped_and_the_last_repeated_key_wins() {
let mut line = String::from(r#"{"method":"first","#);
for i in 0..100_000 {
line.push_str(&format!(r#""k{i}":{i},"#));
}
line.push_str(r#""method":"m","params":{"a":1},"params":[2],"token":"t"}"#);
let Line::Request { id, method, params, token } = parse_line(line.as_bytes()) else { panic!("a request") };
assert_eq!((id, method.as_str(), token.as_deref()), (Value::Null, "m", Some("t")));
assert_eq!(params.map(|p| p.get()), Some("[2]"));
}
fn held() -> Held {
Held::new(Budget::new(usize::MAX))
}
-8
View File
@@ -134,7 +134,6 @@ fn run_recover(s: &mut Session, p: &Value) -> Result<Value> {
Ok(r)
}
/// Write the report to the `.adt` file beside the saved drawing, held to the automation roots.
#[cfg(not(target_arch = "wasm32"))]
fn write_audit_log(s: &Session, report: &crate::audit::Report) {
let (path_str, title) = match s.state() {
@@ -144,10 +143,6 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
// An unsaved drawing has no folder of its own to hold the log.
let Some(path) = &path_str else { return };
let adt_path = std::path::PathBuf::from(path).with_extension("adt");
if let Err(e) = crate::file_access::check_write(&adt_path) {
log::warn!("AUDITCTL: not writing audit log {}: {e}", adt_path.display());
return;
}
let content = report.format_adt(&title, path_str.as_deref());
// Write through an exclusively-created temporary and rename over the companion path, so a
// planted `.adt` symlink beside the drawing cannot redirect the report onto another file
@@ -161,13 +156,10 @@ fn write_audit_log(s: &Session, report: &crate::audit::Report) {
fn write_audit_log(_: &Session, _: &crate::audit::Report) {}
#[cfg(not(target_arch = "wasm32"))]
/// The bytes of the file at `path`, once the automation roots allow reading it.
fn read_path(cmd: &str, path: &str) -> Result<Vec<u8>> {
crate::file_access::check_read(path).map_err(|e| bad(cmd, e))?;
crate::capped_read::read_capped(std::path::Path::new(path), file::MAX_DRAWING_BYTES).map_err(|e| bad(cmd, format!("{path}: {e}")))
}
/// The bytes of the drawing at `path`, held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_path(cmd: &str, _path: &str) -> Result<Vec<u8>> {
Err(bad(cmd, "paths are not available on the web; pass `data`"))
-2
View File
@@ -260,11 +260,9 @@ fn csv(columns: &[String], rows: &[Vec<Cell>], sep: char) -> String {
out
}
/// Write the extracted table to `path`, held to the automation roots.
fn write_file(path: &str, text: &str) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(EngineError::Other)?;
std::fs::write(path, text).map_err(|e| EngineError::Other(format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
@@ -88,11 +88,9 @@ pub(super) fn read_drawing(path: &str) -> Result<Drawing> {
Err(last.unwrap_or_else(|| bad("insert", format!("{path}: file not found"))))
}
/// The bytes of the drawing to insert, held to the automation roots.
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("insert", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("insert", format!("{_path}: {e}")))
}
-25
View File
@@ -70,8 +70,6 @@ fn stamp(path: &str) -> Option<(u64, Option<SystemTime>)> {
/// A library drawing, read once and kept while the file is as it was: placing a block must not
/// parse the whole file again.
fn cached_drawing(path: &str) -> Result<Arc<Drawing>> {
// Before the cache too: a drawing read earlier must not be handed out past the roots.
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
// The reader sniffs the bytes, so a DXF named `part.bin` would load: the contract is DWG/DXF by name.
if !is_drawing(Path::new(path)) {
return Err(bad("blocklibrary", format!("{path}: expected a DWG or DXF file")));
@@ -188,9 +186,6 @@ pub fn read_library_file(path: &str) -> Result<Arc<Drawing>> {
/// What BLOCKLIBRARY answers for `path`. It needs no session, so the palette reads big drawings
/// and slow folders on a worker thread.
pub fn list_library(path: &str) -> Result<Value> {
// Before anything looks at the path: a folder's listing, or whether it is one, says what is
// outside the automation roots.
crate::file_access::check_read(path).map_err(|e| bad("blocklibrary", e))?;
if is_folder(path) {
let (files, truncated) = folder_files(Path::new(path))?;
let list: Vec<Value> = files.iter().map(|(name, file)| json!({ "name": name, "file": file })).collect();
@@ -361,26 +356,6 @@ fn run_libraries(_s: &mut Session, p: &Value) -> Result<Value> {
mod tests {
use super::*;
/// Under the automation roots a library folder or file outside them is refused before it is
/// listed or read.
#[test]
fn the_automation_roots_hold_library_paths() {
let base = std::env::temp_dir().join(format!("cadcraft-library-roots-{}", std::process::id()));
let (inside, outside) = (base.join("in"), base.join("outside"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
std::fs::write(outside.join("parts.dxf"), b"0\nEOF\n").unwrap();
let roots = crate::file_access::AutomationRoots::new(Some(&inside), None).unwrap();
crate::file_access::confine(roots.as_ref(), || {
let folder = list_library(&outside.to_string_lossy()).map(|v| v.to_string());
assert!(folder.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{folder:?}");
let file = list_library(&outside.join("parts.dxf").to_string_lossy()).map(|v| v.to_string());
assert!(file.as_ref().is_err_and(|e| e.to_string().contains("automation")), "{file:?}");
assert!(list_library(&inside.to_string_lossy()).is_ok());
});
let _ = std::fs::remove_dir_all(&base);
}
/// A list that could not be written stays the list of this session, whatever the file says.
#[test]
fn a_failed_write_keeps_the_list_in_memory() {
+1 -5
View File
@@ -105,8 +105,6 @@ fn write(s: &Session, cmd: &str, path: &str, what: Source) -> Result<(usize, usi
let bytes = (hooks.write)(&d, path).map_err(|e| bad(cmd, e))?;
// Through a temporary file, as SAVE writes, so a failed write keeps the file it replaces.
#[cfg(not(target_arch = "wasm32"))]
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
#[cfg(not(target_arch = "wasm32"))]
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
let lost = if drops_unknown(path) { not_saved(&d) } else { BTreeMap::new() };
Ok((d.model.len(), bytes.len(), lost))
@@ -172,9 +170,7 @@ fn output_path(typed: &str) -> String {
fn exists(path: &str) -> bool {
#[cfg(not(target_arch = "wasm32"))]
{
// Outside the automation roots the answer would say whether a file is there; the write
// that follows is refused anyway.
crate::file_access::check_write(path).is_ok() && std::path::Path::new(path).exists()
std::path::Path::new(path).exists()
}
#[cfg(target_arch = "wasm32")]
{
-4
View File
@@ -408,7 +408,6 @@ fn run_xbind(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "bound": bound }))
}
/// Open the file a selected reference points at, as its own drawing.
fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
let d = s.doc()?;
let name = match str_param(p, "name") {
@@ -430,9 +429,6 @@ fn run_xopen(s: &mut Session, p: &Value) -> Result<Value> {
let file = load::find(&path, host.as_deref().map(std::path::Path::new), false).map_err(|m| match m {
load::Missing::NotFound => bad("xopen", format!("{path}: file not found")),
load::Missing::Refused(r) => bad("xopen", format!("{path}: not opened, {r}")),
load::Missing::OutsideRoots => {
bad("xopen", format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
}
})?;
s.execute("open", &json!({ "path": file.to_string_lossy() }))
}
+17 -98
View File
@@ -145,12 +145,9 @@ pub(crate) enum Missing {
NotFound,
/// The saved path isn't followed, and there is no file of its name beside the host.
Refused(Refused),
/// The automation roots don't reach the file ([`crate::file_access`]).
OutsideRoots,
}
impl Missing {
/// The status and message a reference gets when its file can't be loaded.
fn outcome(self, path: &str) -> (XrefStatus, String) {
match self {
Self::NotFound => {
@@ -158,9 +155,6 @@ impl Missing {
(XrefStatus::NotFound, format!("{path}: {why}"))
}
Self::Refused(r) => (XrefStatus::Unresolved, format!("{path}: not opened, {r}")),
Self::OutsideRoots => {
(XrefStatus::Unresolved, format!("{path}: not opened, automation path rejected: outside the read root (or the write root)"))
}
}
}
}
@@ -214,36 +208,14 @@ pub(crate) fn find(path: &str, host: Option<&Path>, chosen: bool) -> Result<Path
return Err(Missing::NotFound);
}
let (files, refused) = candidates(path, host, chosen);
// Outside the automation roots a place isn't even looked at, so the answer can't tell whether a
// file is there. A match found by ignoring case is checked again: it can be a link leading out.
let allowed = |p: &PathBuf| crate::file_access::check_read(p).is_ok();
let looked_for = files.len();
let files: Vec<PathBuf> = files.into_iter().filter(allowed).collect();
let outside = files.len() < looked_for;
// A match found by ignoring case that the roots refuse counts as outside them too.
#[cfg(not(target_arch = "wasm32"))]
let mut refused_match = false;
#[cfg(not(target_arch = "wasm32"))]
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| {
files.iter().find_map(|p| {
let c = match case_insensitive(p) {
Ok(Some(c)) => c,
Ok(None) => return None,
Err(()) => {
refused_match = true;
return None;
}
};
let ok = allowed(&c);
refused_match |= !ok;
ok.then_some(c)
})
});
#[cfg(not(target_arch = "wasm32"))]
let outside = outside || refused_match;
let found = files.iter().find(|p| p.is_file()).cloned().or_else(|| files.iter().find_map(|p| case_insensitive(p)));
#[cfg(target_arch = "wasm32")]
let found: Option<PathBuf> = None;
found.ok_or(if outside { Missing::OutsideRoots } else { refused.map_or(Missing::NotFound, Missing::Refused) })
let found: Option<PathBuf> = {
let _ = files;
None
};
found.ok_or(refused.map_or(Missing::NotFound, Missing::Refused))
}
/// Upper bound on directory entries scanned per path component by [`case_insensitive`].
@@ -253,16 +225,10 @@ const MAX_CASE_SCAN: usize = 10_000;
/// The existing file `p` names when its letters' case is ignored, on file systems that don't
/// ignore it themselves. Drawings made on Windows often store a reference as `PLAN.DWG` for
/// `Plan.dwg`; Windows finds it, and so should Linux. Each missing component is matched against
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing. `Err` when
/// the automation roots refuse a place it would have to look in.
/// its folder's entries; an exact match always wins, and an ambiguous one finds nothing.
#[cfg(not(target_arch = "wasm32"))]
fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
fn case_insensitive(p: &Path) -> Option<PathBuf> {
use std::path::Component;
// Under the automation roots a place is probed only when the roots allow it, or when it lies on
// the way to `p` as it was spelled (which was checked): a name corrected to another case could be
// a link leading out, and looking inside it would look outside the roots.
let mut corrected = false;
let probe = |q: &Path, corrected: bool| (!corrected && p.starts_with(q)) || crate::file_access::check_read(q).is_ok();
let mut out = PathBuf::new();
for c in p.components() {
let Component::Normal(name) = c else {
@@ -270,27 +236,23 @@ fn case_insensitive(p: &Path) -> Result<Option<PathBuf>, ()> {
continue;
};
let exact = out.join(name);
if !probe(&exact, corrected) {
return Err(());
}
if exact.exists() {
out = exact;
continue;
}
let Some(want) = name.to_str().map(str::to_lowercase) else { return Ok(None) };
let Ok(entries) = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out }) else { return Ok(None) };
let mut hits = entries.take(MAX_CASE_SCAN).flatten().filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
let Some(hit) = hits.next() else { return Ok(None) };
let want = name.to_str()?.to_lowercase();
let mut hits = std::fs::read_dir(if out.as_os_str().is_empty() { Path::new(".") } else { &out })
.ok()?
.take(MAX_CASE_SCAN)
.flatten()
.filter(|e| e.file_name().to_str().is_some_and(|n| n.to_lowercase() == want));
let hit = hits.next()?;
if hits.next().is_some() {
return Ok(None);
return None;
}
out.push(hit.file_name());
corrected = true;
if !probe(&out, corrected) {
return Err(());
}
}
Ok(out.is_file().then_some(out))
out.is_file().then_some(out)
}
/// Read a drawing file through the host's io hooks, counting its bytes against the load's total.
@@ -299,7 +261,6 @@ fn read(file: &Path, cx: &mut Ctx) -> Result<Drawing, String> {
#[cfg(not(target_arch = "wasm32"))]
{
use std::io::Read;
crate::file_access::check_read(file)?;
let left = MAX_XREF_TOTAL_BYTES.saturating_sub(cx.bytes);
let limit = MAX_XREF_BYTES.min(left);
let mut f = std::fs::File::open(file).map_err(|e| e.to_string())?;
@@ -642,48 +603,6 @@ mod tests {
assert_eq!(find("", Some(&host), false), Err(Missing::NotFound));
}
/// A name corrected to another case is checked against the roots before it is looked inside, and a
/// match they refuse leaves the other candidates to be tried.
#[cfg(unix)]
#[test]
fn a_name_corrected_to_a_link_out_of_the_roots_is_not_looked_inside() {
use crate::file_access::{AutomationRoots, confine};
let base = std::env::temp_dir().join(format!("cc-xref-case-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
for d in ["in/sub", "outside"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
std::fs::write(base.join("outside/target.dxf"), "x").unwrap();
std::fs::write(base.join("in/Mixed.dxf"), "x").unwrap();
std::os::unix::fs::symlink(base.join("outside"), base.join("in/Alias")).unwrap();
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/sub/Mixed.dxf")).unwrap();
if base.join("in/alias").exists() {
// A case-insensitive file system never needs a name corrected: nothing to test.
eprintln!("skipped: this file system ignores case");
std::fs::remove_dir_all(&base).unwrap();
return;
}
let roots = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
confine(Some(&roots), || {
// `alias` isn't there but `Alias` is, a link out: the probe stops before looking in it.
assert_eq!(case_insensitive(&base.join("in/alias/target.dxf")), Err(()));
// A match that leaves the roots doesn't end the search: the next candidate is tried.
let host = base.join("in/host.dxf");
let found = find("sub/mixed.dxf", Some(&host), true).unwrap();
assert_eq!(found, base.join("in/Mixed.dxf"));
// With no other candidate it is still a refusal by the roots, not a missing file.
std::fs::create_dir_all(base.join("in/lone")).unwrap();
std::os::unix::fs::symlink(base.join("outside/target.dxf"), base.join("in/lone/Only.dxf")).unwrap();
assert_eq!(find("lone/only.dxf", Some(&host), true), Err(Missing::OutsideRoots));
});
assert_eq!(
case_insensitive(&base.join("in/alias/target.dxf")),
Ok(Some(base.join("in/Alias/target.dxf"))),
"without roots the link is followed"
);
std::fs::remove_dir_all(&base).unwrap();
}
#[test]
fn prefixes_ignore_case() {
assert!(has_prefix("SITE|Walls", "site|"));
+11 -1
View File
@@ -564,7 +564,17 @@ pub fn seg_param(s: &Segment, p: Vec2) -> f64 {
match s {
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
Segment::Arc { arc, ccw } => {
let t = (cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15)).clamp(0.0, 1.0);
// A point just outside the sweep (on the arc within tolerance of an end) goes to the
// nearer end: a hair before the start is the start, not round the circle to the end.
let a = cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start);
let sweep = arc.sweep().max(1e-15);
let t = if a <= sweep {
a / sweep
} else if a - sweep < TAU - a {
1.0
} else {
0.0
};
if *ccw { t } else { 1.0 - t }
}
}
+19
View File
@@ -601,6 +601,25 @@ fn measure_spline_by_its_own_parameter() {
assert!(pts.len() == 3 && [7.0, 4.0, 1.0].iter().all(|x| pts.iter().any(|p| near(*p, *x, 0.0))), "{pts:?}");
}
/// A pick a hair outside an arc's sweep beside its start is at its start, for an arc and for a
/// polyline's arc span alike: MEASURE runs from there (round the circle it was the far end).
#[test]
fn measure_from_a_pick_a_hair_before_an_arcs_start() {
let curves = [
("arc", json!({"center": [0, 0], "radius": 1, "start": 0, "end": 180})),
("pline", json!({"vertices": [{"p": [1, 0], "bulge": 1}, [-1, 0]]})),
];
for (cmd, args) in curves {
let mut s = Session::new();
let e = h(&s.execute(cmd, &args).unwrap());
s.execute("measure", &json!({"handle": e, "length": 1, "from": [1, -1e-13]})).unwrap();
let pts: Vec<Vec2> =
s.doc().unwrap().model.iter().filter_map(|e| if let EntityKind::Point(p) = &e.kind { Some(p.p.xy()) } else { None }).collect();
// From (1, 0), a point every radian.
assert!(pts.len() == 3 && [1.0f64, 2.0, 3.0].iter().all(|a| pts.iter().any(|p| near(*p, a.cos(), a.sin()))), "{cmd}: {pts:?}");
}
}
/// MEASURE counts every vertex in a polyline's parameter, coincident ones too (AutoCAD's polyline
/// parameter is the vertex index; the chain drops zero-length spans), and picks an ellipse's end
/// by the ellipse parameter like any other curve: AutoCAD 2024 runs both measured cases below from
-3
View File
@@ -82,7 +82,6 @@ fn write_file(cmd: &str, path: &str, bytes: &[u8]) -> Result<()> {
{
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the export write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
@@ -202,11 +201,9 @@ fn import_drawing(s: &mut Session, src: &Drawing, at: Vec2, scale: f64, file: &s
}))
}
/// The bytes of the file to import, held to the automation roots.
fn read_file(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("import", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), crate::cmd::file::MAX_DRAWING_BYTES)
.map_err(|e| bad("import", format!("{_path}: {e}")))
}
+2 -33
View File
@@ -240,7 +240,6 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
let path = _path;
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(path).map_err(|e| bad("script", e))?;
let bytes =
crate::capped_read::read_capped(std::path::Path::new(path), MAX_SCRIPT_BYTES).map_err(|e| bad("script", format!("{path}: {e}")))?;
String::from_utf8_lossy(&bytes).into_owned()
@@ -321,7 +320,6 @@ pub fn read_file(path: &std::path::Path) -> std::result::Result<ReadFile, String
let Some(text_path) = path.to_str() else {
return Err(bad("open", format!("{shown}: the file name is not valid Unicode, so CADCraft can't save back to it")));
};
crate::file_access::check_read(text_path).map_err(|e| bad("open", e))?;
let bytes = crate::capped_read::read_capped(path, MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{shown}: {e}")))?;
read_bytes(&bytes, text_path, Some(text_path.to_string()))
});
@@ -346,7 +344,6 @@ pub fn finish_open(s: &mut Session, f: ReadFile) -> Result<Value> {
Ok(opened(s, i, true))
}
/// Parse a drawing's bytes, and search its folder for fonts where the automation roots allow.
fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile> {
let hooks = io().ok_or_else(|| bad("open", "file formats are not available in this build"))?;
let drawing = (hooks.read)(bytes, name).map_err(|e| bad("open", e))?;
@@ -357,17 +354,7 @@ fn read_bytes(bytes: &[u8], name: &str, path: Option<String>) -> Result<ReadFile
if let Some(dir) = path.as_deref().and_then(|p| std::path::Path::new(p).parent()) {
// A bare file name is in the current folder.
let dir = if dir.as_os_str().is_empty() { std::path::Path::new(".") } else { dir };
let dir = std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf());
match crate::file_access::current() {
None => cadcraft_fonts::shx::add_drawing_dir(&dir),
// The folder holds no record of the roots, and a font's name there can be a link leading
// out of them: the search asks the roots about each file before it opens one.
Some(roots) => {
let owner = format!("{:?}|{:?}", roots.read_root(), roots.write_root());
let guard = std::sync::Arc::new(move |font: &std::path::Path| roots.check(font, crate::file_access::Access::Read).is_ok());
cadcraft_fonts::shx::add_drawing_dir_guarded(&dir, &owner, guard);
}
}
cadcraft_fonts::shx::add_drawing_dir(&std::path::absolute(dir).unwrap_or_else(|_| dir.to_path_buf()));
}
Ok(ReadFile { drawing, binary_dxf: craft_dxf::is_binary(bytes), name: name.to_string(), path })
}
@@ -410,7 +397,6 @@ fn run_open(s: &mut Session, p: &Value) -> Result<Value> {
let path = _path;
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(path).map_err(|e| bad("open", e))?;
let bytes =
crate::capped_read::read_capped(std::path::Path::new(path), MAX_DRAWING_BYTES).map_err(|e| bad("open", format!("{path}: {e}")))?;
let i = open_bytes(s, &bytes, path, Some(path.to_string()))?;
@@ -496,7 +482,6 @@ fn save_as(s: &mut Session, cmd: &str, path: &str, opts: &SaveAs) -> Result<usiz
fn store(path: &str, bytes: &[u8]) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(|e| bad("save", e))?;
// A file in a folder still to be made has nothing to back up.
if is_drawing_file(path) && crate::autosave::isavebak() && crate::atomic_write::missing_folder(std::path::Path::new(path)).is_none() {
backup(std::path::Path::new(path))
@@ -706,9 +691,7 @@ fn backup(path: &std::path::Path) -> std::io::Result<()> {
};
let (head, tail, len) = ends(&mut src)?;
let bak = backup_path(path);
// Whether the .bak name is taken is asked without following a link there: a link leading out of
// the roots (or to another computer) isn't looked at.
if !backup_replaced(&head, &tail, len, std::fs::symlink_metadata(&bak).is_ok()) {
if !backup_replaced(&head, &tail, len, bak.exists()) {
log::warn!("save: {} doesn't look like a whole drawing; its backup is left as it was", path.display());
return Ok(());
}
@@ -1072,20 +1055,6 @@ mod tests {
use crate::Session;
use crate::temp_dir::TempDir;
/// Whether the `.bak` name is taken is asked without following a link there: a dangling link
/// counts as taken, so a file that doesn't look like a drawing leaves it alone.
#[cfg(unix)]
#[test]
fn a_link_at_the_bak_name_counts_as_a_backup_without_being_followed() {
let dir = TempDir::new("cc-bak-link");
let path = dir.join("plain.dxf");
std::fs::write(&path, "just some text, not a drawing").unwrap();
let bak = super::backup_path(&path);
std::os::unix::fs::symlink(dir.join("nowhere"), &bak).unwrap();
super::backup(&path).unwrap();
assert!(std::fs::symlink_metadata(&bak).unwrap().file_type().is_symlink(), "the link is left as it was");
}
/// A backup is never more open than the drawing or the old `.bak`, and loses the group bits when
/// it would keep the old `.bak`'s group while the drawing is in another.
#[cfg(unix)]
-2
View File
@@ -107,11 +107,9 @@ fn other_drawing(s: &Session, p: &Value) -> Result<(Arc<Drawing>, String)> {
Ok((Arc::new(d), name))
}
/// The bytes of the drawing to compare with, held to the automation roots.
fn read_path(_path: &str) -> Result<Vec<u8>> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad("compare", e))?;
crate::capped_read::read_capped(std::path::Path::new(_path), super::MAX_DRAWING_BYTES).map_err(|e| bad("compare", format!("{_path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+6 -6
View File
@@ -128,8 +128,8 @@ pub fn alias_name(a: &str) -> std::result::Result<String, String> {
}
/// The aliases of a `.pgp` file's text, and its problems.
fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
let mut out = BTreeMap::new();
fn parse(text: &str) -> (Vec<(String, String)>, Vec<String>) {
let mut out: Vec<(String, String)> = Vec::new();
let mut warnings = Vec::new();
let mut warn = |no: usize, msg: String| {
if warnings.len() < MAX_WARNINGS {
@@ -165,13 +165,13 @@ fn parse(text: &str) -> (BTreeMap<String, String>, Vec<String>) {
warn(no, format!("{}: unknown command {}; skipped", alias.trim(), target.trim()));
continue;
};
// Once full, stop at the next valid definition, even if it repeats an alias.
if out.len() >= MAX_ALIASES {
warn(no, format!("more than {MAX_ALIASES} aliases; the rest are skipped"));
break;
}
// A later definition wins without scanning all the aliases accumulated so far.
out.insert(name, id);
// A later line for the same alias wins, as it would when typed into the file twice.
out.retain(|(a, _)| *a != name);
out.push((name, id));
}
(out, warnings)
}
@@ -185,7 +185,7 @@ fn listing(warnings: &[String], added: usize) -> Value {
fn load(text: &str, path: Option<String>) -> (usize, Vec<String>) {
let (aliases, warnings) = parse(text);
let mut st = store();
st.map = aliases;
st.map = aliases.into_iter().collect();
if path.is_some() {
st.file = path;
}
-3
View File
@@ -73,13 +73,10 @@ fn read_template(path: &str) -> Result<Drawing> {
}
#[cfg(not(target_arch = "wasm32"))]
/// The bytes of the template at `path`, once the automation roots allow reading it.
fn read_bytes(path: &str) -> Result<Vec<u8>> {
crate::file_access::check_read(path).map_err(|e| bad("new", e))?;
crate::capped_read::read_capped(std::path::Path::new(path), super::MAX_DRAWING_BYTES).map_err(|e| bad("new", format!("template {path}: {e}")))
}
/// The bytes of the template at `path`, held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_bytes(path: &str) -> Result<Vec<u8>> {
Err(bad("new", format!("template {path}: paths are not available on the web")))
-3
View File
@@ -115,10 +115,8 @@ pub fn support_text(cmd: &str, p: &serde_json::Value, path_key: &str, text_key:
}
#[cfg(not(target_arch = "wasm32"))]
/// The text of the support file at `path`, once the automation roots allow reading it, up to the size limit.
fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
use std::io::Read;
crate::file_access::check_read(path).map_err(|e| super::bad(cmd, e))?;
let f = std::fs::File::open(path).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
let mut bytes = Vec::new();
f.take(MAX_SUPPORT_FILE_BYTES + 1).read_to_end(&mut bytes).map_err(|e| super::bad(cmd, format!("{path}: {e}")))?;
@@ -128,7 +126,6 @@ fn read_support_file(cmd: &str, path: &str) -> crate::Result<String> {
Ok(String::from_utf8_lossy(&bytes).into_owned())
}
/// The text of a support file (a linetype or hatch pattern file, say), size-limited and held to the automation roots.
#[cfg(target_arch = "wasm32")]
fn read_support_file(cmd: &str, _path: &str) -> crate::Result<String> {
Err(super::bad(cmd, "paths are not available on the web; pass the file's contents"))
+7 -12
View File
@@ -75,7 +75,6 @@ fn read_file(path: &str, host: Option<&str>) -> std::result::Result<Vec<u8>, Str
#[cfg(not(target_arch = "wasm32"))]
{
let file = super::blocks::xref::find_file(path, host).ok_or("file not found")?;
crate::file_access::check_read(&file)?;
let len = std::fs::metadata(&file).map_err(|e| e.to_string())?.len();
if len > MAX_IMAGE_BYTES {
return Err(format!("the file is larger than {} MB", MAX_IMAGE_BYTES >> 20));
@@ -181,18 +180,14 @@ fn decode_files(paths: &[&str], host: Option<&str>) -> Vec<std::result::Result<R
if loaders > 1 {
// Each loader takes the next file nobody has started.
let next = AtomicUsize::new(0);
// The automation roots are per thread, so they go along with each loader.
let roots = crate::file_access::current();
let work = || {
crate::file_access::confine(roots.as_ref(), || {
let mut done = Vec::new();
loop {
let index = next.fetch_add(1, Ordering::Relaxed);
let Some(path) = paths.get(index) else { break };
done.push((index, load(path)));
}
done
})
let mut done = Vec::new();
loop {
let index = next.fetch_add(1, Ordering::Relaxed);
let Some(path) = paths.get(index) else { break };
done.push((index, load(path)));
}
done
};
let finished: Vec<_> = std::thread::scope(|scope| {
let started: Vec<_> = (0..loaders).filter_map(|_| std::thread::Builder::new().spawn_scoped(scope, work).ok()).collect();
-1
View File
@@ -864,7 +864,6 @@ fn run_plot(s: &mut Session, p: &Value, cmd: &str) -> Result<Value> {
let path = _path;
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the plot write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad(cmd, e))?;
let folder = super::file::new_folder(path);
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), &bytes).map_err(|e| bad(cmd, format!("{path}: {e}")))?;
let mut r = json!({ "path": path, "bytes": bytes.len(), "layout": layout, "pages": pages, "format": format });
@@ -187,7 +187,6 @@ fn edit_style(cmd: &str, st: &mut PlotStyle, v: &Value) -> Result<()> {
Ok(())
}
/// List, read, change, load and export plot style tables; any file is held to the automation roots.
fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "stylesmanager";
let action = str_param(p, "action").unwrap_or("list").to_ascii_lowercase();
@@ -304,7 +303,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
(None, Some(_path)) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(_path).map_err(|e| bad(cmd, e))?;
let bytes = crate::capped_read::read_capped(std::path::Path::new(_path), cadcraft_doc::MAX_TABLE_FILE)
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
String::from_utf8(bytes).map_err(|e| bad(cmd, format!("{_path}: {e}")))?
@@ -333,7 +331,6 @@ fn run_stylesmanager(s: &mut Session, p: &Value) -> Result<Value> {
Some(_path) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
crate::atomic_write::write_atomic(std::path::Path::new(_path), text.as_bytes())
.map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
Ok(json!({ "name": name, "path": _path, "bytes": text.len() }))
-1
View File
@@ -145,7 +145,6 @@ fn store(path: &str, bytes: &[u8]) -> Result<()> {
{
// Exclusively create a fresh temporary file and rename it into place so a planted
// `<path>.cadcraft-tmp` symlink cannot redirect the write (CWE-59).
crate::file_access::check_write(path).map_err(|e| bad("layout.saveas", e))?;
crate::atomic_write::write_atomic_making_folders(std::path::Path::new(path), bytes).map_err(|e| bad("layout.saveas", format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+20 -7
View File
@@ -26,7 +26,7 @@ mod stretch;
mod transform;
mod trim;
use break_join::{BreakM, run_break, run_breakat, run_join};
use break_join::{BreakAtPointM, BreakM, run_break, run_breakat, run_join};
use explode::run_explode;
pub(crate) use explode::{explode_kind, explode_with};
use fillet::{FilletM, run_chamfer, run_fillet};
@@ -37,7 +37,7 @@ use select_then::{DisplaceM, Op, SelectThen};
use stretch::{StretchM, run_stretch};
pub(crate) use transform::{holds_ole_frame, ole_refusal, refuse_ole_frames, transform_entities};
use transform::{run_copy, run_erase, run_mirror, run_move, run_rotate, run_scale};
pub(crate) use trim::{Edges, extend, trim};
pub(crate) use trim::{CUT_ONCE, Edges, extend, json_pick_error, trim};
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -85,14 +85,24 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("trim", "Trim", trimextend::run_trim)
.menu(&["Modify", "Trim"])
.alias(&["tr"])
.params(
"{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\"} → {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing)",
)
.params(concat!(
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; edges?: [hex] (default: every object; a polyline that is one of them, or every object in Standard mode, also cuts itself at its vertices and crossings), edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\" ",
"→ {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing). ",
"For handle+pick: handle is the object to trim; pick selects the portion of that object to remove ",
"(normally a point on it, away from a cutting intersection); edges are the cutting edges. The JSON default is standard mode."
))
.interactive(|_| Ok(Box::new(TrimM::new(false)))),
CommandSpec::new("extend", "Extend", trimextend::run_extend)
.menu(&["Modify", "Extend"])
.alias(&["ex"])
.params("{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\"}")
.params(concat!(
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; ",
"edges?: [hex], edgeMode?: \"extend\"|\"none\". ",
"For handle+pick: handle is the object to extend; pick points toward the boundary to extend to ",
"(normally a point on that boundary), selecting the nearer end of the object ",
"(of an open polyline, the end on the pick's side of its middle parameter); ",
"edges are the boundary edges, and the nearest forward intersection is used."
))
.interactive(|_| Ok(Box::new(TrimM::new(true)))),
CommandSpec::new("fillet", "Fillet", run_fillet)
.menu(&["Modify", "Fillet"])
@@ -114,7 +124,10 @@ pub fn specs() -> Vec<CommandSpec> {
.alias(&["br"])
.params("{handle, p1, p2} → {handles: the object (kept, reshaped) then the new pieces; none when nothing is left}")
.interactive(|_| Ok(Box::new(BreakM::default()))),
CommandSpec::new("breakatpoint", "Break At Point", run_breakat).menu(&["Modify", "Break At Point"]).params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}"),
CommandSpec::new("breakatpoint", "Break At Point", run_breakat)
.menu(&["Modify", "Break At Point"])
.params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}")
.interactive(|_| Ok(Box::new(BreakAtPointM::default()))),
CommandSpec::new("join", "Join", run_join)
.menu(&["Modify", "Join"])
.alias(&["j"])
+95 -34
View File
@@ -4,16 +4,6 @@ use super::{
Value, Vec2, arc, bad, json, lwpoly, norm_angle, point_param, point_req, targets,
};
/// Gives a rebuilt arc piece its source centre Z, or a rebuilt polyline piece its source elevation.
fn with_z(mut k: EntityKind, z: f64) -> EntityKind {
match &mut k {
EntityKind::Arc(a) => a.center.z = z,
EntityKind::LwPolyline(p) => p.elevation = z,
_ => {}
}
k
}
/// Break `h` between two points (or at one point when p1 == p2).
pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Vec<Handle>> {
if crate::cmd::curves::is_locked(s, h) {
@@ -39,12 +29,12 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
}
EntityKind::Circle(c) => {
if p1.near(p2, 1e-12) {
return Err(EngineError::Other("Arc cannot be full 360 degrees.".into()));
return Err(EngineError::Other("Arc cannot be full 360 degrees".into()));
}
let a1 = c.center.xy().angle_to(p1);
let a2 = c.center.xy().angle_to(p2);
// AutoCAD removes the CCW portion from the first to the second point.
vec![with_z(arc(&Arc::new(c.center.xy(), c.radius, a2, a1)), c.center.z)]
vec![arc(&Arc::new(c.center.xy(), c.radius, a2, a1))]
}
EntityKind::Arc(a) => {
let ga = Arc::new(a.center.xy(), a.radius, a.start, a.end);
@@ -55,10 +45,10 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
}
let mut v = Vec::new();
if t1 > 1e-12 {
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)), a.center.z));
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)));
}
if t2 < ga.sweep() - 1e-12 {
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)), a.center.z));
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)));
}
v
}
@@ -81,24 +71,32 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
};
let (mut t1, mut t2) = (lp(p1), lp(p2));
if p.closed {
if (t1 - t2).abs() < 1e-9 {
return Err(EngineError::Other("Cannot break a closed polyline at a single point.".into()));
let (lo, hi) = if t1 <= t2 { (t1, t2) } else { (t2, t1) };
let tol = 1e-9 * (1.0 + total);
if hi - lo < tol {
// One point: the outline opens at its start vertex and splits at the point;
// at the start vertex itself it stays whole and closed.
if lo < tol || lo > total - tol {
return Ok(vec![h]);
}
vec![lwpoly(sub_polyline(&segs, 0.0, lo), false), lwpoly(sub_polyline(&segs, lo, total), false)]
} else {
// The stretch between the points that doesn't run through the start vertex
// goes, whichever point came first; what is left runs from the later point
// round through the start vertex to the earlier one.
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
vec![lwpoly(sub_polyline(&doubled, hi, lo + total), false)]
}
// Like a circle: the stretch from the first point to the second, along the
// vertices, goes; what is left runs from the second point round to the first.
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
let end = if t1 > t2 { t1 } else { t1 + total };
vec![with_z(lwpoly(sub_polyline(&doubled, t2, end), false), p.elevation)]
} else {
if t1 > t2 {
std::mem::swap(&mut t1, &mut t2);
}
let mut v = Vec::new();
if t1 > 1e-12 {
v.push(with_z(lwpoly(sub_polyline(&segs, 0.0, t1), false), p.elevation));
v.push(lwpoly(sub_polyline(&segs, 0.0, t1), false));
}
if t2 < total - 1e-12 {
v.push(with_z(lwpoly(sub_polyline(&segs, t2, total), false), p.elevation));
v.push(lwpoly(sub_polyline(&segs, t2, total), false));
}
v
}
@@ -215,6 +213,41 @@ pub(super) fn run_join(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "handle": r.map(|h| h.hex()) }))
}
/// The object picked at `p` for BREAK and BREAKATPOINT ("*Invalid selection*" when there is none).
/// One on a locked layer is refused there, and the command asks for an object again, as AutoCAD
/// 2024 does; the pick doesn't fall through to an object under it.
fn pick_to_break(s: &mut Session, p: Vec2) -> Result<Option<Handle>> {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
match s.pick_object(&space, p, ap)? {
Some(h) if crate::cmd::curves::is_locked(s, h) => {
s.echo("The object is on a locked layer.");
Ok(None)
}
Some(h) => {
s.set_selection(vec![h]);
Ok(Some(h))
}
None => {
s.echo("*Invalid selection*");
Ok(None)
}
}
}
/// Break `h` from `p1` to `p2` and end the command. As in AutoCAD 2024, a break that can't be made
/// (a whole circle at one point: "Arc cannot be full 360 degrees") is reported and ends the
/// command too, leaving the object as it was.
fn break_and_end(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Step> {
match break_entity(s, h, p1, p2) {
Ok(_) => {}
Err(EngineError::Other(m)) => s.echo(m),
Err(e) => return Err(e),
}
s.set_selection(Vec::new());
Ok(Step::Done)
}
#[derive(Default)]
pub(super) struct BreakM {
obj: Option<(Handle, Vec2)>,
@@ -236,14 +269,8 @@ impl Interactive for BreakM {
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.obj, i) {
(None, Input::Point(p)) => {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
match s.pick_object(&space, p, ap)? {
Some(h) => {
self.obj = Some((h, p));
s.set_selection(vec![h]);
}
None => s.echo("*Invalid selection*"),
if let Some(h) = pick_to_break(s, p)? {
self.obj = Some((h, p));
}
Ok(Step::Continue)
}
@@ -256,12 +283,46 @@ impl Interactive for BreakM {
self.first_point = false;
Ok(Step::Continue)
}
(Some((h, p1)), Input::Point(p2)) => {
break_entity(s, h, p1, p2)?;
(Some((h, p1)), Input::Point(p2)) => break_and_end(s, h, p1, p2),
(Some(_), Input::Enter) => {
s.set_selection(Vec::new());
Ok(Step::Done)
}
(_, Input::Enter) => Ok(Step::Done),
(None, Input::Enter) => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
}
/// BREAKATPOINT at the command line, with AutoCAD 2024's prompts: "Select object:", then "Specify
/// break point:"; the object is split there with no gap (the point projects onto it).
#[derive(Default)]
pub(super) struct BreakAtPointM {
obj: Option<Handle>,
}
impl Interactive for BreakAtPointM {
fn name(&self) -> &'static str {
"BREAKATPOINT"
}
fn prompt(&self, _s: &Session) -> Prompt {
match self.obj {
None => Prompt::new("Select object", Accept::POINT),
Some(_) => Prompt::new("Specify break point", Accept::POINT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.obj, i) {
(None, Input::Point(p)) => {
self.obj = pick_to_break(s, p)?;
Ok(Step::Continue)
}
(Some(h), Input::Point(p)) => break_and_end(s, h, p, p),
(Some(_), Input::Enter) => {
s.set_selection(Vec::new());
Ok(Step::Done)
}
(None, Input::Enter) => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
+266 -37
View File
@@ -1,3 +1,5 @@
use cadcraft_geom::Bounds2;
use super::{
Arc, EngineError, Entity, EntityKind, Handle, Line, PolyVertex, Polyline, Prim, Result, Segment, Session, TAU, Vec2, angle_in_sweep, arc,
ccw_sweep, intersect_ext, line, lwpoly, norm_angle,
@@ -91,13 +93,62 @@ fn prim_to_segments(p: &Prim) -> Vec<Segment> {
}
}
/// Explain the generic line failures for JSON handle+pick calls, and a line TRIM picked on its
/// only cuts ([`ON_THE_CUT`]). Other curves retain their own diagnostics: their nearest-parameter
/// rules do not prove that a pick is invalid.
pub(crate) fn json_pick_error(s: &Session, h: Handle, pick: Vec2, edges: Edges, extending: bool, error: EngineError) -> EngineError {
let generic = if extending { "Object does not intersect an edge." } else { "Object does not intersect a cutting edge." };
if !matches!(&error, EngineError::Other(message) if message == generic || (!extending && message == ON_THE_CUT)) {
return error;
}
let Ok(d) = s.doc() else { return error };
let Some(e) = d.entity(h) else { return error };
let EntityKind::Line(l) = &e.kind else { return error };
let Ok(cut) = edge_segments(s, edges, h) else { return error };
let ln = Line::new(l.a.xy(), l.b.xy());
let message = if extending {
// The selected end already failed. Check the opposite end with the same ray and
// forward-intersection rules before attributing the failure to the pick's end choice.
let (fixed, end) = if pick.dist(ln.b) < pick.dist(ln.a) { (ln.b, ln.a) } else { (ln.a, ln.b) };
let dir = (end - fixed).normalized();
let ray = Segment::Line(Line::new(end, end + dir * 1e8));
let opposite_hit = cut.iter().flat_map(|c| intersect_ext(&ray, c, false)).any(|x| (x - end).dot(dir) > 1e-9);
if opposite_hit {
"The `pick` point selects an end with no boundary ahead; choose `pick` toward the boundary to extend to."
} else {
"No usable boundary intersection was found for either end of the object to extend."
}
} else {
let pick_param = ln.param_of(pick).clamp(0.0, 1.0);
let has_cut = cut.iter().flat_map(|c| intersect_ext(&Segment::Line(ln), c, false)).any(|x| {
let t = ln.param_of(x);
t > 1e-9 && t < 1.0 - 1e-9
});
if !has_cut {
"No usable cutting-edge intersection in the interior of the object to trim."
} else if pick_param.is_nan() {
return error;
} else if !ln.at(pick_param).near(pick, 1e-9_f64.max(64.0 * f64::EPSILON * (1.0 + pick.len().max(ln.a.len()).max(ln.b.len())))) {
"The `pick` point is off the line and projects onto a cutting intersection; pick away from that intersection."
} else {
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection."
}
};
EngineError::Other(message.into())
}
/// Trim `h` at the piece containing `pick`. Returns the handles that replace it.
/// Trim `h` at the piece containing `pick`. Returns what it became: its pieces, `h` first
/// ([`replace_with_pieces`]).
pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Result<Vec<Handle>> {
if crate::cmd::curves::is_locked(s, h) {
return Err(EngineError::Other("The object is on a locked layer.".into()));
}
let e = s.doc()?.entity(h).map(|e| (**e).clone()).ok_or_else(|| EngineError::Other("no such object".into()))?;
let cut = edge_segments(s, edges, h)?;
// A polyline that is one of the edges (picked, or with every object in either mode) cuts
// itself too.
let itself = edges.only.is_none_or(|o| o.contains(&h));
let pieces: Vec<EntityKind> = match &e.kind {
EntityKind::Line(l) => {
let ln = Line::new(l.a.xy(), l.b.xy());
@@ -109,10 +160,12 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
.collect();
ts.sort_by(f64::total_cmp);
let tp = ln.param_of(pick).clamp(0.0, 1.0);
let found = ts.len();
ts.retain(|t| (t - tp).abs() * ln.len() > ON_CUT);
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(1.0, f64::min);
if lo == 0.0 && hi == 1.0 {
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -131,11 +184,14 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
let mut ts: Vec<f64> =
cut.iter().flat_map(|c| intersect_ext(&seg, c, false)).map(param).filter(|t| *t > 1e-9 && *t < sweep - 1e-9).collect();
ts.sort_by(f64::total_cmp);
let tp = param(pick).min(sweep);
// A pick off the arc is at the end it is nearer, round the circle.
let tp = crate::cmd::curves::seg_param(&seg, pick) * sweep;
let found = ts.len();
ts.retain(|t| (t - tp).abs() * ga.radius > ON_CUT);
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(sweep, f64::min);
if lo == 0.0 && hi == sweep {
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -151,10 +207,16 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
let mut angs: Vec<f64> = cut.iter().flat_map(|x| intersect_ext(&full, x, false)).map(|p| c.center.xy().angle_to(p)).collect();
angs.sort_by(f64::total_cmp);
angs.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
if angs.len() < 2 {
return Err(EngineError::Other("Circle must intersect cutting edges at two or more points.".into()));
}
let ap = c.center.xy().angle_to(pick);
let found = angs.len();
angs.retain(|a| {
let d = norm_angle(a - ap);
d.min(TAU - d) * c.radius > ON_CUT
});
if angs.len() < 2 {
let why = if found >= 2 { ON_THE_CUT } else { "Circle must intersect cutting edges at two or more points." };
return Err(EngineError::Other(why.into()));
}
// The removed arc runs between the two intersections around the pick.
let n = angs.len();
let mut keep = None;
@@ -167,7 +229,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
}
keep.into_iter().collect()
}
EntityKind::LwPolyline(p) => trim_polyline(p, &cut, pick)?,
EntityKind::LwPolyline(p) => match trim_polyline(p, &cut, pick, itself)? {
Some(pieces) => pieces,
None => return Ok(vec![h]),
},
k => crate::cmd::modify2::trim_other(k, &cut, pick)?,
};
replace_with_pieces(s, h, pieces)
@@ -181,19 +246,20 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
/// in its middle keeps its handle on the piece from its start point, the piece to its end point is
/// new; a circle broken or trimmed becomes an arc with the circle's handle.)
///
/// Dimensions attached to the object follow [`crate::assoc::follow_pieces`]. Its parametric
/// constraints are removed: its new shape no longer meets them, and solving them again would move
/// the objects they tie it to.
/// Each piece keeps what the object had beyond its outline ([`inherit`]). Dimensions attached to
/// the object follow [`crate::assoc::follow_pieces`]. Its parametric constraints are removed: its
/// new shape no longer meets them, and solving them again would move the objects they tie it to.
pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<EntityKind>) -> Result<Vec<Handle>> {
let d = s.doc_mut()?;
let mut pieces = pieces.into_iter();
let Some(first) = pieces.next() else {
if pieces.is_empty() {
d.remove_entity(h);
return Ok(Vec::new());
};
}
let (Some(space), Some(old)) = (d.space_of(h), d.entity(h).cloned()) else {
return Err(EngineError::Other("no such object".into()));
};
let mut pieces = pieces.into_iter().map(|k| inherit(&old.kind, k));
let Some(first) = pieces.next() else { return Ok(Vec::new()) };
d.modify_entity(h, |e| e.kind = first)?;
let mut out = vec![h];
for kind in pieces {
@@ -213,6 +279,31 @@ pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<Entity
Ok(out)
}
/// `piece`, cut from `source`, with what it keeps of it as AutoCAD 2024's BREAK and TRIM leave
/// pieces: a line's Z along it, an arc's (or a circle's) centre Z, and a polyline's elevation,
/// constant width and linetype generation.
fn inherit(source: &EntityKind, mut piece: EntityKind) -> EntityKind {
match (source, &mut piece) {
(EntityKind::Line(s), EntityKind::Line(p)) => {
let ln = Line::new(s.a.xy(), s.b.xy());
if ln.len() > 0.0 {
let z = |t: f64| s.a.z + (s.b.z - s.a.z) * t;
p.a.z = z(ln.param_of(p.a.xy()));
p.b.z = z(ln.param_of(p.b.xy()));
}
}
(EntityKind::Arc(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
(EntityKind::Circle(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
(EntityKind::LwPolyline(s), EntityKind::LwPolyline(p)) => {
p.elevation = s.elevation;
p.const_width = s.const_width;
p.plinegen = s.plinegen;
}
_ => {}
}
piece
}
/// Sub-polyline between length parameters `a` and `b` (open polylines).
pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex> {
let mut out: Vec<PolyVertex> = Vec::new();
@@ -245,15 +336,128 @@ pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex>
out
}
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> Result<Vec<EntityKind>> {
/// Two line segments of a polyline within this sine of parallel run on as one, straight on or
/// doubling back: the vertex between them doesn't cut it, and they don't cut each other. AutoCAD
/// 2024 cuts at a bend of 1e-8 and not at one of 8e-9, whatever the lengths.
const STRAIGHT: f64 = 1e-8;
/// Upper bounds on one trim's search for where a polyline crosses itself (hostile files): the pairs
/// of segments searched (those the piece picked can reach, times those near them) and the
/// crossings found. Past either the trim is refused, rather than made at some of its cuts.
const MAX_SELF_PAIRS: usize = 1 << 24;
const MAX_SELF_CROSSINGS: usize = 1 << 16;
/// How near a cut a pick is on it, along the object. AutoCAD 2024 trims nothing for a pick that
/// near one of a polyline's own cuts, and passes over a cut by another edge, the trim running on
/// across it, on lines, arcs and circles too. On open polylines from 1e-3 to 1e9 long it was within
/// 5e-7, and 5.1e-7 away trimmed at the cut (around a closed rectangle it reached a little further,
/// to 1e-6; on a line, further still, to 5e-4 on one 10 long).
const ON_CUT: f64 = 5e-7;
/// The refusal when every cut was passed over ([`ON_CUT`]): the object meets an edge, at the pick,
/// so Quick mode leaves it in place rather than erasing it as one no edge crosses.
const ON_THE_CUT: &str = "The pick is on the cut: nothing to trim.";
/// AutoCAD 2024's refusal to trim a closed polyline cut at one point only.
pub(crate) const CUT_ONCE: &str = "Curve must intersect cutting edges at least twice.";
/// Whether segments `a` and `b` of a polyline run on as one ([`STRAIGHT`]).
fn runs_on(a: &Segment, b: &Segment) -> bool {
let (Segment::Line(a), Segment::Line(b)) = (a, b) else { return false };
let (u, v) = (a.b - a.a, b.b - b.a);
u.cross(v).abs() < STRAIGHT * u.len() * v.len()
}
/// Where a polyline that is one of the cutting edges cuts itself around segment `k`, the one
/// picked, as lengths along it: at its vertices (every vertex of a closed one, its start included)
/// but those it runs straight on through ([`runs_on`]), and, on `k` and the segments it runs
/// straight on into, where another of its segments crosses them or a vertex of it (an end
/// included) touches them. The piece picked lies within those segments, so crossings elsewhere
/// don't bound it. AutoCAD 2024 trims a polyline that is one of the cutting edges at these.
fn self_cuts(segs: &[Segment], closed: bool, k: usize) -> Result<Vec<f64>> {
let n = segs.len();
let mut starts = Vec::with_capacity(n);
let mut acc = 0.0;
for s in segs {
starts.push(acc);
acc += s.len();
}
let before = |i: usize| {
if i > 0 {
Some(i - 1)
} else if closed {
n.checked_sub(1)
} else {
None
}
};
let after = |i: usize| {
if i + 1 < n {
Some(i + 1)
} else if closed {
Some(0)
} else {
None
}
};
// Whether the polyline runs straight on through the vertex segment `i` starts at.
let straight = |i: usize| matches!((before(i).and_then(|j| segs.get(j)), segs.get(i)), (Some(a), Some(b)) if runs_on(a, b));
let mut ts: Vec<f64> = (usize::from(!closed)..n).filter(|i| !straight(*i)).filter_map(|i| starts.get(i).copied()).collect();
let mut run = vec![k];
let mut i = k;
while let Some(j) = before(i).filter(|_| straight(i) && run.len() < n) {
run.push(j);
i = j;
}
let mut i = k;
while let Some(j) = after(i).filter(|j| straight(*j) && run.len() < n) {
run.push(j);
i = j;
}
let boxes: Vec<_> = segs.iter().map(Segment::bounds).collect();
let reach = run.iter().filter_map(|i| boxes.get(*i)).fold(Bounds2::EMPTY, |r, b| r.union(b));
let near: Vec<usize> = (0..n).filter(|j| boxes.get(*j).is_some_and(|b| b.intersects(&reach))).collect();
if run.len().saturating_mul(near.len()) > MAX_SELF_PAIRS {
return Err(EngineError::Other("Too many segments to trim the polyline where it crosses itself.".into()));
}
// A crossing, or a vertex of another segment touching this one, cuts it; so does a crossing
// where it runs straight on into the next. Two segments meeting at a vertex cut nothing more.
let cuts = |t: f64, i: usize| (t > 1e-9 && t < 1.0 - 1e-9) || (t <= 1e-9 && straight(i)) || (t >= 1.0 - 1e-9 && after(i).is_some_and(straight));
let vertices = ts.len();
for &i in &run {
let (Some(a), Some(box_a), Some(a0)) = (segs.get(i), boxes.get(i), starts.get(i)) else { continue };
for &j in &near {
let (Some(b), Some(box_b)) = (segs.get(j), boxes.get(j)) else { continue };
if j == i || runs_on(a, b) || !box_a.intersects(box_b) {
continue;
}
for x in intersect_ext(a, b, false) {
let t = param_on(a, x);
if cuts(t, i) {
ts.push(a0 + t * a.len());
if ts.len() - vertices > MAX_SELF_CROSSINGS {
return Err(EngineError::Other("Too many crossings to trim the polyline where it crosses itself.".into()));
}
}
}
}
}
Ok(ts)
}
/// Trim a polyline at the piece containing `pick`, between the cuts by `cut` and, when it is one
/// of the cutting edges (`itself`), by its own ([`self_cuts`]). `None`: the pick is on one of its
/// own cuts ([`ON_CUT`]), which trims nothing.
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itself: bool) -> Result<Option<Vec<EntityKind>>> {
let pl = Polyline { vertices: p.vertices.clone(), closed: p.closed };
let segs = pl.segments();
let total: f64 = segs.iter().map(Segment::len).sum();
let mut ts: Vec<f64> = Vec::new();
let mut acc = 0.0;
let mut tp = 0.0;
// The pick's length along the polyline and the segment it is on.
let (mut tp, mut k) = (0.0, 0);
let mut best = f64::INFINITY;
for s in &segs {
for (i, s) in segs.iter().enumerate() {
let len = s.len();
for x in cut.iter().flat_map(|c| intersect_ext(s, c, false)) {
ts.push(acc + param_on(s, x) * len);
@@ -262,13 +466,34 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> R
if c.dist(pick) < best {
best = c.dist(pick);
tp = acc + param_on(s, c) * len;
k = i;
}
acc += len;
}
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
let mut own = if itself { self_cuts(&segs, p.closed, k)? } else { Vec::new() };
// An open polyline's ends cut nothing; a closed one's start vertex cuts it like any other (a
// cut there is at 0 or at its length, which the pieces below take as one).
if !p.closed {
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
own.retain(|t| *t > 1e-9 && *t < total - 1e-9);
}
// How far apart two lengths along the polyline are, round its start too when it is closed.
let apart = |s: f64, t: f64| if p.closed { (s - t).abs().min(total - (s - t).abs()) } else { (s - t).abs() };
// A pick on one of its own cuts trims nothing; a cut by another edge there is passed over, and
// the piece runs on across it.
if own.iter().any(|t| apart(*t, tp) <= ON_CUT) {
return Ok(None);
}
let found = ts.len();
ts.retain(|t| apart(*t, tp) > ON_CUT);
let passed = ts.len() < found;
ts.extend(own);
ts.sort_by(f64::total_cmp);
if ts.is_empty() {
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
return Err(EngineError::Other(if passed { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
if p.closed && ts.first().is_some_and(|f| ts.iter().all(|t| apart(*f, *t) <= ON_CUT)) {
return Err(EngineError::Other(CUT_ONCE.into()));
}
let lo = ts.iter().copied().filter(|t| *t < tp).fold(f64::NEG_INFINITY, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(f64::INFINITY, f64::min);
@@ -283,33 +508,31 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> R
if hi.is_finite() { hi } else { ts.first().copied().unwrap_or(total) + total },
);
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
let (a, mut b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
// A single cut leaves the whole outline, opened there.
if b <= a + 1e-9 {
b += total;
}
let (a, b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
out.push(mk(sub_polyline(&doubled, a, b)));
} else {
// A piece whose ends meet (the polyline touched itself there) is closed, without its
// repeated vertex, as AutoCAD leaves it.
let piece = |mut vs: Vec<PolyVertex>| {
// Within rounding of the coordinates, however far from the origin, and no more.
let meets = vs.len() >= 4
&& matches!((vs.first(), vs.last()), (Some(a), Some(b)) if a.p.near(b.p, 64.0 * f64::EPSILON * (1.0 + a.p.len().max(b.p.len()))));
if meets {
vs.pop();
}
lwpoly(vs, meets)
};
if lo.is_finite() {
out.push(mk(sub_polyline(&segs, 0.0, lo)));
out.push(piece(sub_polyline(&segs, 0.0, lo)));
}
if hi.is_finite() {
out.push(mk(sub_polyline(&segs, hi, total)));
out.push(piece(sub_polyline(&segs, hi, total)));
}
}
Ok(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect())
Ok(Some(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect()))
}
pub(super) fn param_on(s: &Segment, p: Vec2) -> f64 {
match s {
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
Segment::Arc { arc, ccw } => {
let t = norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15);
let t = t.clamp(0.0, 1.0);
if *ccw { t } else { 1.0 - t }
}
}
}
pub(super) use crate::cmd::curves::seg_param as param_on;
/// A polyline arc segment on `ga`'s circle that ends at `end` after turning through `sweep`
/// (signed, positive counterclockwise), run on round the circle to the nearest boundary edge: the
@@ -372,7 +595,13 @@ pub(crate) fn extend(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Re
EntityKind::LwPolyline(p) if !p.closed && p.vertices.len() >= 2 => {
let mut vs = p.vertices.clone();
let n = vs.len();
let from_end = vs.last().is_some_and(|l| pick.dist(l.p) < vs.first().map(|f| pick.dist(f.p)).unwrap_or(f64::INFINITY));
// The pick's parameter: the segment it is nearest, plus how far along it. AutoCAD 2024
// extends the end on that side of the polyline's middle parameter, the last from the
// middle on, not the end nearer the pick. A repeated vertex counts as a segment, so
// these come from the vertices, not `Polyline::segments`, which skips it.
let spans: Vec<_> = vs.windows(2).filter_map(|w| Some((w.first()?.p, w.get(1)?.p, w.first()?.bulge))).collect();
let at = crate::cmd::curves::vertex_param_of(&spans, pick);
let from_end = 2.0 * at >= (n - 1) as f64;
let (i_end, i_prev) = if from_end { (n - 1, n - 2) } else { (0, 1) };
let end = vs.get(i_end).map(|v| v.p).unwrap_or_default();
let prev = vs.get(i_prev).map(|v| v.p).unwrap_or_default();
+3 -20
View File
@@ -79,9 +79,7 @@ impl PlotterStore {
}
PlotterStore {
list: || {
let d = dir()?;
crate::file_access::check_read(&d)?;
let rd = match std::fs::read_dir(d) {
let rd = match std::fs::read_dir(dir()?) {
Ok(rd) => rd,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(e) => return Err(e.to_string()),
@@ -94,7 +92,6 @@ impl PlotterStore {
},
read: |n| {
let p = file(n)?;
crate::file_access::check_read(&p)?;
let len = std::fs::metadata(&p).map_err(|e| format!("{n}: {e}"))?.len();
if len > cadcraft_doc::MAX_PLOTTER_FILE as u64 {
return Err(format!("{n}: the plotter configuration file is too large"));
@@ -103,16 +100,10 @@ impl PlotterStore {
},
write: |n, t| {
let p = file(n)?;
// Checked before the folder it lives in is created. The temporary file sits beside it.
crate::file_access::check_write(&p)?;
std::fs::create_dir_all(dir()?).map_err(|e| e.to_string())?;
crate::atomic_write::write_atomic(&p, t.as_bytes()).map_err(|e| format!("{n}: {e}"))
},
delete: |n| {
let p = file(n)?;
crate::file_access::check_write(&p)?;
std::fs::remove_file(p).map_err(|e| format!("{n}: {e}"))
},
delete: |n| std::fs::remove_file(file(n)?).map_err(|e| format!("{n}: {e}")),
}
}
}
@@ -556,18 +547,11 @@ fn edit_device(cmd: &str, c: &mut PlotterConfig, p: &Value) -> Result<()> {
Ok(())
}
/// List, read, change, load, export and delete plotter configurations; any file is held to the automation roots.
fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "plottermanager";
let action = str_param(p, "action").unwrap_or("list").trim().to_ascii_lowercase();
match action.as_str() {
"list" => {
// Under the roots a refused settings folder is an error, not a short list.
if crate::file_access::current().is_some() {
(store().list)().map_err(|e| bad(cmd, e))?;
}
Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() }))
}
"list" => Ok(json!({ "devices": devices().iter().map(summary).collect::<Vec<_>>() })),
"get" => {
let n = device_name(cmd, p)?;
let c = find_device(&n).ok_or_else(|| unknown_device(cmd, &n))?;
@@ -652,7 +636,6 @@ fn run_plottermanager(_s: &mut Session, p: &Value) -> Result<Value> {
Some(_path) => {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(_path).map_err(|e| bad(cmd, e))?;
std::fs::write(_path, &text).map_err(|e| bad(cmd, format!("{_path}: {e}")))?;
Ok(json!({ "name": name, "path": _path }))
}
-1
View File
@@ -238,7 +238,6 @@ fn read_link(id: &str, file: &std::path::Path) -> Result<String> {
let path = file.display();
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_read(file).map_err(|e| bad(id, e))?;
// The limit is enforced on the bytes read, not on reported metadata, so a device or FIFO
// that misreports its length can't be buffered to EOF.
let bytes = crate::capped_read::read_capped(file, MAX_LINK_BYTES).map_err(|e| bad(id, format!("{path}: {e}")))?;
-1
View File
@@ -514,7 +514,6 @@ pub(crate) fn table_csv(t: &Table, sep: char) -> String {
fn write_text(path: &str, text: &str) -> Result<()> {
#[cfg(not(target_arch = "wasm32"))]
{
crate::file_access::check_write(path).map_err(|e| bad("tableexport", e))?;
std::fs::write(path, text).map_err(|e| bad("tableexport", format!("{path}: {e}")))
}
#[cfg(target_arch = "wasm32")]
+45 -11
View File
@@ -8,8 +8,9 @@ use cadcraft_doc::{Drawing, EntityKind, Handle};
use cadcraft_geom::{Bounds2, Line, Vec2, line_line};
use serde_json::{Value, json};
use super::curves::KW;
use super::helpers::{line, lwpoly, rect_vertices};
use super::modify::{Edges, extend, trim};
use super::modify::{CUT_ONCE, Edges, extend, json_pick_error, trim};
use super::{bad, point_param, points_param};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
@@ -31,8 +32,10 @@ fn proj_mode(s: &Session) -> i64 {
}
/// Whether a trim error says the object meets no cutting edge (a Quick-mode trim then erases it).
/// A closed polyline cut at one point meets one, and is left as it is.
fn misses_edges(e: &EngineError) -> bool {
e.to_string().contains("intersect")
let m = e.to_string();
m.contains("intersect") && m != CUT_ONCE
}
/// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
@@ -103,7 +106,12 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
for w in pl.windows(2) {
let (Some(p), Some(q)) = (w.first(), w.get(1)) else { continue };
let seg = Line::new(*p, *q);
let cands = [*p, *q, seg.closest(a)].into_iter().chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
// Kept `tol` inside the segment: a vertex, where two segments meet, is a cut of a
// polyline that is one of its own edges, and a pick on a cut trims nothing.
let e = (tol / seg.len()).min(0.5);
let cands = [seg.at(e), seg.at(1.0 - e), seg.at(seg.param_of(a).clamp(e, 1.0 - e))]
.into_iter()
.chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
for c in cands.filter(|c| inside(*c)) {
if best.is_none_or(|b| c.dist(a) < b.dist(a)) {
best = Some(c);
@@ -173,7 +181,6 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
let cmd = if extending { "extend" } else { "trim" };
let only: Option<Vec<Handle>> =
p.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_str().and_then(Handle::parse_hex)).collect());
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
let quick = match p.get("mode") {
None | Some(Value::Null) => false,
Some(v) => match v.as_str().map(|m| m.trim().to_ascii_lowercase()).as_deref() {
@@ -182,6 +189,7 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
_ => return Err(bad(cmd, "`mode` must be \"quick\" or \"standard\"")),
},
};
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
let key = if extending { "extended" } else { "trimmed" };
if p.get("fence").is_some_and(|v| !v.is_null()) {
let pts = points_param(p, "fence")
@@ -197,8 +205,19 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
return Ok(json!({ key: n }));
}
let h = super::targets(s, p)?.first().copied().ok_or_else(|| bad(cmd, "`handle` is required"))?;
let pick = point_param(p, "pick").ok_or_else(|| bad(cmd, "`pick` ([x, y]) is required"))?;
let r = apply(s, h, pick, extending, edges, quick)?;
let pick = point_param(p, "pick").ok_or_else(|| {
bad(
cmd,
if extending {
"`pick` ([x, y]) is required: point toward the boundary to extend to, selecting the nearer end"
} else {
"`pick` ([x, y]) is required: select the portion of the object to trim away"
},
)
})?;
// Diagnose only an existing single-pick JSON failure. Successful calls, Quick-mode
// erasure, fence/crossing and the interactive command keep their existing behavior.
let r = apply(s, h, pick, extending, edges, quick).map_err(|e| json_pick_error(s, h, pick, edges, extending, e))?;
if extending { Ok(Value::Null) } else { Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() })) }
}
@@ -220,6 +239,8 @@ enum Stage {
Edges(Vec<Handle>),
/// Fence points so far.
Fence(Vec<Vec2>),
/// Quick mode's two-point fence, started by a pick in empty space: its first point.
QuickFence(Vec2),
/// A crossing window: its first corner once picked.
Crossing(Option<Vec2>),
Mode,
@@ -356,11 +377,12 @@ impl Interactive for TrimM {
None => Prompt::new("Specify first fence point", Accept::POINT),
Some(l) => Prompt::new("Specify next fence point", Accept::POINT).kw(&["Undo"]).base(*l),
},
Stage::QuickFence(a) => Prompt::new("Specify next fence point", Accept::POINT).base(*a),
Stage::Crossing(None) => Prompt::new("Specify first corner", Accept::POINT),
Stage::Crossing(Some(_)) => Prompt::new("Specify opposite corner", Accept::POINT),
Stage::Mode => {
let msg = if self.extend { "Enter an extend mode option" } else { "Enter a trim mode option" };
Prompt::new(msg, Accept::TEXT).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
Prompt::new(msg, KW).kw(&["Quick", "Standard"]).default(if quick_mode(s) { "Quick" } else { "Standard" })
}
Stage::Project => {
let cur = match proj_mode(s) {
@@ -368,9 +390,9 @@ impl Interactive for TrimM {
2 => "View",
_ => "Ucs",
};
Prompt::new("Enter a projection option", Accept::TEXT).kw(&["None", "Ucs", "View"]).default(cur)
Prompt::new("Enter a projection option", KW).kw(&["None", "Ucs", "View"]).default(cur)
}
Stage::Edge => Prompt::new("Enter an implied edge extension mode", Accept::TEXT).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
Stage::Edge => Prompt::new("Enter an implied edge extension mode", KW).kw(&["Extend", "No extend"]).default(if edge_mode(s) {
"Extend"
} else {
"No extend"
@@ -455,6 +477,16 @@ impl Interactive for TrimM {
}
Ok(Step::Continue)
}
Stage::QuickFence(a) => {
self.stage = Stage::Pick;
if let Input::Point(b) = i {
let r = self.step(s, |m, s| fence(s, &[a, b], extending, m.edges(quick, implied), quick).map(|_| ()));
if let Err(e) = r {
s.echo(e.to_string());
}
}
Ok(Step::Continue)
}
Stage::Crossing(first) => {
match (first, i) {
(None, Input::Point(p)) => self.stage = Stage::Crossing(Some(p)),
@@ -475,8 +507,9 @@ impl Interactive for TrimM {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
let Some(h) = s.pick_object(&space, p, ap)? else {
// A pick in empty space opens a crossing window there.
self.stage = Stage::Crossing(Some(p));
// A pick in empty space starts a two-point fence in Quick mode (as in
// AutoCAD, #1594) and a crossing window in Standard mode.
self.stage = if quick { Stage::QuickFence(p) } else { Stage::Crossing(Some(p)) };
return Ok(Step::Continue);
};
let r = self.step(s, |m, s| apply(s, h, p, extending, m.edges(quick, implied), quick).map(|_| ()));
@@ -525,6 +558,7 @@ impl Interactive for TrimM {
.windows(2)
.filter_map(|w| Some(line(*w.first()?, *w.get(1)?)))
.collect(),
Stage::QuickFence(a) => vec![line(*a, c)],
Stage::Crossing(Some(a)) => vec![lwpoly(rect_vertices(*a, c), true)],
_ => Vec::new(),
}
-781
View File
@@ -1,781 +0,0 @@
//! The folders automation may read and write (#1472).
//!
//! `cadcraft-cli mcp --automation-read-root <dir> --automation-write-root <dir>` confines the files
//! an agent's commands reach. [`AutomationRoots`] holds the two folders. While they are in force,
//! every path a command reads goes through [`check_read`] and every path it writes through
//! [`check_write`]:
//!
//! - The path is made absolute against the working directory, as the file system reads it. Its
//! links are followed: for a file that doesn't exist yet, the links of its nearest existing
//! folder, the rest of the path being plain names (`..` below a missing folder is refused, and so
//! is a link that leads nowhere).
//! - On Windows a network path (`\\server\share`, `\\?\UNC\...`), a device path (`\\.\...`) or a
//! verbatim path that isn't a disk is refused before anything opens it, unless a root is already
//! on that same server and share (or that same device or prefix). A link whose target is one of
//! those is refused from the target text, before the link is followed. Opening such a path would
//! contact a host the agent named.
//! - The result must lie inside the root, compared by whole components (`/work2` isn't inside
//! `/work`) and exactly: both sides have been through the file system, which gives each folder
//! its real name, and a Windows folder can be case sensitive, with `Root` beside `root`.
//! - Reads may lie under either root; writes only under the write root, and never at the write
//! root itself (its save-style temporary file would be outside). A root given alone grants
//! reads under it even when it is the write root; a read root grants no writes.
//!
//! Roots are in force on a thread inside [`confine`]. The MCP headless backend runs every call in
//! it; without roots nothing is checked, so the app and the command line keep working everywhere.
//!
//! A path is checked, then opened: a process that can change the folders in between (swapping in
//! a link) can still win that race. A network, device or non-disk verbatim path is not opened at
//! all. The roots keep an agent to the files it was given; they don't guard against other
//! programs on the computer.
pub mod commands;
use std::cell::RefCell;
use std::ffi::OsString;
use std::path::{Component, Path, PathBuf};
use std::sync::Arc;
/// Read access or write access.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Access {
Read,
Write,
}
/// The folders automation may read and write; a root left out grants no access of its kind.
#[derive(Debug)]
pub struct AutomationRoots {
read: Option<PathBuf>,
write: Option<PathBuf>,
}
/// The folder at `path`, which must exist, made absolute with its links followed: what paths are
/// compared with.
fn open_root(path: &Path, access: Access) -> Result<PathBuf, String> {
let kind = match access {
Access::Read => "read",
Access::Write => "write",
};
std::fs::canonicalize(path)
.and_then(|p| if p.is_dir() { Ok(p) } else { Err(std::io::ErrorKind::NotADirectory.into()) })
.map_err(|e| format!("cannot open the automation {kind} root `{}`: {e}", path.display()))
}
impl AutomationRoots {
/// The roots `read` and `write`, which must be existing folders; `None` when neither is given
/// (nothing is confined then).
pub fn new(read: Option<&Path>, write: Option<&Path>) -> Result<Option<Arc<Self>>, String> {
if read.is_none() && write.is_none() {
return Ok(None);
}
let read = read.map(|p| open_root(p, Access::Read)).transpose()?;
let write = write.map(|p| open_root(p, Access::Write)).transpose()?;
Ok(Some(Arc::new(Self { read, write })))
}
/// The read root, absolute with its links followed.
pub fn read_root(&self) -> Option<&Path> {
self.read.as_deref()
}
/// The write root, absolute with its links followed.
pub fn write_root(&self) -> Option<&Path> {
self.write.as_deref()
}
/// May the file or folder at `path` be read (or written)? `Err` says why not.
///
/// A read may lie under either root: the read root, or the write root (files the agent may
/// write it may also read back). A write may lie only under the write root, and not at the
/// root itself, whose save-style temporary file would sit beside it. Its name must stand there
/// too: a link outside pointing in is refused, since what is written beside the name (a
/// drawing's `.bak`) or done to it (a delete) happens in the folder that holds it.
///
/// A path is taken as it is: turned into text on the way, a name that isn't text would name a
/// different file.
pub fn check(&self, given: impl AsRef<Path>, access: Access) -> Result<(), String> {
let given = given.as_ref();
let target = resolve(given, self)?;
let path = given.display();
if access == Access::Read {
let roots = [self.read.as_ref(), self.write.as_ref()];
if roots.iter().flatten().any(|r| inside(&target, r)) {
return Ok(());
}
if roots.iter().all(|r| r.is_none()) {
return Err(format!("automation filesystem access is not granted: read authority is absent: {path}"));
}
return Err(format!("automation path rejected: outside the read root (or the write root): {path}"));
}
let Some(folder) = self.write.as_ref() else {
return Err(format!("automation filesystem access is not granted: write authority is absent: {path}"));
};
if !inside(&target, folder) {
return Err(format!("automation path rejected: outside the write root {}: {path}", folder.display()));
}
// A write to the root itself would put its temporary file beside the root, outside it.
if same(&target, folder) {
return Err(format!("automation path rejected: the write root itself cannot be written: {path}"));
}
if !inside(&resolve(given.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new(".")), self)?, folder) {
return Err(format!("automation path rejected: stands outside the write root {}: {path}", folder.display()));
}
Ok(())
}
}
thread_local! {
/// The roots in force on this thread.
static ROOTS: RefCell<Option<Arc<AutomationRoots>>> = const { RefCell::new(None) };
}
/// Puts the roots it replaced back when dropped (also when `f` panics).
struct Restore(Option<Arc<AutomationRoots>>);
impl Drop for Restore {
/// Puts the roots it replaced back.
fn drop(&mut self) {
ROOTS.with(|r| *r.borrow_mut() = self.0.take());
}
}
/// Run `f` with `roots` in force on this thread (`None`: as things stand).
pub fn confine<T>(roots: Option<&Arc<AutomationRoots>>, f: impl FnOnce() -> T) -> T {
let previous = ROOTS.with(|r| r.replace(roots.cloned()));
let _restore = Restore(previous);
f()
}
/// This thread's roots, if any.
pub fn current() -> Option<Arc<AutomationRoots>> {
ROOTS.with(|r| r.borrow().clone())
}
/// May `path` be read here? Always, without roots in force.
pub fn check_read(path: impl AsRef<Path>) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Read))
}
/// May `path` be written here? Always, without roots in force.
pub fn check_write(path: impl AsRef<Path>) -> Result<(), String> {
current().map_or(Ok(()), |r| r.check(path, Access::Write))
}
/// `path` made absolute with its links followed; for a path that doesn't exist (yet), its nearest
/// existing folder's links followed and the rest appended.
///
/// A Windows network, device or non-disk verbatim prefix is refused before any of that, unless
/// `roots` already stands on the same server and share (or the same device or prefix).
fn resolve(path: &Path, roots: &AutomationRoots) -> Result<PathBuf, String> {
let shown = path.display();
if path.as_os_str().is_empty() {
return Err("automation path rejected: path is empty".into());
}
// Checked as given: making `…\NUL` absolute gives the device path `\\.\NUL` on Windows.
if cfg!(windows) && path.components().any(|c| matches!(c, Component::Normal(n) if n.to_str().is_some_and(is_device_name))) {
return Err(format!("automation path rejected: reserved device names are not allowed: {shown}"));
}
// Before `absolute` too: on Windows that call asks the system about the path.
if let Some(why) = refused_prefix(path, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
let absolute = std::path::absolute(path).map_err(|e| format!("automation path rejected: cannot resolve {shown}: {e}"))?;
if let Some(why) = refused_prefix(&absolute, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
// The names below the nearest existing folder, last first.
let mut missing: Vec<OsString> = vec![];
let mut at = absolute.as_path();
loop {
// A link to a network path is judged from the target text. Canonicalizing it would follow
// the link and contact that host. Only Windows has those prefixes, so other targets skip
// the walk.
#[cfg(windows)]
if let Some(why) = link_leads_to_refused_prefix(at, roots) {
return Err(format!("automation path rejected: {why}: {shown}"));
}
match std::fs::canonicalize(at) {
Ok(mut found) => {
found.extend(missing.iter().rev());
return Ok(found);
}
Err(e) => match std::fs::symlink_metadata(at) {
Ok(m) if m.file_type().is_symlink() => return Err(format!("automation path rejected: a link that leads nowhere: {shown}")),
// There, yet its real path can't be had (no permission): nothing to compare.
Ok(_) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => return Err(format!("automation path rejected: cannot resolve {shown}: {e}")),
},
}
let parent = at.parent();
match (at.components().next_back(), parent) {
(Some(Component::Normal(name)), Some(parent)) => {
missing.push(name.to_os_string());
at = parent;
}
(Some(Component::ParentDir), _) => {
return Err(format!("automation path rejected: parent traversal below a folder that doesn't exist: {shown}"));
}
// Down to the root (or drive) and it doesn't exist either.
_ => {
let e = std::io::Error::from(std::io::ErrorKind::NotFound);
return Err(format!("automation path rejected: cannot resolve {shown}: {e}"));
}
}
}
}
/// Why `path` must not be opened: it is a Windows network, device or non-disk verbatim path, and
/// no root already uses that prefix. A local disk path returns `None`.
///
/// The comparison is ASCII case only, so `FileServer` matches `fileserver` and U+212A does not
/// match `k`. Matching only decides whether that host may be contacted; [`inside`] still decides
/// the folder.
fn refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
#[cfg(windows)]
{
let key = windows_prefix(path)?;
let allowed = [roots.read.as_ref(), roots.write.as_ref()]
.into_iter()
.flatten()
.any(|root| windows_prefix(root).is_some_and(|root_key| prefixes_match(&root_key, &key)));
if allowed { None } else { Some(key.refusal()) }
}
#[cfg(not(windows))]
{
let _ = (path, roots);
None
}
}
/// The refusal for a link in `path`, taken from the link's own text.
///
/// Folders are inspected from the root downward with [`std::fs::symlink_metadata`], which does not
/// follow a link, and the target is read with [`std::fs::read_link`]. A link to a network path is
/// therefore refused before [`std::fs::canonicalize`] would open that host, including when the
/// link is only an ancestor of the name. At most [`MAX_LINK_HOPS`] links are followed; one more,
/// or a link whose target cannot be read, is refused instead of being opened.
#[cfg(windows)]
fn link_leads_to_refused_prefix(path: &Path, roots: &AutomationRoots) -> Option<&'static str> {
follow_links(path, roots, MAX_LINK_HOPS)
}
/// [`link_leads_to_refused_prefix`], with `hops_left` links still allowed.
#[cfg(windows)]
fn follow_links(path: &Path, roots: &AutomationRoots, hops_left: usize) -> Option<&'static str> {
if let Some(why) = refused_prefix(path, roots) {
return Some(why);
}
let mut ancestors: Vec<&Path> = path.ancestors().collect();
ancestors.reverse();
for prefix in ancestors {
// A relative path's ancestor list ends at an empty name. Absolute paths, which are all
// this is called with, have no empty ancestor; skip it rather than treating it as missing.
if prefix.as_os_str().is_empty() {
continue;
}
if let Some(why) = refused_prefix(prefix, roots) {
return Some(why);
}
let Ok(meta) = std::fs::symlink_metadata(prefix) else { return None };
if !meta.file_type().is_symlink() {
continue;
}
if hops_left == 0 {
return Some("too many links");
}
let Ok(target) = std::fs::read_link(prefix) else { return Some("a link that leads nowhere") };
let joined = if target.is_absolute() {
target
} else {
match prefix.parent() {
Some(parent) if !parent.as_os_str().is_empty() => parent.join(target),
_ => target,
}
};
let rest = match path.strip_prefix(prefix) {
Ok(rest) if !rest.as_os_str().is_empty() => rest,
_ => Path::new(""),
};
let next = if rest.as_os_str().is_empty() { joined } else { joined.join(rest) };
if let Some(why) = refused_prefix(&next, roots) {
return Some(why);
}
return follow_links(&next, roots, hops_left - 1);
}
None
}
/// How many links [`link_leads_to_refused_prefix`] follows before it stops.
#[cfg(windows)]
const MAX_LINK_HOPS: usize = 40;
/// A Windows prefix that is not a local disk.
#[cfg(windows)]
enum WindowsPrefix {
/// `\\server\share` or `\\?\UNC\server\share`.
Unc(OsString, OsString),
/// `\\.\device`.
Device(OsString),
/// `\\?\` that is neither a disk nor `UNC`.
Verbatim(OsString),
}
#[cfg(windows)]
impl WindowsPrefix {
/// The error text for a path with this prefix.
fn refusal(&self) -> &'static str {
match self {
Self::Unc(_, _) => "UNC paths are refused unless a root is on the same server and share",
Self::Device(_) => "device paths are refused unless a root uses the same device",
Self::Verbatim(_) => "verbatim paths are refused unless a root uses the same prefix",
}
}
}
/// `path`'s Windows prefix when it is not a local disk.
#[cfg(windows)]
fn windows_prefix(path: &Path) -> Option<WindowsPrefix> {
use std::path::Prefix;
let Component::Prefix(prefix) = path.components().next()? else { return None };
match prefix.kind() {
Prefix::Disk(_) | Prefix::VerbatimDisk(_) => None,
Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => Some(WindowsPrefix::Unc(server.to_os_string(), share.to_os_string())),
Prefix::DeviceNS(device) => Some(WindowsPrefix::Device(device.to_os_string())),
Prefix::Verbatim(rest) => Some(WindowsPrefix::Verbatim(rest.to_os_string())),
}
}
/// Whether `path` may be opened because `root` already stands on the same server and share,
/// device or verbatim prefix. ASCII case only.
#[cfg(windows)]
fn prefixes_match(root: &WindowsPrefix, path: &WindowsPrefix) -> bool {
let same = |a: &std::ffi::OsStr, b: &std::ffi::OsStr| a.eq_ignore_ascii_case(b);
match (root, path) {
(WindowsPrefix::Unc(server, share), WindowsPrefix::Unc(path_server, path_share)) => same(server, path_server) && same(share, path_share),
(WindowsPrefix::Device(root_device), WindowsPrefix::Device(path_device)) => same(root_device, path_device),
(WindowsPrefix::Verbatim(root_prefix), WindowsPrefix::Verbatim(path_prefix)) => same(root_prefix, path_prefix),
_ => false,
}
}
/// Is `path` (resolved) `root` or inside it, component by component?
fn inside(path: &Path, root: &Path) -> bool {
let mut path = path.components();
root.components().all(|r| path.next() == Some(r))
}
/// Is `path` (resolved) exactly `root`, compared like [`inside`] does?
fn same(path: &Path, root: &Path) -> bool {
path.components().eq(root.components())
}
/// A Windows device name (`CON`, `NUL`, `COM1`, `LPT¹`… also with an extension or a `:`), which
/// names no file.
fn is_device_name(component: &str) -> bool {
let stem = component.split(['.', ':']).next().unwrap_or(component).trim_end_matches(' ').to_ascii_uppercase();
let numbered = |prefix: &str| {
stem.strip_prefix(prefix).is_some_and(|n| matches!(n, "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "¹" | "²" | "³"))
};
matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CLOCK$" | "CONIN$" | "CONOUT$") || numbered("COM") || numbered("LPT")
}
#[cfg(test)]
mod tests {
use super::*;
/// A folder of a test's own, removed when the test ends, also when it fails.
struct TestDir(PathBuf);
impl std::ops::Deref for TestDir {
type Target = Path;
/// The folder itself.
fn deref(&self) -> &Path {
&self.0
}
}
impl Drop for TestDir {
/// Removes the folder and all it holds; a failure here must not hide the test's own.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder of this test's own: made here, so nothing else put it there first.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cc-file-access-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// A fresh folder holding `in` (read root), `out` (write root) and `outside`.
fn folders(name: &str) -> (TestDir, Arc<AutomationRoots>) {
let base = fresh_dir(name);
for d in ["in/sub", "out", "outside", "in2"] {
std::fs::create_dir_all(base.join(d)).unwrap();
}
std::fs::write(base.join("in/a.dxf"), "0\nEOF\n").unwrap();
std::fs::write(base.join("outside/secret.dxf"), "0\nEOF\n").unwrap();
let roots = AutomationRoots::new(Some(&base.join("in")), Some(&base.join("out"))).unwrap().unwrap();
(base, roots)
}
/// `p` as a string a command would pass.
fn s(p: PathBuf) -> String {
p.to_string_lossy().into_owned()
}
/// Paths under either root may be read; writes stay inside the write root.
#[test]
fn paths_inside_the_roots_pass_and_others_dont() {
let (base, roots) = folders("inside");
assert_eq!(roots.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
assert_eq!(roots.check(s(base.join("in")), Access::Read), Ok(()), "the root itself");
assert_eq!(roots.check(s(base.join("in/sub/new.dxf")), Access::Read), Ok(()), "missing files are checked by their folder");
assert_eq!(roots.check(s(base.join("out/new/deeper/x.png")), Access::Write), Ok(()), "and by their nearest folder");
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
assert!(e.starts_with("automation path rejected: outside the read root"), "{e}");
// Reads are allowed under the write root too; writes are not allowed under the read root.
assert_eq!(roots.check(s(base.join("out/x.png")), Access::Read), Ok(()), "the write root also grants reads");
let e = roots.check(s(base.join("in/a.dxf")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
}
/// A write-only root still permits reads inside it; reads outside both roots are refused.
#[test]
fn reads_are_allowed_under_either_root() {
let (base, _) = folders("either");
let write_only = AutomationRoots::new(None, Some(&base.join("out"))).unwrap().unwrap();
assert_eq!(write_only.check(s(base.join("out/new.dxf")), Access::Read), Ok(()), "a file to read back");
let e = write_only.check(s(base.join("in/a.dxf")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root (or the write root)"), "{e}");
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
assert_eq!(read_only.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
assert!(read_only.check(s(base.join("out/new.dxf")), Access::Read).is_err(), "a read root alone grants no read of another folder");
}
/// A write to the write root itself would put its `.cadcraft-tmp` file beside the root: refused.
#[test]
fn writing_to_the_write_root_itself_is_refused() {
let (base, roots) = folders("write-root");
let out = s(base.join("out"));
let sep = std::path::MAIN_SEPARATOR;
for p in [out.clone(), format!("{out}{sep}."), format!("{out}{sep}..{sep}out")] {
let e = roots.check(&p, Access::Write).unwrap_err();
assert!(e.contains("the write root itself cannot be written"), "{p}: {e}");
}
assert_eq!(roots.check(&out, Access::Read), Ok(()), "reading the root stays allowed");
assert_eq!(roots.check(s(base.join("out/new/x.png")), Access::Write), Ok(()), "a normal save inside still works");
}
/// `in2` starts like `in` and isn't inside it.
#[test]
fn a_sibling_with_the_same_prefix_is_outside() {
let (base, roots) = folders("prefix");
std::fs::write(base.join("in2/b.dxf"), "0\nEOF\n").unwrap();
assert!(roots.check(s(base.join("in2/b.dxf")), Access::Read).is_err(), "in2 is not inside in");
assert!(roots.check(format!("{}2/c.dxf", s(base.join("in"))), Access::Read).is_err());
}
/// `..` is followed where it can be, and refused below a missing folder.
#[test]
fn parent_traversal_is_resolved_or_refused() {
let (base, roots) = folders("dotdot");
let sep = std::path::MAIN_SEPARATOR;
let up = format!("{}{sep}..{sep}outside{sep}secret.dxf", s(base.join("in")));
assert!(roots.check(&up, Access::Read).unwrap_err().contains("outside the read root"), "`..` out of the root");
let back = format!("{}{sep}..{sep}a.dxf", s(base.join("in/sub")));
assert_eq!(roots.check(&back, Access::Read), Ok(()), "`..` that stays inside");
let missing = format!("{}{sep}nope{sep}..{sep}..{sep}outside{sep}x.dxf", s(base.join("out")));
let e = roots.check(&missing, Access::Write).unwrap_err();
// Windows resolves `..` by name first (so does opening the file there): then it's outside.
assert!(e.contains("parent traversal below a folder that doesn't exist") || e.contains("outside the write root"), "{e}");
}
/// A relative path means the working directory, and an empty one is refused.
#[test]
fn relative_paths_resolve_against_the_working_directory() {
let (_base, roots) = folders("relative");
// The tests' working directory is the crate's folder: not inside the roots.
assert!(roots.check("a.dxf", Access::Read).unwrap_err().contains("outside the read root"));
assert!(roots.check("", Access::Read).unwrap_err().contains("path is empty"));
}
/// A root must be a folder that exists; no roots at all confines nothing.
#[test]
fn a_missing_root_is_an_error_and_none_is_no_confinement() {
let (base, _) = folders("missing");
let e = AutomationRoots::new(Some(&base.join("nope")), None).unwrap_err();
assert!(e.starts_with("cannot open the automation read root"), "{e}");
let e = AutomationRoots::new(None, Some(&base.join("in/a.dxf"))).unwrap_err();
assert!(
e.starts_with("cannot open the automation write root")
&& e.ends_with(&std::io::Error::from(std::io::ErrorKind::NotADirectory).to_string()),
"{e}"
);
assert!(AutomationRoots::new(Some(Path::new("")), None).unwrap_err().starts_with("cannot open the automation read root ``"));
assert!(AutomationRoots::new(None, None).unwrap().is_none());
// One root alone grants only its own access.
let read_only = AutomationRoots::new(Some(&base.join("in")), None).unwrap().unwrap();
let e = read_only.check(s(base.join("in/x.dxf")), Access::Write).unwrap_err();
assert!(e.contains("write authority is absent"), "{e}");
}
/// Links are judged by where they lead, so a link out is refused and one inside is fine.
#[test]
fn links_are_followed_before_comparing() {
let (base, roots) = folders("links");
#[cfg(unix)]
let made = |target: &Path, link: &Path| std::os::unix::fs::symlink(target, link).is_ok();
#[cfg(windows)]
let made = |target: &Path, link: &Path| {
let made =
if target.is_dir() { std::os::windows::fs::symlink_dir(target, link) } else { std::os::windows::fs::symlink_file(target, link) };
made.is_ok()
};
#[cfg(not(any(unix, windows)))]
let made = |_: &Path, _: &Path| false;
// Windows needs Developer Mode or elevation to make links: nothing to test without them.
if !made(&base.join("outside/secret.dxf"), &base.join("in/leak.dxf")) {
eprintln!("skipped: symbolic links can't be made here");
return;
}
assert!(roots.check(s(base.join("in/leak.dxf")), Access::Read).unwrap_err().contains("outside the read root"), "a file link out");
assert!(made(&base.join("outside"), &base.join("out/away")));
let e = roots.check(s(base.join("out/away/new.png")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "a folder link out: {e}");
assert!(made(&base.join("outside/gone.dxf"), &base.join("out/dangling.png")));
let e = roots.check(s(base.join("out/dangling.png")), Access::Write).unwrap_err();
assert!(e.contains("a link that leads nowhere"), "writing would create the file outside: {e}");
// A link to a folder inside the root stays inside.
assert!(made(&base.join("in/sub"), &base.join("in/alias")));
assert_eq!(roots.check(s(base.join("in/alias/x.dxf")), Access::Read), Ok(()));
// A root given through a link is the folder it leads to.
assert!(made(&base.join("in"), &base.join("in-link")));
let linked = AutomationRoots::new(Some(&base.join("in-link")), None).unwrap().unwrap();
assert_eq!(linked.check(s(base.join("in/a.dxf")), Access::Read), Ok(()));
}
/// Names are compared exactly: `Root` isn't `root`, which a case-sensitive folder can hold beside it.
#[test]
fn a_name_differing_only_in_case_is_not_the_root() {
assert!(!inside(Path::new("/w/Root/x"), Path::new("/w/root")));
assert!(!same(Path::new("/w/Root"), Path::new("/w/root")));
assert!(inside(Path::new("/w/root/x"), Path::new("/w/root")));
assert!(same(Path::new("/w/root"), Path::new("/w/root")));
}
/// The superscript ports, `COM0`, `LPT0` and the `:` form are device names.
#[test]
fn device_names_include_the_superscript_ports() {
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.dxf", "NUL ", "COM¹", "lpt³.txt", "com²", "NUL:", "con:stream", "COM0", "lpt0.txt"] {
assert!(is_device_name(d), "{d}");
}
for d in ["console.txt", "COM", "COM10", "LPT⁴", "a.nul", "nullable"] {
assert!(!is_device_name(d), "{d}");
}
}
/// A name that isn't text is checked as itself: the text of it names a file that isn't there,
/// which would pass, when the name itself is a link leading out.
#[cfg(unix)]
#[test]
fn a_name_that_is_not_text_is_judged_as_itself() {
use std::os::unix::ffi::OsStrExt;
let (base, roots) = folders("not-text");
let name = std::ffi::OsStr::from_bytes(b"a\xff.dxf");
let link = base.join("in").join(name);
// APFS and others refuse such a name: nothing to test there.
if std::os::unix::fs::symlink(base.join("outside/secret.dxf"), &link).is_err() {
eprintln!("skipped: this file system refuses a name that isn't text");
return;
}
assert!(roots.check(&link, Access::Read).is_err());
assert_eq!(roots.check(&*link.to_string_lossy(), Access::Read), Ok(()), "as text it is another file, which isn't there");
}
/// A name is judged by the folder it stands in as well as by where it leads.
#[cfg(unix)]
#[test]
fn a_link_standing_outside_the_write_root_is_refused() {
let (base, roots) = folders("entry");
std::fs::write(base.join("out/t.dxf"), "x").unwrap();
let link = base.join("outside/link.dxf");
std::os::unix::fs::symlink(base.join("out/t.dxf"), &link).unwrap();
assert!(roots.check(&link, Access::Write).unwrap_err().contains("stands outside the write root"));
assert_eq!(roots.check(&link, Access::Read), Ok(()), "reading it reads what is inside");
let inner = base.join("out/link.dxf");
std::os::unix::fs::symlink(base.join("out/t.dxf"), &inner).unwrap();
assert_eq!(roots.check(&inner, Access::Write), Ok(()));
assert_eq!(roots.check(base.join("out/new/deep/x.dxf"), Access::Write), Ok(()));
}
/// On a real case-sensitive folder, `Root` beside the root `root` is outside it.
#[cfg(windows)]
#[test]
fn a_case_sensitive_windows_folder_can_hold_a_sibling_of_the_root() {
let base = fresh_dir("sensitive");
let sensitive = std::process::Command::new("fsutil").args(["file", "setCaseSensitiveInfo"]).arg(&*base).arg("enable").output();
if !sensitive.is_ok_and(|o| o.status.success()) {
eprintln!("this runner can't make a case-sensitive folder: skipped");
return;
}
std::fs::create_dir(base.join("root")).unwrap();
std::fs::create_dir(base.join("Root")).unwrap();
std::fs::write(base.join("Root/secret.dxf"), "x").unwrap();
let roots = AutomationRoots::new(Some(&base.join("root")), Some(&base.join("root"))).unwrap().unwrap();
for p in ["Root/secret.dxf", "Root/new.dxf"] {
assert!(roots.check(s(base.join(p)), Access::Read).is_err(), "{p}");
assert!(roots.check(s(base.join(p)), Access::Write).is_err(), "{p}");
}
assert_eq!(roots.check(s(base.join("root/new.dxf")), Access::Write), Ok(()));
}
/// On an ordinary Windows folder any case finds the root, and device names are refused.
#[cfg(windows)]
#[test]
fn windows_gives_a_root_its_real_spelling_and_refuses_devices() {
let (base, roots) = folders("case");
let upper = s(base.join("IN/A.DXF"));
assert_eq!(roots.check(upper.as_str(), Access::Read), Ok(()), "{upper}");
assert_eq!(roots.check(s(base.join("In/Sub/New.dxf")), Access::Read), Ok(()));
let e = roots.check(s(base.join("out/NUL")), Access::Write).unwrap_err();
assert!(e.contains("reserved device names"), "{e}");
assert!(roots.check(s(base.join("out/com1.txt")), Access::Write).is_err());
assert!(roots.check(s(base.join("out/COM¹")), Access::Write).is_err());
assert_eq!(roots.check(s(base.join("out/console.txt")), Access::Write), Ok(()));
}
/// A network, device or non-disk verbatim path is refused before the file system is asked.
/// The error names the prefix. It is not the error canonicalize would return.
#[cfg(windows)]
#[test]
fn a_network_path_is_refused_before_it_is_opened() {
let (base, roots) = folders("unc");
let paths = [
(r"\\203.0.113.5\s\x.dwg", "UNC"),
(r"\\?\UNC\203.0.113.5\s\x.dwg", "UNC"),
(r"//203.0.113.5/s/x.dwg", "UNC"),
(r"\\host@SSL\share\x.dwg", "UNC"),
(r"\\host@SSL@443\share\x.dwg", "UNC"),
(r"\\.\PhysicalDrive0", "device path"),
(r"\\?\Volume{00000000-0000-0000-0000-000000000000}\x.dwg", "verbatim path"),
];
for (p, kind) in paths {
for access in [Access::Read, Access::Write] {
let e = roots.check(p, access).unwrap_err();
assert!(e.starts_with("automation path rejected:"), "{p}: {e}");
assert!(e.contains(kind), "{p}: {e}");
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{p}: {e}");
}
}
let e = roots.check(s(base.join("outside/secret.dxf")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root"), "{e}");
let root = windows_prefix(Path::new(r"\\?\UNC\FileServer\Projects\work")).unwrap();
let same = windows_prefix(Path::new(r"\\fileserver\projects\a.dwg")).unwrap();
let other_share = windows_prefix(Path::new(r"\\fileserver\secret\a.dwg")).unwrap();
let other_host = windows_prefix(Path::new(r"\\203.0.113.5\Projects\a.dwg")).unwrap();
let kelvin = windows_prefix(Path::new("\\\\wor\u{212a}\\Projects\\a.dwg")).unwrap();
assert!(prefixes_match(&root, &same), "the same server and share, in either spelling");
assert!(!prefixes_match(&root, &other_share));
assert!(!prefixes_match(&root, &other_host));
assert!(!prefixes_match(&root, &kelvin), "U+212A is not k");
assert!(windows_prefix(Path::new(r"C:\Projects\a.dwg")).is_none());
assert!(windows_prefix(Path::new(r"\\?\C:\Projects\a.dwg")).is_none());
}
/// U+212A is a different folder from `k`, so a write there is outside the root and creates nothing.
#[cfg(windows)]
#[test]
fn a_kelvin_sign_is_not_a_way_out_of_the_write_root() {
let base = fresh_dir("kelvin");
let root = base.join("work");
std::fs::create_dir(&root).unwrap();
let roots = AutomationRoots::new(Some(&root), Some(&root)).unwrap().unwrap();
let sibling = base.join("wor\u{212a}").join("x.dwg");
let e = roots.check(s(sibling), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
assert!(!base.join("wor\u{212a}").exists(), "the check must not create the folder");
assert_eq!(roots.check(s(root.join("new.dxf")), Access::Write), Ok(()));
}
/// A junction needs no extra privilege. One that leads out of the write root is outside it.
#[cfg(windows)]
#[test]
fn a_junction_out_of_the_write_root_is_refused() {
let (base, roots) = folders("junction");
let link = base.join("out").join("away");
let made = std::process::Command::new("cmd").args(["/c", "mklink", "/J"]).arg(&link).arg(base.join("outside")).status();
if !made.is_ok_and(|s| s.success()) {
eprintln!("skipped: junctions can't be made here");
return;
}
let e = roots.check(s(link.join("new.png")), Access::Write).unwrap_err();
assert!(e.contains("outside the write root"), "{e}");
assert!(!base.join("outside/new.png").exists());
}
/// A link whose text names a network path is refused before that path is opened.
#[cfg(windows)]
#[test]
fn a_link_to_a_network_path_is_refused_before_it_is_followed() {
let (base, roots) = folders("unc-link");
let link = base.join("in/leak.dxf");
if std::os::windows::fs::symlink_file(r"\\203.0.113.5\s\x.dwg", &link).is_err() {
eprintln!("skipped: symbolic links can't be made here");
return;
}
let e = roots.check(link.as_path(), Access::Read).unwrap_err();
assert!(e.contains("UNC"), "{e}");
assert!(!e.contains("cannot resolve") && !e.to_ascii_lowercase().contains("os error"), "{e}");
}
/// An alternate data stream is still the file it hangs off: outside the roots it is refused.
#[cfg(windows)]
#[test]
fn an_alternate_stream_outside_the_roots_is_refused() {
let (base, roots) = folders("ads");
let e = roots.check(s(base.join("outside/secret.dxf:zone")), Access::Read).unwrap_err();
assert!(e.contains("outside the read root"), "{e}");
assert_eq!(roots.check(s(base.join("out/new.dxf:zone")), Access::Write), Ok(()));
}
/// Roots end with their scope, also when a nested scope or a panic ends it.
#[test]
fn scopes_nest_and_restore_after_a_panic() {
let (base, roots) = folders("scopes");
let outside = s(base.join("outside/secret.dxf"));
assert_eq!(check_read(&outside), Ok(()), "nothing is confined by default");
confine(Some(&roots), || {
assert!(check_read(&outside).is_err());
// A nested scope replaces the outer one and gives it back on the way out.
confine(None, || assert_eq!(check_read(&outside), Ok(())));
assert!(check_read(&outside).is_err(), "restored after the inner scope");
});
assert_eq!(check_read(&outside), Ok(()), "restored after confine");
let r = std::panic::catch_unwind(|| confine(Some(&roots), || panic!("boom")));
assert!(r.is_err());
assert_eq!(check_read(&outside), Ok(()), "restored after a panic");
assert_eq!(confine(None, || check_read(&outside)), Ok(()));
}
/// The plain device names, and names that only look like them.
#[test]
fn device_names() {
for d in ["CON", "nul", "Com1", "LPT9.txt", "aux.svg", "NUL "] {
assert!(is_device_name(d), "{d}");
}
for f in ["console", "com10", "lpt", "a.svg", "nul-x"] {
assert!(!is_device_name(f), "{f}");
}
}
}
-552
View File
@@ -1,552 +0,0 @@
//! Which commands automation may run while the automation roots are in force ([`super`]).
//!
//! The checks that hold a path to the roots sit where the file is touched, and a new command that
//! touches a file through a new route would get past them. So a command runs under the roots only
//! if it is listed here: anything else is refused, whatever it does. Adding a command to the
//! registry means adding it to one of these lists (`every_command_is_classified` says so).
/// Commands that read or write files, each path held to the roots where the file is touched.
pub const FILES: &[&str] = &[
"-linetype",
"-plottermanager",
"-wblock",
"-xref",
"aliasedit",
"appload",
"attach",
"blocklibimport",
"blocklibrary",
"audit",
"compare",
"compareexport",
"dataextraction",
"datalink",
"datalinkupdate",
"eattext",
"export",
"exportpdf",
"hatch",
"hatch.patterns",
"image",
"imageattach",
"import",
"insert",
"layout",
"layout.saveas",
"linetype",
"lisp",
"minsert",
"new",
"open",
"options",
"pagesetup",
"pdfbook",
"plot",
"plotstyle",
"plottermanager",
"preview",
"publish",
"qsave",
"recover",
"reinit",
"saveas",
"script",
"setvar",
"share",
"stylesmanager",
"tableexport",
"wblock",
"xattach",
"xbind",
"xopen",
"xref",
];
/// Commands that can't be held to the roots, and why.
pub const REFUSED: &[(&str, &str)] = &[
("drawingrecovery", "it works on the autosave folder (SAVEFILEPATH), which is the server's own"),
("blocklibraries", "it keeps its list of libraries in the settings folder, which is the server's own"),
];
/// Commands that touch no file.
pub const NO_FILES: &[&str] = &[
"blockspalette",
"dimoverride.clear",
"-dimstyle",
"dimstyle.overrides",
"dimstyle.saveas",
"properties.describe",
"close",
"closeall",
"document.switch",
"document.bytes",
"u",
"undo",
"redo",
"mredo",
"cutclip",
"cutbase",
"copyclip",
"copybase",
"pasteclip",
"pasteblock",
"pasteorig",
"erase.selection",
"selectall",
"ai_deselect",
"select",
"qselect",
"qselect.info",
"selectsimilar",
"isolateobjects",
"hideobjects",
"unisolateobjects",
"xclip",
"xclipframe",
"zoom",
"zoom.realtime",
"zoom.dynamic",
"zoom.previous",
"zoom.window",
"zoom.in",
"zoom.out",
"zoom.all",
"zoom.extents",
"zoom.object",
"pan",
"pan.left",
"pan.right",
"pan.up",
"pan.down",
"regen",
"regenall",
"redraw",
"dview",
"view.set",
"view.get",
"layout.set",
"view",
"-vports",
"vports.activate",
"vports.named",
"line",
"pline",
"circle",
"arc",
"rectang",
"polygon",
"ellipse",
"point",
"point.multiple",
"xline",
"ray",
"spline",
"donut",
"solid",
"text",
"mtext",
"arc.sce",
"arc.sca",
"arc.scl",
"arc.sea",
"arc.sed",
"arc.ser",
"arc.cse",
"arc.csa",
"arc.csl",
"arc.continue",
"circle.cd",
"circle.2p",
"circle.3p",
"circle.ttr",
"circle.ttt",
"ellipse.axis",
"ellipse.arc",
"divide",
"measure",
"revcloud",
"revcloud.polygonal",
"revcloud.freehand",
"wipeout",
"3dpoly",
"helix",
"spline.cv",
"centermark",
"centerline",
"mline",
"mlstyle",
"mledit",
"breakline",
"dimlinear",
"dimaligned",
"dimradius",
"dimdiameter",
"dimangular",
"dimarc",
"dimordinate",
"dimcontinue",
"dimbaseline",
"qdim",
"dim",
"mleader",
"leader",
"dimstyle.update",
"dimoverride",
"dimreassociate",
"dimdisassociate",
"dimtedit.home",
"dimtedit.angle",
"dimtedit.left",
"dimtedit.center",
"dimtedit.right",
"dimtedit",
"dimspace",
"dimedit",
"dimedit.oblique",
"dimjogged",
"dimjogline",
"dimbreak",
"diminspect",
"mleaderedit",
"mleaderedit.add",
"mleaderedit.remove",
"mleaderalign",
"mleadercollect",
"scalelistedit",
"objectscale",
"aiobjectscaleadd",
"aiobjectscaleremove",
"annoreset",
"annoupdate",
"annovisible.current",
"annovisible.all",
"annovisible.toggle",
"gradient",
"boundary",
"region",
"hatchedit",
"hatchpick",
"overkill",
"block",
"-block",
"attdef",
"attedit",
"-attedit",
"base",
"blocks.dynamic",
"blocks.reference",
"blocks.reference.set",
"blocks.reference.grips",
"blocks.reference.grip",
"purge",
"blocks.list",
"battman",
"attdisp",
"attsync",
"burst",
"blockreplace",
"blocks.description",
"attdisp.normal",
"attdisp.on",
"attdisp.off",
"refedit",
"refset",
"refclose",
"bedit",
"bsave",
"bsaveas",
"bclose",
"erase",
"oops",
"move",
"copy",
"rotate",
"scale",
"mirror",
"stretch",
"offset",
"trim",
"extend",
"fillet",
"chamfer",
"explode",
"break",
"breakatpoint",
"join",
"draworder",
"draworder.front",
"draworder.back",
"draworder.above",
"draworder.under",
"texttofront",
"texttofront.text",
"texttofront.dimensions",
"texttofront.leaders",
"texttofront.all",
"hatchtoback",
"array",
"arrayrect",
"arraypolar",
"-array",
"arrayedit",
"arrayclose",
"pedit",
"splinedit",
"lengthen",
"align",
"blend",
"reverse",
"ncopy",
"mocoro",
"chspace",
"flatten",
"arraypath",
"textedit",
"group",
"ungroup",
"groupedit",
"groups.list",
"-group",
"pickstyle",
"grip.move",
"grip.stretch",
"grip.rotate",
"grip.scale",
"grip.mirror",
"grip.option",
"grip",
"compare.next",
"compare.previous",
"compareclose",
"layer",
"layer.new",
"layer.set",
"layer.current",
"layer.delete",
"laymcur",
"laymch",
"laycur",
"layiso",
"layuniso",
"layfrz",
"layoff",
"laylck",
"layulk",
"layon",
"laythw",
"layerp",
"layerstate.save",
"layerstate.restore",
"layerstate.list",
"layerstate.delete",
"layerstate.rename",
"laymrg",
"laydel",
"layout.new",
"layout.delete",
"layout.rename",
"layout.copy",
"layout.list",
"mview",
"mview.polygonal",
"vpclip",
"vports",
"vports.1",
"vports.2",
"vports.3",
"vports.4",
"viewport.set",
"vplayer",
"mspace",
"pspace",
"plotwindow",
"3dorbit",
"properties",
"properties.set",
"chprop",
"change",
"matchprop",
"color",
"lweight",
"ltscale",
"units",
"-units",
"thickness",
"limits",
"style",
"style.list",
"style.rename",
"style.delete",
"style.current",
"dimstyle",
"dimstyle.dimension",
"dimstyle.list",
"dimstyle.rename",
"dimstyle.delete",
"dimstyle.current",
"dimstyle.override",
"tablestyle",
"mleaderstyle",
"ddptype",
"rename",
"dist",
"id",
"list",
"area",
"time",
"status",
"drawing.inspect",
"entities",
"shapes",
"usage",
"loops",
"texts",
"countlist",
"counttable",
"count",
"union",
"subtract",
"intersect",
"massprop",
"ortho",
"grid",
"snap",
"polar",
"otrack",
"dynmode",
"lwdisplay",
"isodraft",
"isoplane",
"transparencydisplay",
"qpmode",
"selectioncycling",
"osnap",
"dsettings",
"getvar",
"sysvars",
"cal",
"quickcalc.pick",
"find",
"measuregeom",
"radius.measure",
"angle.measure",
"volume.measure",
"table",
"table.set",
"table.insertrow",
"table.deleterow",
"table.insertcol",
"table.deletecol",
"table.merge",
"table.unmerge",
"tablestyle.cellstyle",
"table.cellstyle",
"table.formula",
"table.recalc",
"tabledit",
"table.break",
"tolerance",
"txt2mtxt",
"geomconstraint",
"gccoincident",
"gcperpendicular",
"gcparallel",
"gctangent",
"gchorizontal",
"gcvertical",
"gccollinear",
"gcconcentric",
"gcsmooth",
"gcsymmetric",
"gcequal",
"gcfix",
"autoconstrain",
"constraintbar",
"constraintbar.showall",
"constraintbar.hideall",
"dimconstraint",
"dcaligned",
"dchorizontal",
"dcvertical",
"dcangular",
"dcradius",
"dcdiameter",
"dclinear",
"dcdisplay",
"dcdisplay.showall",
"dcdisplay.hideall",
"delconstraint",
"parameters",
"constraintsettings",
"constraintinfer",
"constraints.inspect",
"constraints.dof",
];
/// Why command `id` may not run here; `None` when it may. Without roots in force everything may.
pub fn refusal(id: &str) -> Option<String> {
super::current()?;
if let Some((_, why)) = REFUSED.iter().find(|(c, _)| *c == id) {
return Some(format!("automation command refused: {why}"));
}
if FILES.contains(&id) || NO_FILES.contains(&id) {
return None;
}
Some("automation command refused: it is not classified for the automation roots".to_string())
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::panic)]
mod tests {
use super::super::{AutomationRoots, confine};
use super::*;
use std::collections::BTreeSet;
/// Words in a command's parameter doc that usually name a file. In these commands they don't:
/// `array` and `arraypath` follow a path of objects, and `blocks.reference.grips` reports a
/// direction.
const NOT_FILES: &[&str] = &["array", "arraypath", "blocks.reference.grips"];
/// The words of a command's documentation, lower case.
fn words(doc: &str) -> BTreeSet<String> {
doc.to_ascii_lowercase().split(|c: char| !c.is_ascii_alphanumeric()).map(str::to_string).collect()
}
/// Walks the registry: every command is on exactly one list, and the lists name no command
/// that is gone. A command whose parameters name a file can't be on the no-files list.
#[test]
fn every_command_is_classified() {
let refused: Vec<&str> = REFUSED.iter().map(|(c, _)| *c).collect();
let lists = [FILES, refused.as_slice(), NO_FILES];
let specs = crate::command_specs();
for spec in specs {
let on = lists.iter().filter(|l| l.contains(&spec.id)).count();
assert_eq!(on, 1, "`{}` is on {on} lists: add it to one in file_access/commands.rs", spec.id);
let doc = words(spec.params);
let names_a_file = ["path", "file", "template", "patternfile", "folder", "dir"].iter().any(|w| doc.contains(*w));
if names_a_file && NO_FILES.contains(&spec.id) && !NOT_FILES.contains(&spec.id) {
panic!("`{}` takes a file ({}): it belongs on FILES, with its paths checked", spec.id, spec.params);
}
}
for id in lists.iter().flat_map(|l| l.iter()) {
assert!(specs.iter().any(|s| s.id == *id), "`{id}` is listed but no longer a command");
}
}
/// Under roots a command nobody classified is refused; without roots it isn't this table's business.
#[test]
fn an_unclassified_command_fails_closed() {
let base = std::env::temp_dir().join(format!("cc-commands-{}", std::process::id()));
std::fs::create_dir_all(&base).unwrap();
let roots = AutomationRoots::new(Some(&base), None).unwrap();
assert_eq!(refusal("made.up"), None);
confine(roots.as_ref(), || {
assert!(refusal("made.up").unwrap().contains("not classified"));
assert!(refusal("drawingrecovery").unwrap().contains("autosave"));
assert!(refusal("blocklibraries").unwrap().contains("settings folder"));
assert_eq!(refusal("open"), None);
assert_eq!(refusal("line"), None);
});
let _ = std::fs::remove_dir_all(base);
}
}
-1
View File
@@ -18,7 +18,6 @@ pub mod blockedit;
pub mod capped_read;
pub mod cmd;
pub mod doc_path;
pub mod file_access;
mod finite;
pub mod grip_dims;
pub mod grips;
+2 -9
View File
@@ -13,7 +13,6 @@ pub struct LispFile {
pub text: String,
}
/// LISP `open`: a file handle, or nil when the file can't be opened or the automation roots refuse it.
pub(super) fn open(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError> {
arity(&a, 2, 3)?;
let path = string(&a[0])?.to_string();
@@ -39,7 +38,7 @@ pub(super) fn open(ctx: &mut Ctx<'_>, a: Vec<Value>) -> Result<Flow, LispError>
}
None => return Ok(Flow::Value(Value::Nil)),
}
} else if crate::file_access::check_write(&path).is_err() || !can_write(&path) {
} else if !can_write(&path) {
return Ok(Flow::Value(Value::Nil));
}
let id = ctx.env.next_file;
@@ -84,7 +83,6 @@ pub fn read_text_file(path: impl AsRef<std::path::Path>) -> Option<String> {
// Read through a byte-limited, regular-file-only reader so a path naming an endless device
// cannot exhaust memory before the 64 MiB cap is enforced (CWE-400).
const MAX: usize = 64 * 1024 * 1024;
crate::file_access::check_read(path.as_ref()).ok()?;
let bytes = crate::capped_read::read_capped(path.as_ref(), MAX).ok()?;
Some(String::from_utf8_lossy(&bytes).into_owned())
}
@@ -105,13 +103,9 @@ fn can_write(_path: &str) -> bool {
false
}
/// Write or append `text`, doing nothing when the automation roots refuse the path.
#[cfg(not(target_arch = "wasm32"))]
fn write_text_file(path: &str, text: &str, append: bool) {
use std::io::Write;
if crate::file_access::check_write(path).is_err() {
return;
}
// Opened without blocking and without truncating, so a FIFO with no reader fails at once
// instead of stalling the interpreter; only a regular file is then truncated and written.
let mut o = std::fs::OpenOptions::new();
@@ -133,11 +127,10 @@ fn write_text_file(path: &str, text: &str, append: bool) {
fn write_text_file(_path: &str, _text: &str, _append: bool) {}
/// A file or a folder: routines test whether a module is installed with `(findfile "module/.")`.
/// Outside the automation roots the answer is no.
#[cfg(not(target_arch = "wasm32"))]
fn file_exists(path: &str) -> bool {
let p = std::path::Path::new(path);
crate::file_access::check_read(p).is_ok() && (p.is_file() || p.is_dir())
p.is_file() || p.is_dir()
}
#[cfg(target_arch = "wasm32")]
+1 -5
View File
@@ -64,11 +64,7 @@ pub(super) fn list(a: &[Value]) -> R {
pub(super) fn append(a: &[Value]) -> R {
let mut items = Vec::new();
for v in a {
let l = list_arg(v)?;
// Check the result's cells before holding them: the same long list given many times
// would otherwise grow far past the cell cap inside this one call (#1930).
super::super::value::check_new_cells(items.len().saturating_add(l.len()))?;
items.extend(l);
items.extend(list_arg(v)?);
}
Ok(Value::list(items))
}
+4 -17
View File
@@ -1228,23 +1228,10 @@ pub fn load_source(s: &Session, name: &str) -> Option<String> {
}
let candidates =
if std::path::Path::new(name).extension().is_none() { vec![format!("{name}.lsp"), name.to_string()] } else { vec![name.to_string()] };
// An absolute path is read as given. A relative name is looked up in the support folder only,
// never in the process working folder: that can be the folder of a drawing just opened from a
// file manager, and a `tools.lsp` shipped beside it must not answer a startup file's
// `(load "tools")` (#1927). Without a support folder (the command-line tool, which has no
// startup files) a relative name is read as given.
let dir = match s.lisp_support_dir() {
Some(d) if !std::path::Path::new(name).is_absolute() => d,
_ => return candidates.iter().find_map(super::builtins::read_text_file),
};
// A relative name stays inside the support folder: plain folder and file names only. `..` would
// climb out of it, and on Windows a rooted name (`\tools`) or a drive-relative one (`C:tools`,
// the working folder of drive C) is not absolute, yet joined to the folder it replaces it.
use std::path::Component;
if !std::path::Path::new(name).components().all(|c| matches!(c, Component::Normal(_) | Component::CurDir)) {
return None;
}
candidates.iter().find_map(|c| super::builtins::read_text_file(dir.join(c)))
// As given (a path, or relative to the working folder), then in the support folder.
let support =
s.lisp_support_dir().map(|d| candidates.iter().map(|c| d.join(c).to_string_lossy().into_owned()).collect::<Vec<_>>()).unwrap_or_default();
candidates.iter().chain(&support).find_map(super::builtins::read_text_file)
}
#[cfg(test)]
-71
View File
@@ -1480,74 +1480,3 @@ fn atof_out_of_range_exponent_reads_whole_token() {
assert_eq!(ok(&mut s, "(< (atof \"-1e400\") -1e300)"), "T");
assert_eq!(ok(&mut s, "(= (atof \"1e-400\") 0.0)"), "T");
}
/// #1927: with a support folder, a relative `load` name is found there, never through the
/// process working folder; an absolute path is still read as given.
#[cfg(unix)]
#[test]
fn relative_load_uses_the_support_folder_not_the_working_folder() {
let base = std::env::temp_dir().join(format!("cadcraft-lisp-loadpath-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
let (support, other) = (base.join("support"), base.join("other"));
std::fs::create_dir_all(&support).unwrap();
std::fs::create_dir_all(&other).unwrap();
std::fs::write(support.join("tools.lsp"), "(setq which \"support\")").unwrap();
std::fs::write(other.join("tools.lsp"), "(setq which \"other\")").unwrap();
std::fs::write(other.join("only.lsp"), "(setq only 1)").unwrap();
// `other/…` as a path relative to the working folder.
let cwd = std::env::current_dir().unwrap();
let up = "../".repeat(cwd.components().count().saturating_sub(1));
let rel = |f: &str| format!("{up}{}", other.join(f).to_string_lossy().trim_start_matches('/'));
let mut s = session();
s.set_lisp_support_dir(Some(support.clone()));
assert_eq!(ok(&mut s, "(load \"tools\") which"), "\"support\"");
let r = eval(&mut s, &format!("(load \"{}\") only", rel("only.lsp")));
assert!(!matches!(r.as_deref(), Ok("1")), "not read through the working folder: {r:?}");
assert_eq!(ok(&mut s, &format!("(load \"{}\") which", other.join("tools.lsp").to_string_lossy())), "\"other\"");
let _ = std::fs::remove_dir_all(&base);
}
/// #1927 on Windows: a rooted name (`\folder\tools.lsp`, no drive) or a drive-relative one
/// (`C:tools`) is not absolute, but joined to the support folder it replaces that folder; such a
/// name is refused rather than read from outside the support folder.
#[cfg(windows)]
#[test]
fn rooted_and_drive_relative_load_names_stay_in_the_support_folder() {
let base = std::env::temp_dir().join(format!("cadcraft-lisp-rooted-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&base);
let (support, other) = (base.join("support"), base.join("other"));
std::fs::create_dir_all(&support).unwrap();
std::fs::create_dir_all(&other).unwrap();
let outside = other.join("only.lsp");
std::fs::write(&outside, "(setq only 1)").unwrap();
// The same file without its drive (`\Users\...\other\only.lsp`), escaped for a LISP string.
let full = outside.to_string_lossy().into_owned();
let rooted = full.get(full.find('\\').unwrap()..).unwrap().replace('\\', "\\\\");
let drive = full.get(..2).unwrap().to_string();
let mut s = session();
s.set_lisp_support_dir(Some(support.clone()));
let r = eval(&mut s, &format!("(load \"{rooted}\") only"));
assert!(!matches!(r.as_deref(), Ok("1")), "a rooted name is not read outside the support folder: {r:?}");
let r = eval(&mut s, &format!("(load \"{drive}only\") only"));
assert!(!matches!(r.as_deref(), Ok("1")), "a drive-relative name is refused: {r:?}");
std::fs::write(support.join("only.lsp"), "(setq only 2)").unwrap();
assert_eq!(ok(&mut s, "(load \".\\\\only\") only"), "2", "a plain relative name is still read from the support folder");
let _ = std::fs::remove_dir_all(&base);
}
/// #1930: `append` over many references to one long list is refused before it builds the
/// result, not after it has filled memory.
#[test]
fn append_checks_the_cell_cap_before_building_its_result() {
let _heavy = super::value::HEAVY_CELLS.lock().unwrap_or_else(|e| e.into_inner());
let mut s = session();
s.lisp.limits.cells = 50_000;
let before = super::value::live_cells();
let e =
eval(&mut s, "(setq l nil) (repeat 10000 (setq l (cons 1 l))) (setq m nil) (repeat 1000 (setq m (cons l m))) (apply 'append m)").unwrap_err();
assert!(e.contains("too many list cells"), "{e}");
assert!(super::value::live_cells() < before + 50_000, "no oversized result was built");
assert_eq!(ok(&mut s, "(setq l nil m nil) (length (append '(1) '(2 3)))"), "3");
}
-6
View File
@@ -76,12 +76,6 @@ pub fn check_cells() -> Result<(), LispError> {
if live_cells() > CELL_LIMIT.with(Cell::get) { Err(LispError::quit("out of memory: too many list cells")) } else { Ok(()) }
}
/// `n` more cons cells would exceed the cap: checked before a built-in allocates a result many
/// times the size of its arguments (`append` over the same long list, #1930).
pub fn check_new_cells(n: usize) -> Result<(), LispError> {
if live_cells().saturating_add(n) > CELL_LIMIT.with(Cell::get) { Err(LispError::quit("out of memory: too many list cells")) } else { Ok(()) }
}
/// Start a slice of a run on this thread: it has made `used` bytes of its `budget`.
pub fn set_string_budget(used: u64, budget: u64) {
STRING_BYTES.with(|c| c.set((used, budget)));
-4
View File
@@ -24,12 +24,8 @@ impl Session {
}
}
/// Run a command by id, unless the automation roots, its own state or the block editor refuse it.
fn execute_guarded(&mut self, id: &str, params: &Value) -> Result<Value> {
let spec = find_command(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
if let Some(why) = crate::file_access::commands::refusal(spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
}
(spec.enabled)(self).map_err(|m| EngineError::Disabled(spec.id.into(), m))?;
if let Some(why) = cmd::blocks::bedit::refused_in_editor(self, spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
-3
View File
@@ -79,9 +79,6 @@ impl Session {
}
return Err(EngineError::UnknownCommand(typed.to_string()));
};
if let Some(why) = crate::file_access::commands::refusal(spec.id) {
return Err(EngineError::Disabled(spec.id.into(), why));
}
if transparent && spec.transparent && self.running.is_some() {
// Transparent commands (zoom, pan…) run without cancelling the active one.
if spec.interactive.is_none() {
-5
View File
@@ -291,7 +291,6 @@ pub fn format_angle_list(angles: &[f64]) -> String {
angles.iter().map(|a| format!("{}", (a.to_degrees() * 1e6).round() / 1e6)).collect::<Vec<_>>().join(";")
}
/// Set a system variable, refusing values out of its range and folders the automation roots can't hold.
pub fn set(s: &mut Session, name: &str, v: &Value) -> Result<()> {
let n = name.trim().to_ascii_uppercase();
if is_read_only(&n) {
@@ -388,10 +387,6 @@ pub fn set(s: &mut Session, name: &str, v: &Value) -> Result<()> {
"SAVETIME" => crate::autosave::set_savetime(
as_f64(v).filter(|m| *m >= 0.0 && *m <= f64::from(crate::autosave::MAX_SAVETIME)).ok_or_else(bad)?.round() as u32,
),
// A folder autosave and recovery would use without any further check.
"SAVEFILEPATH" if crate::file_access::current().is_some() => {
return Err(EngineError::Other("SAVEFILEPATH cannot be changed under the automation roots".into()));
}
"SAVEFILEPATH" => crate::autosave::set_savefilepath(v.as_str().ok_or_else(bad)?),
"ISAVEBAK" => crate::autosave::set_isavebak(as_bool(v).ok_or_else(bad)?),
// A number is in degrees; text is an angle typed in AUNITS (SETVAR at the command line).
+4 -141
View File
@@ -3,10 +3,8 @@
//! process-wide, so these tests run one at a time.
use std::sync::Mutex;
use std::time::{Duration, Instant};
use cadcraft_engine::Session;
use cadcraft_engine::cmd::file::MAX_ALIASES;
use cadcraft_engine::cmd::resolve_alias;
use serde_json::json;
@@ -28,10 +26,6 @@ ZZBAD, *NOSUCHCOMMAND
LINE, *CIRCLE
";
fn alias_prefix(count: usize) -> String {
(0..count).map(|i| format!("ZZP{i:05},*LINE\n")).collect()
}
#[test]
fn an_alias_file_adds_and_overrides_aliases() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
@@ -67,148 +61,17 @@ fn an_alias_file_adds_and_overrides_aliases() {
fn reinit_reads_the_alias_file_again() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let dir = TempDir::new("aliases");
let file = dir.file("mine.pgp", "ZZR, *LINE\nzzr, *RECTANG\n");
let file = dir.file("mine.pgp", "ZZR, *RECTANG\n");
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let r = s.execute("aliasedit", &json!({ "file": file })).unwrap();
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["file"], json!(file));
assert_eq!(r["warnings"], json!([]));
s.execute("aliasedit", &json!({ "file": file })).unwrap();
assert_eq!(resolve_alias("zzr"), "rectang");
std::fs::write(&file, "ZZR, *MOVE\nzzr, *CIRCLE\n").unwrap();
std::fs::write(&file, "ZZR, *CIRCLE\n").unwrap();
s.cmdline("reinit").unwrap();
assert_eq!(resolve_alias("zzr"), "circle");
assert!(s.log.iter().any(|l| l.contains("1 command alias")), "{:?}", s.log);
let r = s.execute("aliasedit", &json!({})).unwrap();
assert_eq!(r["file"], json!(file));
assert_eq!(r["aliases"], json!({ "zzr": "circle" }));
let r = s.execute("reinit", &json!({ "text": "ZZS, *LINE\nzzs, *SCALE\n" })).unwrap();
let r = s.execute("reinit", &json!({ "text": "ZZS, *SCALE\n" })).unwrap();
assert_eq!(r["aliases"], json!({ "zzs": "scale" }));
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["warnings"], json!([]));
assert_eq!(r["file"], json!(file), "reloading text keeps the remembered file");
let r = s.execute("reinit", &json!({})).unwrap();
assert_eq!(r["aliases"], json!({ "zzr": "circle" }));
assert_eq!(r["loaded"], json!(1));
assert_eq!(r["file"], json!(file));
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn valid_redefinitions_win_and_the_listing_stays_sorted() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let text = "ZZZ,*LINE\nZza,*LINE\nzzz,*CIRCLE\nZZA,*NO_SUCH_1933\nLINE,*CIRCLE\n";
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
let aliases = json!({ "zza": "line", "zzz": "circle" });
assert_eq!(r["aliases"], aliases);
assert_eq!(r["loaded"], json!(2), "loaded counts unique aliases, not definitions");
assert_eq!(r["file"], json!(null));
assert_eq!(
r["warnings"],
json!(["line 4: ZZA: unknown command *NO_SUCH_1933; skipped", "line 5: LINE is a command name; it stays the command; skipped"])
);
assert_eq!(resolve_alias("ZZZ"), "circle");
assert_eq!(resolve_alias("zza"), "line", "an invalid redefinition keeps the previous target");
assert_eq!(resolve_alias("line"), "line");
assert_eq!(serde_json::to_string(&r["aliases"]).unwrap(), r#"{"zza":"line","zzz":"circle"}"#);
let listing = s.execute("aliasedit", &json!({})).unwrap();
assert_eq!(listing, json!({ "aliases": aliases, "file": null, "loaded": 0, "warnings": [] }));
let empty = s.execute("aliasedit", &json!({ "text": "" })).unwrap();
assert_eq!(empty, json!({ "aliases": {}, "file": null, "loaded": 0, "warnings": [] }));
assert_eq!(resolve_alias("zza"), "zza", "an empty import replaces the old set");
assert_eq!(resolve_alias("zzz"), "zzz");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn duplicates_below_the_limit_leave_room_for_another_alias() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = alias_prefix(MAX_ALIASES - 1);
for _ in 0..16 {
text.push_str("ZZP00000,*MOVE\nzzp00001,*CIRCLE\n");
}
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES - 1));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES - 1);
assert_eq!(r["warnings"], json!([]));
for i in 0..MAX_ALIASES - 1 {
let expected = match i {
0 => "move",
1 => "circle",
_ => "line",
};
assert_eq!(r["aliases"][format!("zzp{i:05}")], json!(expected));
}
text.push_str("ZZNEW,*PLINE\n");
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES);
assert_eq!(r["aliases"]["zznew"], json!("pline"));
assert_eq!(r["aliases"]["zzp00000"], json!("move"));
assert_eq!(r["aliases"]["zzp00001"], json!("circle"));
assert_eq!(r["warnings"], json!([]), "duplicate definitions do not use up the alias limit");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
#[test]
fn a_full_file_validates_lines_before_stopping_at_the_next_valid_definition() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = alias_prefix(MAX_ALIASES);
text.push_str("; comment\nZZP00000,*NO_SUCH_1933\nLINE,*CIRCLE\nZZEXTERNAL, START NOTHING\nmalformed\nZZP00000,*MOVE\nZZAFTER,*CIRCLE\nanother malformed sentinel\n");
let params = json!({ "text": text });
let start = Instant::now();
let result = s.execute("aliasedit", &params);
let elapsed = start.elapsed();
let r = result.unwrap();
assert_eq!(r["loaded"], json!(MAX_ALIASES));
assert_eq!(r["aliases"].as_object().unwrap().len(), MAX_ALIASES);
assert_eq!(r["aliases"]["zzp00000"], json!("line"), "the cap stops even a valid duplicate replacement");
assert!(r["aliases"].get("zzafter").is_none(), "the remainder of the file is skipped");
assert_eq!(
r["warnings"],
json!([
format!("line {}: ZZP00000: unknown command *NO_SUCH_1933; skipped", MAX_ALIASES + 2),
format!("line {}: LINE is a command name; it stays the command; skipped", MAX_ALIASES + 3),
format!("line {}: ZZEXTERNAL is an external command; CADCraft doesn't run programs from alias files", MAX_ALIASES + 4),
format!("line {}: `malformed` is not ALIAS, *COMMAND; skipped", MAX_ALIASES + 5),
format!("line {}: more than {MAX_ALIASES} aliases; the rest are skipped", MAX_ALIASES + 6)
])
);
// Setting one existing alias through JSON has a different rule from importing a full file.
let r = s.execute("aliasedit", &json!({ "set": { "ZZP00000": "move" } })).unwrap();
assert_eq!(r["aliases"]["zzp00000"], json!("move"));
assert_eq!(r["loaded"], json!(1));
assert!(s.execute("aliasedit", &json!({ "set": { "ZZNEW": "line" } })).is_err());
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
// A generous responsiveness guard, not a benchmark or a timeout for a hung import.
assert!(elapsed < Duration::from_secs(5), "importing {MAX_ALIASES} aliases took {elapsed:?}");
}
#[test]
fn the_warning_limit_does_not_stop_a_later_valid_redefinition() {
let _one = ONE_AT_A_TIME.lock().unwrap_or_else(|e| e.into_inner());
let mut s = Session::new();
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
let mut text = String::from("ZZW,*LINE\n");
for _ in 0..101 {
text.push_str("ZZW,*NO_SUCH_1933\n");
}
text.push_str("zzw,*CIRCLE\n");
let r = s.execute("aliasedit", &json!({ "text": text })).unwrap();
assert_eq!(r["aliases"], json!({ "zzw": "circle" }));
assert_eq!(r["loaded"], json!(1));
let warnings: Vec<_> = (2..=101).map(|no| format!("line {no}: ZZW: unknown command *NO_SUCH_1933; skipped")).collect();
assert_eq!(r["warnings"], json!(warnings), "only the first 100 warnings are returned");
s.execute("aliasedit", &json!({ "clear": true })).unwrap();
}
-25
View File
@@ -285,7 +285,6 @@ fn oops_brings_back_what_it_erased_where_it_was() {
assert_eq!(order, [a, b, c]);
}
/// A refused -WBLOCK leaves OOPS as it was.
#[test]
fn a_dash_wblock_refused_during_refedit_leaves_oops_as_it_was() {
let (mut s, a, b, c) = drawing();
@@ -302,27 +301,3 @@ fn a_dash_wblock_refused_during_refedit_leaves_oops_as_it_was() {
s.execute("oops", &json!({})).unwrap();
assert!(alive(&s, c));
}
/// Outside the automation roots the prompt doesn't say whether a file is there.
#[test]
fn the_replace_prompt_says_nothing_about_a_file_outside_the_roots() {
let (mut s, ..) = drawing();
let dir = TempDir::new("dash-wblock-roots");
for d in ["in", "out", "outside"] {
std::fs::create_dir(dir.join(d)).unwrap();
}
let there = dir.join("outside/there.dwg");
std::fs::write(&there, "old").unwrap();
// Without roots the same file gets the prompt, so its absence below is the check's doing.
let (mut free, ..) = drawing();
free.cmdline("-wblock").unwrap();
free.cmdline(&there.display().to_string()).unwrap();
assert!(free.prompt_text().contains("already exists"), "{}", free.prompt_text());
let write = dir.join("out");
let roots = cadcraft_engine::file_access::AutomationRoots::new(Some(&dir.join("in")), Some(&write)).unwrap();
cadcraft_engine::file_access::confine(roots.as_ref(), || {
s.cmdline("-wblock").unwrap();
s.cmdline(&there.display().to_string()).unwrap();
assert!(!s.prompt_text().contains("already exists"), "{}", s.prompt_text());
});
}
@@ -1,5 +1,6 @@
//! BREAK on a closed polyline removes the stretch from the first to the second point along the
//! vertex direction and leaves one open polyline (#1173).
//! BREAK on a closed polyline removes the stretch between the two points that doesn't run
//! through its start vertex, whichever point comes first, and leaves one open polyline from the
//! later point round to the earlier one (#1173; AutoCAD 2024, accoreconsole).
use cadcraft_doc::{EntityKind, LwPolyline};
use cadcraft_engine::Session;
@@ -38,14 +39,15 @@ fn break_opens_a_closed_polyline_at_the_command_line() {
}
#[test]
fn break_json_on_a_closed_polyline_follows_the_order_of_the_points() {
fn break_json_on_a_closed_polyline_ignores_the_order_of_the_points() {
let mut s = Session::new();
let r = closed_rect(&mut s);
// Second point before the first along the vertices: the long way round goes, the short
// stretch between them stays.
// Second point before the first along the vertices: the same stretch goes as with the points
// the other way round (measured with the first point after the second, and both ways on a
// 100 x 10 rectangle broken at (10, 0) and (10, 10), where the long stretch went).
s.execute("break", &json!({ "handle": r["handle"], "p1": [100, 30], "p2": [50, 0] })).unwrap();
let ps = polys(&s);
assert_eq!(ps.len(), 1);
assert!(!ps[0].closed);
assert_eq!(pts(&ps[0]), vec![(50.0, 0.0), (100.0, 0.0), (100.0, 30.0)]);
assert_eq!(pts(&ps[0]), vec![(100.0, 30.0), (100.0, 60.0), (0.0, 60.0), (0.0, 0.0), (50.0, 0.0)]);
}
@@ -0,0 +1,134 @@
//! BREAKATPOINT and BREAK where the result is easy to get wrong, as AutoCAD 2024 runs them
//! (accoreconsole, `entget` of every object after the command, on these drawings):
//!
//! - BREAKATPOINT at either end of a line, or at the end vertex of an open polyline, leaves the
//! object whole;
//! - at an open polyline's middle vertex it splits it there, the original keeping the first part;
//! - BREAK of a closed polyline at two points of one side, either way round and on the side that
//! closes it too, opens it with its own handle;
//! - a circle trimmed or broken becomes an arc with its own handle.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// The model space objects in order: handle and kind.
fn objects(s: &Session) -> Vec<(Handle, EntityKind)> {
s.doc().unwrap().model.iter().map(|e| (e.handle, e.kind.clone())).collect()
}
/// A polyline's closed flag and vertices (rounded to 1e-9).
fn pts(k: &EntityKind) -> (bool, Vec<(f64, f64)>) {
let EntityKind::LwPolyline(p) = k else { panic!("not a polyline: {k:?}") };
let r = |v: f64| (v * 1e9).round() / 1e9;
(p.closed, p.vertices.iter().map(|v| (r(v.p.x), r(v.p.y))).collect())
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())
}
fn pline(s: &mut Session, vertices: Value, closed: bool) -> Handle {
handle(&s.execute("pline", &json!({ "vertices": vertices, "closed": closed })).unwrap())
}
fn run(s: &mut Session, script: &str) {
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
}
#[test]
fn breakatpoint_at_an_end_leaves_the_object_whole() {
for at in ["100,0", "0,0"] {
let mut s = Session::new();
let l = line(&mut s, [0.0, 0.0], [100.0, 0.0]);
run(&mut s, &format!("BREAKATPOINT {at} {at}\n"));
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{at}: {objs:?}");
let EntityKind::Line(k) = &objs[0].1 else { panic!("{objs:?}") };
assert!(objs[0].0 == l && (k.a.x, k.a.y, k.b.x, k.b.y) == (0.0, 0.0, 100.0, 0.0), "{at}: {objs:?}");
}
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [50, 0], [50, 30]]), false);
run(&mut s, "BREAKATPOINT 50,30 50,30\n");
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (p, (false, vec![(0.0, 0.0), (50.0, 0.0), (50.0, 30.0)])));
}
#[test]
fn breakatpoint_at_a_middle_vertex_splits_there_and_the_original_keeps_the_first_part() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [50, 0], [50, 30]]), false);
run(&mut s, "BREAKATPOINT 50,0 50,0\n");
let objs = objects(&s);
assert_eq!(objs.len(), 2, "{objs:?}");
let first = objs.iter().find(|o| o.0 == p).expect("the original stays");
let other = objs.iter().find(|o| o.0 != p).unwrap();
assert_eq!(pts(&first.1), (false, vec![(0.0, 0.0), (50.0, 0.0)]));
assert_eq!(pts(&other.1), (false, vec![(50.0, 0.0), (50.0, 30.0)]));
// One undo brings back the polyline as it was, under its handle, and nothing else.
s.undo().unwrap();
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (p, (false, vec![(0.0, 0.0), (50.0, 0.0), (50.0, 30.0)])));
}
#[test]
fn break_at_two_points_of_one_side_opens_a_closed_polyline_with_its_handle() {
let bottom = vec![(30.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0), (0.0, 0.0), (20.0, 0.0)];
// The side from (0, 10) back to the start vertex closes the rectangle.
let closing = vec![(0.0, 3.0), (0.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0), (0.0, 8.0)];
for (script, want) in [("BREAK 20,0 30,0\n", &bottom), ("BREAK 30,0 20,0\n", &bottom), ("BREAK 0,8 0,3\n", &closing)] {
let mut s = Session::new();
let r = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
run(&mut s, script);
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{script}: {objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (r, (false, want.clone())), "{script}");
// Undo closes it again.
s.undo().unwrap();
let objs = objects(&s);
let rect = vec![(0.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0)];
assert_eq!(objs.iter().map(|o| (o.0, pts(&o.1))).collect::<Vec<_>>(), vec![(r, (true, rect))], "{script}");
}
}
#[test]
fn a_circle_trimmed_or_broken_becomes_an_arc_with_its_handle() {
// Trimmed between the lines x = -5 and x = 5, picked at its top: the arc from 120 to 60
// degrees, round the bottom.
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
let l = line(&mut s, [-5.0, -20.0], [-5.0, 20.0]);
let m = line(&mut s, [5.0, -20.0], [5.0, 20.0]);
s.execute("trim", &json!({ "handle": c.hex(), "pick": [0, 10], "edges": [l.hex(), m.hex()] })).unwrap();
// The arc's handle, and whether it is AutoCAD's: radius 10 round (0, 0), from `start` to
// `end` degrees (to 1e-9 radians, 0 and 360 alike).
let arc_is = |s: &Session, start: f64, end: f64| {
let objs = objects(s);
let (h, k) = objs.iter().find(|o| matches!(o.1, EntityKind::Arc(_))).cloned().expect("an arc");
let EntityKind::Arc(a) = k else { panic!("not an arc") };
let same = |got: f64, want: f64| {
let d = (got - want.to_radians()).rem_euclid(std::f64::consts::TAU);
d < 1e-9 || std::f64::consts::TAU - d < 1e-9
};
let ok = (a.radius - 10.0).abs() < 1e-9 && a.center.x.abs() < 1e-9 && a.center.y.abs() < 1e-9 && same(a.start, start) && same(a.end, end);
(h, ok)
};
assert_eq!(arc_is(&s, 120.0, 60.0), (c, true));
// Broken from (10, 0) to (0, 10): the arc from 90 degrees round to 0.
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
run(&mut s, "BREAK 10,0 0,10\n");
assert_eq!(objects(&s).len(), 1);
assert_eq!(arc_is(&s, 90.0, 0.0), (c, true));
// Undo gives the circle back under its handle.
s.undo().unwrap();
let objs = objects(&s);
assert!(objs.len() == 1 && objs[0].0 == c && matches!(objs[0].1, EntityKind::Circle(_)), "{objs:?}");
}
@@ -0,0 +1,647 @@
//! BREAK on a closed polyline and TRIM of a polyline that is one of its own cutting edges, as
//! AutoCAD 2024 does them (measured with accoreconsole on these drawings):
//!
//! - BREAK between two points of a closed polyline removes the stretch between them that doesn't
//! run through its start vertex, whichever point comes first; BREAK or BREAKATPOINT at one point
//! splits it there into two open polylines, and at its start vertex leaves it closed.
//! - A polyline that is one of the cutting edges (picked, or with every object, in Standard or
//! Quick mode) is also cut at its own vertices, where it crosses itself and where a vertex of it
//! touches another of its segments. A piece whose ends meet there is left closed. A vertex
//! between two line segments in line (within 1e-8, straight on or doubling back) doesn't cut it.
//! - A pick within 5e-7 of one of the polyline's own cuts, whatever its size, trims nothing; a cut
//! by another edge that near the pick is passed over. An edge through a closed polyline's start
//! vertex cuts it there.
//!
//! Quick mode was measured in AutoCAD 2024 itself, picking on screen: its scripted TRIM runs
//! Standard mode only.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
type Vertex = (f64, f64, f64);
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
fn pline(s: &mut Session, vertices: Value, closed: bool) -> Handle {
handle(&s.execute("pline", &json!({ "vertices": vertices, "closed": closed })).unwrap())
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())
}
/// Every polyline in model space in order: its handle, closed flag and vertices with bulges.
fn polys(s: &Session) -> Vec<(Handle, bool, Vec<Vertex>)> {
s.doc()
.unwrap()
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::LwPolyline(p) => Some((e.handle, p.closed, p.vertices.iter().map(|v| (v.p.x, v.p.y, v.bulge)).collect())),
_ => None,
})
.collect()
}
fn same(got: &[Vertex], want: &[Vertex]) -> bool {
got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g.0 - w.0).abs() < 1e-9 && (g.1 - w.1).abs() < 1e-9 && (g.2 - w.2).abs() < 1e-9)
}
/// The polylines are `want` in order, (`kept`, closed, vertices): `kept` is whether it has the
/// handle `h`.
fn expect(s: &Session, h: Handle, want: &[(bool, bool, &[Vertex])]) {
let got = polys(s);
assert_eq!(got.len(), want.len(), "{got:?}");
for ((gh, gc, gv), (kept, closed, wv)) in got.iter().zip(want) {
assert_eq!((*gh == h, *gc), (*kept, *closed), "{got:?}");
assert!(same(gv, wv), "{gv:?} != {wv:?}");
}
}
fn run(s: &mut Session, script: &str) {
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
}
// ---------------- BREAK on a closed polyline ----------------
#[test]
fn break_removes_the_stretch_between_the_points_that_misses_the_start_vertex() {
// 100 x 10 rectangle broken at (10, 0) and (10, 10): the 190-unit stretch between them goes,
// the 20 units across the start vertex stay, with the points either way round.
for script in ["BREAK 10,0 10,10\n", "BREAK 10,10 10,0\n"] {
let mut s = Session::new();
let r = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
run(&mut s, script);
expect(&s, r, &[(true, false, &[(10.0, 10.0, 0.0), (0.0, 10.0, 0.0), (0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
}
#[test]
fn break_with_the_first_point_after_the_second_keeps_the_run_through_the_start() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], { "p": [40, 0], "bulge": 0.5 }, [60, 0], [60, 30], [0, 30]]), true);
run(&mut s, "BREAK 60,20 10,0\n");
expect(&s, p, &[(true, false, &[(60.0, 20.0, 0.0), (60.0, 30.0, 0.0), (0.0, 30.0, 0.0), (0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
const SQUARE: [[f64; 2]; 4] = [[250.0, 0.0], [270.0, 0.0], [270.0, 20.0], [250.0, 20.0]];
#[test]
fn break_at_one_point_splits_a_closed_polyline_in_two() {
let first: &[Vertex] = &[(250.0, 0.0, 0.0), (260.0, 0.0, 0.0)];
let second: &[Vertex] = &[(260.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0), (250.0, 20.0, 0.0), (250.0, 0.0, 0.0)];
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 260,0 260,0\n");
expect(&s, p, &[(true, false, first), (false, false, second)]);
// BREAKATPOINT does the same.
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
let r = s.execute("breakatpoint", &json!({ "handle": p.hex(), "at": [260, 0] })).unwrap();
assert_eq!(r["handles"].as_array().unwrap().len(), 2);
expect(&s, p, &[(true, false, first), (false, false, second)]);
}
#[test]
fn break_at_a_vertex_splits_there_and_at_the_start_vertex_changes_nothing() {
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 270,20 270,20\n");
expect(
&s,
p,
&[
(true, false, &[(250.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0)]),
(false, false, &[(270.0, 20.0, 0.0), (250.0, 20.0, 0.0), (250.0, 0.0, 0.0)]),
],
);
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 250,0 250,0\n");
expect(&s, p, &[(true, true, &[(250.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0), (250.0, 20.0, 0.0)])]);
}
// ---------------- TRIM of a polyline that cuts itself ----------------
/// A polyline with an arc, and vertical lines at x = 20 and x = 60 crossing it.
fn arc_polyline(s: &mut Session) -> (Handle, Handle, Handle) {
let p = pline(s, json!([[0, 0], { "p": [40, 0], "bulge": 0.4 }, [70, 0], [90, 30]]), false);
let b = line(s, [20.0, -10.0], [20.0, 40.0]);
let c = line(s, [60.0, -20.0], [60.0, 40.0]);
(p, b, c)
}
/// The piece from the x = 60 cut on the arc to the end, as measured.
const FROM_C: [Vertex; 3] = [(60.0, -5.417486860749438, 0.1330399827453447), (70.0, 0.0, 0.0), (90.0, 30.0, 0.0)];
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edges: Option<&[Handle]>) {
let mut p = json!({ "handle": h.hex(), "pick": pick });
if let Some(es) = edges {
p["edges"] = json!(es.iter().map(|e| e.hex()).collect::<Vec<_>>());
}
s.execute("trim", &p).unwrap();
}
#[test]
fn with_every_object_cutting_a_polyline_trims_to_its_own_vertex() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn edges_that_leave_the_polyline_out_cut_only_where_they_cross_it() {
let mut s = Session::new();
let (p, b, c) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], Some(&[b, c]));
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (20.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn a_polyline_that_is_its_only_edge_loses_the_whole_segment_picked() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &[(70.0, 0.0, 0.0), (90.0, 30.0, 0.0)])]);
// The first segment: one piece left, the polyline itself.
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [10.0, 0.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(40.0, 0.0, 0.4), (70.0, 0.0, 0.0), (90.0, 30.0, 0.0)])]);
}
#[test]
fn a_closed_polyline_that_is_its_only_edge_opens_without_the_segment_picked() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [40, 0], [40, 30], [0, 30]]), true);
trim(&mut s, p, [20.0, 0.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(40.0, 0.0, 0.0), (40.0, 30.0, 0.0), (0.0, 30.0, 0.0), (0.0, 0.0, 0.0)])]);
}
#[test]
fn a_polyline_crossing_itself_is_cut_at_the_crossing() {
let x = json!([[0, 0], [40, 20], [40, 0], [0, 20]]);
let mut s = Session::new();
let p = pline(&mut s, x.clone(), false);
trim(&mut s, p, [10.0, 5.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(20.0, 10.0, 0.0), (40.0, 20.0, 0.0), (40.0, 0.0, 0.0), (0.0, 20.0, 0.0)])]);
// Every object (the polyline alone): cut between the crossing and the next vertex.
let mut s = Session::new();
let p = pline(&mut s, x, false);
trim(&mut s, p, [30.0, 15.0], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (20.0, 10.0, 0.0)]), (false, false, &[(40.0, 20.0, 0.0), (40.0, 0.0, 0.0), (0.0, 20.0, 0.0)])]);
}
#[test]
fn a_closed_polyline_at_survey_coordinates_trims_to_its_own_vertex() {
let mut s = Session::new();
let p = pline(
&mut s,
json!([[612345.678, 2398765.432], { "p": [612385.678, 2398765.432], "bulge": 0.4 }, [612415.678, 2398765.432], [612415.678, 2398795.432], [612345.678, 2398795.432]]),
true,
);
let b = line(&mut s, [612365.678, 2398755.432], [612365.678, 2398805.432]);
let c = line(&mut s, [612405.678, 2398745.432], [612405.678, 2398805.432]);
trim(&mut s, p, [612400.678, 2398759.432], Some(&[p, b, c]));
let got = polys(&s);
assert_eq!(got.len(), 1);
let (h, closed, vs) = &got[0];
assert!(*h == p && !closed);
let want: [Vertex; 6] = [
(612405.678, 2398760.014513139, 0.1330399827461127),
(612415.678, 2398765.432, 0.0),
(612415.678, 2398795.432, 0.0),
(612345.678, 2398795.432, 0.0),
(612345.678, 2398765.432, 0.0),
(612385.678, 2398765.432, 0.0),
];
// Survey coordinates: a micrometre on the points, the bulge to 1e-9.
assert_eq!(vs.len(), want.len());
for (g, w) in vs.iter().zip(&want) {
assert!((g.0 - w.0).abs() < 1e-6 && (g.1 - w.1).abs() < 1e-6 && (g.2 - w.2).abs() < 1e-9, "{g:?} != {w:?}");
}
}
#[test]
fn standard_mode_at_the_command_line_with_every_object_cuts_at_the_polyline_vertex() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
// Mode Standard, Enter: every object is a cutting edge.
run(&mut s, "TRIM O S\n\n55,-6\n\n");
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn a_polyline_picked_as_an_edge_in_quick_mode_cuts_itself_too() {
// Quick mode with the edges given (its cuTting edges option): picked is picked.
let mut s = Session::new();
let (p, _, c) = arc_polyline(&mut s);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [55, -6], "mode": "quick", "edges": [p.hex(), c.hex()] })).unwrap();
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn quick_mode_with_every_object_cuts_a_polyline_at_its_own_vertex_too() {
// As Standard mode with every object: from the vertex at (40, 0), not from the line at x = 20.
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [55, -6], "mode": "quick" })).unwrap();
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
/// A rectangle, then an open polyline whose last vertex (6.9, 6.2) touches its second segment
/// inside the rectangle (reversed: whose first vertex does). The polyline's handle.
fn touching(s: &mut Session, reversed: bool) -> Handle {
pline(s, json!([[3.9, 3.8], [8.3, 3.8], [8.3, 6.9], [3.9, 6.9]]), true);
let mut v = vec![[2.3, 3.3], [5.3, 8.0], [8.5, 4.4], [8.8, 7.8], [6.9, 6.2]];
if reversed {
v.reverse();
}
pline(s, json!(v), false)
}
const RECT: [Vertex; 4] = [(3.9, 3.8, 0.0), (8.3, 3.8, 0.0), (8.3, 6.9, 0.0), (3.9, 6.9, 0.0)];
/// Where the second segment crosses the rectangle's top and right sides.
const TOP: Vertex = (6.277777777777777, 6.9, 0.0);
const RIGHT: Vertex = (8.3, 4.625, 0.0);
#[test]
fn a_polyline_is_cut_where_its_end_touches_it() {
let start: [Vertex; 3] = [(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), TOP];
let looped: [Vertex; 3] = [(6.9, 6.2, 0.0), (8.5, 4.4, 0.0), (8.8, 7.8, 0.0)];
// Picked above the touch, in the rectangle: cut from the top side to the touch. What is left
// after it ends where it starts, so it is closed. Quick mode as picked on screen, and Standard
// mode with every object at the command line.
let mut s = Session::new();
let p = touching(&mut s, false);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [6.58, 6.56], "mode": "quick" })).unwrap();
expect(&s, p, &[(false, true, &RECT), (true, false, &start), (false, true, &looped)]);
let mut s = Session::new();
let p = touching(&mut s, false);
run(&mut s, "TRIM O S\n\n6.58,6.56\n\n");
expect(&s, p, &[(false, true, &RECT), (true, false, &start), (false, true, &looped)]);
// Below the touch: cut from the touch to the right side.
let mut s = Session::new();
let p = touching(&mut s, false);
trim(&mut s, p, [7.604, 5.408], None);
let end: [Vertex; 4] = [RIGHT, (8.5, 4.4, 0.0), (8.8, 7.8, 0.0), (6.9, 6.2, 0.0)];
expect(&s, p, &[(false, true, &RECT), (true, false, &[(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), (6.9, 6.2, 0.0)]), (false, false, &end)]);
// The first vertex touching: the closed loop is the piece that keeps the handle.
let mut s = Session::new();
let p = touching(&mut s, true);
trim(&mut s, p, [6.58, 6.56], None);
expect(
&s,
p,
&[
(false, true, &RECT),
(true, true, &[(6.9, 6.2, 0.0), (8.8, 7.8, 0.0), (8.5, 4.4, 0.0)]),
(false, false, &[TOP, (5.3, 8.0, 0.0), (2.3, 3.3, 0.0)]),
],
);
}
#[test]
fn a_closed_piece_keeps_its_arcs() {
let mut s = Session::new();
pline(&mut s, json!([[3.9, 3.8], [8.3, 3.8], [8.3, 6.9], [3.9, 6.9]]), true);
let p = pline(&mut s, json!([[2.3, 3.3], [5.3, 8.0], { "p": [8.5, 4.4], "bulge": 0.3 }, [8.8, 7.8], [6.9, 6.2]]), false);
trim(&mut s, p, [6.58, 6.56], None);
let looped: [Vertex; 3] = [(6.9, 6.2, 0.0), (8.5, 4.4, 0.3), (8.8, 7.8, 0.0)];
expect(&s, p, &[(false, true, &RECT), (true, false, &[(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), TOP]), (false, true, &looped)]);
}
#[test]
fn a_pick_half_a_unit_from_a_vertex_1e9_out_trims_the_segment_it_is_on() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [1e9, 0], [1e9, 10]]), false);
trim(&mut s, p, [1e9, 0.5], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (1e9, 0.0, 0.0)])]);
}
// ---------------- a pick on a cut ----------------
type Edge = ([f64; 2], [f64; 2]);
/// The polyline `v`, with lines `edges`, trimmed at `pick` with every object as an edge, or only
/// the lines when `only_lines`; the polyline's handle and whether the trim was made.
fn attempt(v: Value, closed: bool, edges: &[Edge], only_lines: bool, pick: [f64; 2]) -> (Session, Handle, bool) {
let mut s = Session::new();
let p = pline(&mut s, v, closed);
let ls: Vec<String> = edges.iter().map(|(a, b)| line(&mut s, *a, *b).hex()).collect();
let mut params = json!({ "handle": p.hex(), "pick": pick });
if only_lines {
params["edges"] = json!(ls);
}
let made = s.execute("trim", &params).is_ok();
(s, p, made)
}
/// [`attempt`] with at most one line, which must trim.
fn trimmed(v: Value, closed: bool, edge: Option<Edge>, only_line: bool, pick: [f64; 2]) -> (Session, Handle) {
let (s, p, made) = attempt(v, closed, edge.as_slice(), only_line, pick);
assert!(made, "{pick:?}");
(s, p)
}
/// A vertical line through x = `x`.
fn at(x: f64) -> Edge {
([x, -5.0], [x, 5.0])
}
#[test]
fn a_pick_on_a_cut_trims_nothing() {
// The vertex (10, 0) is the only cut. A pick whose nearest point is within 5e-7 of it, on it
// or off to the side, leaves the polyline as it was; one 6e-7 from it trims the segment it is
// on.
let v = || json!([[0, 0], [10, 0], [10, 10]]);
let whole: [Vertex; 3] = [(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0)];
for pick in [[10.0, 0.0], [10.0, 4e-7], [10.5, 4e-7], [9.99999999, 0.0]] {
let (s, p) = trimmed(v(), false, None, false, pick);
expect(&s, p, &[(true, false, &whole)]);
}
let (s, p) = trimmed(v(), false, None, false, [10.0, 6e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
let (s, p) = trimmed(v(), false, None, false, [9.9999994, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
#[test]
fn a_pick_on_a_cut_is_within_the_same_distance_at_any_size() {
// A polyline a thousandth across, and one 1e9 long with a line through its vertex: 1e-7 from
// the vertex is on the cut, 1e-6 off it.
let small = || json!([[0, 0], [0.001, 0], [0.001, 0.001]]);
let (s, p) = trimmed(small(), false, None, false, [0.001, 1e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (0.001, 0.0, 0.0), (0.001, 0.001, 0.0)])]);
let (s, p) = trimmed(small(), false, None, false, [0.001, 1e-6]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (0.001, 0.0, 0.0)])]);
let long = || json!([[0, 0], [10, 0], [10, 1e9]]);
let through = Some(([0.0, -10.0], [20.0, 10.0]));
let (s, p) = trimmed(long(), false, through, false, [10.0, 1e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 1e9, 0.0)])]);
let (s, p) = trimmed(long(), false, through, false, [10.0, 1e-6]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
#[test]
fn a_cut_by_another_edge_at_the_pick_is_passed_over() {
// A pick within 5e-7 of a cut by another edge runs the piece on across it, to the next cut
// either side; 6e-7 away the cut holds.
let flat = || json!([[0, 0], [10, 0]]);
let piece = |a: f64, b: f64| [(a, 0.0, 0.0), (b, 0.0, 0.0)];
for pick in [[3.0, 0.0], [3.0000004, 0.0]] {
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(7.0)], true, pick);
expect(&s, p, &[(true, false, &piece(7.0, 10.0))]);
}
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(7.0)], true, [3.0000006, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 3.0)), (false, false, &piece(7.0, 10.0))]);
// Lines at 3, 5 and 7: picked on 5, 3 to 7 goes; picked on 7, 5 to the end.
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(5.0), at(7.0)], true, [5.0, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 3.0)), (false, false, &piece(7.0, 10.0))]);
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(5.0), at(7.0)], true, [7.0, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 5.0))]);
// Every object an edge: on to the polyline's own vertex (10, 0).
let (s, p, _) = attempt(json!([[0, 0], [10, 0], [10, 10]]), false, &[at(5.0)], false, [5.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
// A closed rectangle cut at x = 30 and 70 top and bottom, picked on the bottom at 30: round
// its start vertex, from 30 on the top to 70 on the bottom.
let tall = |x: f64| ([x, -5.0], [x, 15.0]);
let (s, p, _) = attempt(json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true, &[tall(30.0), tall(70.0)], true, [30.0, 0.0]);
expect(&s, p, &[(true, false, &[(70.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (30.0, 10.0, 0.0)])]);
// One line only, picked on its cut or 4e-7 past it: no cut is left, and nothing is trimmed.
for pick in [[5.0, 0.0], [5.0000004, 0.0]] {
let (s, p, made) = attempt(json!([[0, 0], [10, 0], [10, 10]]), false, &[at(5.0)], true, pick);
assert!(!made);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
// In Quick mode too: the polyline meets the line, so it isn't erased as one no edge crosses.
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [10, 0]]), false);
line(&mut s, [5.0, -5.0], [5.0, 5.0]);
assert!(s.execute("trim", &json!({ "handle": p.hex(), "pick": [5, 0], "mode": "quick" })).is_err());
expect(&s, p, &[(true, false, &piece(0.0, 10.0))]);
}
#[test]
fn a_pick_on_a_vertex_an_edge_runs_through_trims_nothing() {
// The line's cut is found on the segments either side of the vertex, a rounding apart. Both
// are passed over, so no cut is left and the polyline stays as it was, not split there.
let cases = [
([[5.5, 1.1], [23.3, 7.7], [30.1, 29.9]], ([23.3, 7.7], [45.7, 2.3])),
([[5.5, 1.1], [23.3, 7.7], [30.1, 29.9]], ([2.0 * 23.3 - 45.7, 2.0 * 7.7 - 2.3], [45.7, 2.3])),
([[1.3, 2.7], [37.9, 11.3], [55.1, 48.7]], ([4.5, 43.5], [71.3, -20.9])),
];
for (v, edge) in cases {
let (s, p, made) = attempt(json!(v), false, &[edge], true, v[1]);
let whole: Vec<Vertex> = v.iter().map(|q| (q[0], q[1], 0.0)).collect();
assert!(!made);
expect(&s, p, &[(true, false, &whole)]);
}
}
#[test]
fn an_edge_through_a_closed_polylines_start_vertex_cuts_it_there() {
// The line cuts the rectangle at (0, 0) and at (10, 10) on its top. The pick takes the piece
// it is on, whichever vertex the rectangle starts at. 4e-7 from (0, 0) that cut is passed
// over, which leaves one, and the trim is refused.
let rect = || json!([[0, 0], [100, 0], [100, 10], [0, 10]]);
let edge = Some(([-5.0, -5.0], [15.0, 15.0]));
let left: [Vertex; 3] = [(10.0, 10.0, 0.0), (0.0, 10.0, 0.0), (0.0, 0.0, 0.0)];
let (s, p) = trimmed(rect(), true, edge, true, [50.0, 0.0]);
expect(&s, p, &[(true, false, &left)]);
let (s, p) = trimmed(json!([[50, 0], [100, 0], [100, 10], [0, 10], [0, 0]]), true, edge, true, [50.0, 10.0]);
expect(&s, p, &[(true, false, &left)]);
let (s, p) = trimmed(rect(), true, edge, true, [0.0, 5.0]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (10.0, 10.0, 0.0)])]);
let whole: [Vertex; 4] = [(0.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (0.0, 10.0, 0.0)];
let (s, p, made) = attempt(rect(), true, edge.as_slice(), true, [0.0, 4e-7]);
assert!(!made);
expect(&s, p, &[(true, true, &whole)]);
// The rectangle alone, picked on its start vertex, and 4e-7 from it on its last segment.
for pick in [[0.0, 0.0], [0.0, 4e-7]] {
let (s, p) = trimmed(rect(), true, None, false, pick);
expect(&s, p, &[(true, true, &whole)]);
}
}
#[test]
fn a_closed_polyline_cut_at_one_point_is_left_as_it_was() {
// A line touching the rectangle only at its start vertex, and one crossing its bottom once and
// ending inside: AutoCAD refuses either trim, and Quick mode doesn't erase the rectangle.
for (a, b, pick) in [([-5.0, 5.0], [5.0, -5.0], [50.0, 0.0]), ([50.0, -5.0], [50.0, 5.0], [20.0, 0.0])] {
for mode in ["standard", "quick"] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
let l = line(&mut s, a, b);
let before = polys(&s);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": pick, "edges": [l.hex()], "mode": mode }));
assert!(r.is_err_and(|e| e.to_string() == "Curve must intersect cutting edges at least twice."), "{a:?} {mode}");
assert_eq!(polys(&s), before, "{a:?} {mode}");
}
}
}
// ---------------- where a polyline runs straight on ----------------
#[test]
fn a_vertex_the_polyline_runs_straight_on_through_doesnt_cut_it() {
// (5, 0) lies between two segments in line: the pick takes everything back to the cut before
// it, the start of the polyline or the closed polyline's start vertex.
let v = || json!([[0, 0], [5, 0], [10, 0], [10, 10]]);
let (s, p) = trimmed(v(), false, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
let (s, p) = trimmed(v(), true, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (0.0, 0.0, 0.0)])]);
// A crossing on the segment in line before the one picked bounds the piece, as does one on the
// segment in line after it, and one right at the vertex in line.
let (s, p) = trimmed(json!([[0, 0], [5, 0], [10, 0], [10, 10], [2, 10], [2, -5]]), false, None, false, [7.0, 0.0]);
expect(
&s,
p,
&[
(true, false, &[(0.0, 0.0, 0.0), (2.0, 0.0, 0.0)]),
(false, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (2.0, 10.0, 0.0), (2.0, -5.0, 0.0)]),
],
);
let (s, p) = trimmed(json!([[0, 0], [5, 0], [10, 0], [10, 10], [8, 10], [8, -5]]), false, None, false, [3.5, 0.0]);
expect(&s, p, &[(true, false, &[(8.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (8.0, 10.0, 0.0), (8.0, -5.0, 0.0)])]);
let at_vertex = || json!([[0, 0], [5, 0], [10, 0], [10, 10], [5, 10], [5, -5]]);
let rest: [Vertex; 4] = [(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (5.0, 10.0, 0.0), (5.0, -5.0, 0.0)];
let (s, p) = trimmed(at_vertex(), false, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (5.0, 0.0, 0.0)]), (false, false, &rest)]);
let (s, p) = trimmed(at_vertex(), false, None, false, [3.0, 0.0]);
expect(&s, p, &[(true, false, &[(5.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (5.0, 10.0, 0.0), (5.0, -5.0, 0.0)])]);
// Straight on, or doubling back over itself: no cut at all.
for (v, pick) in [(json!([[0, 0], [5, 0], [10, 0]]), [7.0, 0.0]), (json!([[0, 0], [10, 0], [5, 0]]), [2.0, 0.0])] {
let mut s = Session::new();
let p = pline(&mut s, v, false);
let before = polys(&s);
assert!(s.execute("trim", &json!({ "handle": p.hex(), "pick": pick })).is_err());
assert_eq!(polys(&s), before);
}
}
#[test]
fn a_bend_of_1e_8_cuts_a_polyline_and_a_smaller_one_doesnt() {
// The bend at (5, 0), as the sine of its angle, whatever the segments' lengths.
for (end, pick, cuts) in [
([10.0, 4e-8], [7.0, 0.0], false),
([10.0, 6e-8], [7.0, 0.0], true),
([5005.0, 1e-6], [700.0, 0.0], false),
([5005.0, 0.01], [700.0, 0.0], true),
] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [5, 0], end]), false);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": pick }));
assert_eq!((r.is_ok(), polys(&s)[0].2.len()), if cuts { (true, 2) } else { (false, 3) }, "{end:?}");
}
// Two arcs of one circle, or a line and an arc on from it, cut where they meet.
let q = 0.41421356237309503;
let (s, p) = trimmed(json!([{ "p": [0, 0], "bulge": -q }, { "p": [5, 5], "bulge": -q }, [10, 0]]), false, None, false, [8.5355339, 3.5355339]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, -q), (5.0, 5.0, 0.0)])]);
let (s, p) = trimmed(json!([[0, 0], { "p": [5, 0], "bulge": q }, [10, 5]]), false, None, false, [8.5355339, 1.4644661]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (5.0, 0.0, 0.0)])]);
}
#[test]
fn a_polyline_of_thousands_of_segments_is_cut_where_it_crosses_itself() {
// 3,003 segments, the last crossing the first at (50, 0): the pick on the first takes it from
// there to the vertex (100, 0), as with a few segments.
let mut v = vec![json!([0, 0]), json!([100, 0]), json!([100, 20])];
v.extend((1..=3000).map(|i| json!([100.0 - f64::from(i) / 60.0, 20.0 + f64::from(i % 2)])));
v.push(json!([50, -10]));
let (s, p) = trimmed(json!(v), false, None, false, [75.0, 0.0]);
let got = polys(&s);
assert_eq!(got.len(), 2, "{:?}", got.iter().map(|g| g.2.len()).collect::<Vec<_>>());
assert!(got[0].0 == p && same(&got[0].2, &[(0.0, 0.0, 0.0), (50.0, 0.0, 0.0)]), "{:?}", got[0]);
assert_eq!((got[1].2.len(), got[1].2.first().copied()), (3003, Some((100.0, 0.0, 0.0))));
}
#[test]
fn a_polyline_too_long_to_search_for_its_own_crossings_is_left_as_it_was() {
// 4,100 segments in line: the run picked times those near it is past the bound searched. 300
// segments in line over the same stretch, back and forth, crossed by 300 more: 90,000
// crossings, past the bound kept. The trim is refused, and Quick mode doesn't erase the
// polyline as one no edge crosses.
let mut back_and_forth: Vec<[f64; 2]> = (0..=300).map(|i| [if i % 2 == 0 { 0.0 } else { 10.0 }, 0.0]).collect();
back_and_forth.extend((0..300).map(|i| [0.5 + f64::from(i) * 0.03, if i % 2 == 0 { 5.0 } else { -5.0 }]));
for (v, why) in [(json!((0..=4100).map(|i| [i, 0]).collect::<Vec<_>>()), "Too many segments"), (json!(back_and_forth), "Too many crossings")] {
let mut s = Session::new();
let p = pline(&mut s, v, false);
let before = polys(&s);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": [0.2, 0], "mode": "quick" }));
assert!(r.is_err_and(|e| e.to_string().contains(why)), "{why}");
assert_eq!(polys(&s), before);
}
}
#[test]
fn a_piece_whose_ends_only_come_near_stays_open_far_from_the_origin() {
// 1e9 out, as survey coordinates in millimetres are: the piece left runs from the line's cut
// to the polyline's end, 0.58 away, and stays open.
let o = 1e9;
let mut s = Session::new();
let p = pline(&mut s, json!([[o + 2.3, 3.3], [o + 5.3, 8.0], [o + 8.5, 4.4], [o + 8.8, 7.8], [o + 7.4, 6.5]]), false);
line(&mut s, [o + 6.9, 5.0], [o + 6.9, 7.0]);
trim(&mut s, p, [o + 6.1, 7.1], None);
let got = polys(&s);
assert_eq!(got.len(), 2, "{got:?}");
let (h, closed, vs) = &got[1];
assert!(*h != p && !closed && vs.len() == 4, "{got:?}");
let last = vs[3];
assert!((last.0 - (o + 7.4)).abs() < 1e-6 && (last.1 - 6.5).abs() < 1e-6, "{last:?}");
}
#[test]
fn a_polyline_is_cut_where_a_vertex_of_it_touches_it() {
// The vertex (6, 6) lies on the first segment, which is cut there.
let v = json!([[0, 0], [10, 10], [12, 4], [6, 6], [4, 12]]);
let mut s = Session::new();
let p = pline(&mut s, v.clone(), false);
trim(&mut s, p, [3.0, 3.0], None);
expect(&s, p, &[(true, false, &[(6.0, 6.0, 0.0), (10.0, 10.0, 0.0), (12.0, 4.0, 0.0), (6.0, 6.0, 0.0), (4.0, 12.0, 0.0)])]);
let mut s = Session::new();
let p = pline(&mut s, v, false);
trim(&mut s, p, [8.0, 8.0], None);
expect(
&s,
p,
&[
(true, false, &[(0.0, 0.0, 0.0), (6.0, 6.0, 0.0)]),
(false, false, &[(10.0, 10.0, 0.0), (12.0, 4.0, 0.0), (6.0, 6.0, 0.0), (4.0, 12.0, 0.0)]),
],
);
}
#[test]
fn a_long_run_in_line_on_a_large_polyline_is_cut_where_it_is_crossed() {
// 1,000 segments in line along y = 0, then 20,002 more, the last crossing the run at x = 500.25:
// only the few segments near the run are searched, and the pick takes it from the crossing to
// the corner (1000, 0).
let mut v: Vec<Value> = (0..=1000).map(|i| json!([i, 0])).collect();
v.push(json!([1000, 200]));
v.extend((1..=20000).map(|i| json!([1000.0 - f64::from(i) * 499.75 / 20000.0, 200.0 + f64::from(i % 2)])));
v.push(json!([500.25, -10]));
let (s, p) = trimmed(json!(v), false, None, false, [999.5, 0.0]);
let got = polys(&s);
assert_eq!(got.len(), 2, "{:?}", got.iter().map(|g| g.2.len()).collect::<Vec<_>>());
assert!(got[0].0 == p && got[0].2.len() == 502 && got[0].2.last() == Some(&(500.25, 0.0, 0.0)), "{:?}", got[0].2.last());
assert_eq!((got[1].2.first().copied(), got[1].2.last().copied()), (Some((1000.0, 0.0, 0.0)), Some((500.25, -10.0, 0.0))));
}
#[test]
fn a_crossing_window_whose_nearest_point_is_a_vertex_trims_the_segment_it_ends() {
// The window's first corner is nearest the vertex (10, 0), a cut of the polyline: the segment
// before it goes, either way round the window, as in AutoCAD.
for (a, b) in [([10.5, -0.5], [8.0, 2.0]), ([8.0, 2.0], [10.5, -0.5])] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [10, 0], [10, 10]]), false);
s.execute("trim", &json!({ "crossing": [a, b], "mode": "standard" })).unwrap();
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
}
@@ -0,0 +1,128 @@
//! BREAKATPOINT at the command line and from a script, with AutoCAD 2024's prompts ("Select
//! object:", then "Specify break point:"); BREAK and BREAKATPOINT end the command when a circle
//! can't be broken at one point, and refuse an object on a locked layer when it is picked. Measured
//! in AutoCAD 2024 (accoreconsole) on these drawings.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// The model space objects in order: handle and kind.
fn objects(s: &Session) -> Vec<(Handle, EntityKind)> {
s.doc().unwrap().model.iter().map(|e| (e.handle, e.kind.clone())).collect()
}
fn line_ends(k: &EntityKind) -> ((f64, f64), (f64, f64)) {
let EntityKind::Line(l) = k else { panic!("not a line: {k:?}") };
((l.a.x, l.a.y), (l.b.x, l.b.y))
}
#[test]
fn breakatpoint_asks_for_the_object_then_the_point_and_splits_the_line_there() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("BREAKATPOINT").unwrap();
assert!(s.prompt_text().ends_with("Select object:"), "{}", s.prompt_text());
s.cmdline("1002,0").unwrap();
assert!(s.prompt_text().ends_with("Specify break point:"), "{}", s.prompt_text());
// Off the line: the point projects onto it.
s.cmdline("1005,3").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1005.0, 0.0)));
assert_eq!(line_ends(&objs[1].1), ((1005.0, 0.0), (1010.0, 0.0)));
}
#[test]
fn breakatpoint_from_a_script_splits_an_arc_and_a_closed_polyline() {
let mut s = Session::new();
let a = handle(&s.execute("arc", &json!({ "center": [700, 0], "radius": 10, "start": 0, "end": 90 })).unwrap());
let p = handle(&s.execute("pline", &json!({ "vertices": [[250, 0], [270, 0], [270, 20], [250, 20]], "closed": true })).unwrap());
s.script("BREAKATPOINT 707.0710678,7.0710678 707.0710678,7.0710678\nBREAKATPOINT 260,0 260,0\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.iter().map(|o| o.0).take(2).collect::<Vec<_>>(), [a, p]);
let EntityKind::Arc(arc) = &objs[0].1 else { panic!("not an arc") };
assert!((arc.start - 0.0).abs() < 1e-9 && (arc.end.to_degrees() - 45.0).abs() < 1e-6, "{arc:?}");
let EntityKind::Arc(rest) = &objs[2].1 else { panic!("not an arc") };
assert!((rest.start.to_degrees() - 45.0).abs() < 1e-6 && (rest.end.to_degrees() - 90.0).abs() < 1e-9, "{rest:?}");
let pts = |k: &EntityKind| match k {
EntityKind::LwPolyline(l) => (l.closed, l.vertices.iter().map(|v| (v.p.x, v.p.y)).collect::<Vec<_>>()),
k => panic!("not a polyline: {k:?}"),
};
assert_eq!(pts(&objs[1].1), (false, vec![(250.0, 0.0), (260.0, 0.0)]));
assert_eq!(pts(&objs[3].1), (false, vec![(260.0, 0.0), (270.0, 0.0), (270.0, 20.0), (250.0, 20.0), (250.0, 0.0)]));
}
#[test]
fn breakatpoint_and_break_at_one_point_of_a_circle_report_it_and_end() {
for script in ["BREAKATPOINT 1300,10 1300,10\n", "BREAK 1300,10 1300,10\n"] {
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [1300, 0], "radius": 10 })).unwrap());
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
assert!(s.log.iter().any(|l| l == "Arc cannot be full 360 degrees"), "{script}: {:?}", s.log);
let objs = objects(&s);
assert_eq!(objs.len(), 1);
assert!(objs[0].0 == c && matches!(objs[0].1, EntityKind::Circle(_)), "{objs:?}");
}
}
#[test]
fn enter_ends_breakatpoint_and_leaves_nothing_selected() {
let mut s = Session::new();
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
s.script("BREAKATPOINT\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
// Enter at the break point after picking: the line is not left selected.
s.script("BREAKATPOINT 5,0\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.selection().is_empty());
assert_eq!(objects(&s).len(), 1);
}
#[test]
fn an_object_on_a_locked_layer_is_refused_when_picked() {
let mut s = Session::new();
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
s.execute("layer.set", &json!({ "name": "0", "locked": true })).unwrap();
for cmd in ["BREAKATPOINT", "BREAK"] {
s.cmdline(cmd).unwrap();
s.cmdline("5,0").unwrap();
assert!(s.prompt_text().ends_with("Select object:"), "{cmd}: {}", s.prompt_text());
assert!(s.log.iter().any(|l| l == "The object is on a locked layer."), "{cmd}: {:?}", s.log);
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{cmd}: {}", s.prompt_text());
}
assert_eq!(objects(&s).len(), 1);
}
#[test]
fn breakatpoint_from_lisp_with_a_bare_entity_name() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("(command \"_.BREAKATPOINT\" (entlast) '(1004.0 0.0))").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1004.0, 0.0)));
}
#[test]
fn breakatpoint_from_lisp_with_an_entity_and_point() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("(command \"_.BREAKATPOINT\" (list (entlast) '(1005.0 0.0)) '(1005.0 0.0))").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1005.0, 0.0)));
}
@@ -0,0 +1,187 @@
//! Which end of an open polyline EXTEND runs on, as AutoCAD 2024 chooses it (measured with
//! accoreconsole on these drawings): the end on the pick's side of the polyline's middle parameter.
//! The pick's parameter is the segment it is nearest, counted from 0, plus how far along that
//! segment it is; from half the number of segments on, the last end extends, below it the first.
//! Neither the end vertex nearer the pick nor the length along the polyline decides.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
type Vertex = (f64, f64, f64);
fn handle(v: &Value) -> String {
v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_owned()
}
/// The open polyline `vertices` with lines `edges`, extended at `pick` to the lines; its vertices
/// with their bulges.
fn extended(vertices: &[Vertex], edges: &[([f64; 2], [f64; 2])], pick: [f64; 2]) -> Vec<Vertex> {
let mut s = Session::new();
let vs: Vec<Value> = vertices.iter().map(|(x, y, b)| json!({ "p": [x, y], "bulge": b })).collect();
let p = handle(&s.execute("pline", &json!({ "vertices": vs, "closed": false })).unwrap());
let es: Vec<String> = edges.iter().map(|(a, b)| handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())).collect();
s.execute("extend", &json!({ "handle": p, "pick": pick, "edges": es })).unwrap();
match &s.doc().unwrap().entity(Handle::parse_hex(&p).unwrap()).unwrap().kind {
EntityKind::LwPolyline(l) => l.vertices.iter().map(|v| (v.p.x, v.p.y, v.bulge)).collect(),
k => panic!("{k:?}"),
}
}
fn same(got: &[Vertex], want: &[Vertex]) -> bool {
got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g.0 - w.0).abs() < 1e-6 && (g.1 - w.1).abs() < 1e-6 && (g.2 - w.2).abs() < 1e-6)
}
/// Vertical lines through x = `xs`, from `y0` to `y1`.
fn at(xs: &[f64], y0: f64, y1: f64) -> Vec<([f64; 2], [f64; 2])> {
xs.iter().map(|x| ([*x, y0], [*x, y1])).collect()
}
fn flat(pts: &[(f64, f64)]) -> Vec<Vertex> {
pts.iter().map(|(x, y)| (*x, *y, 0.0)).collect()
}
#[test]
fn the_end_on_the_picks_side_of_the_middle_parameter_extends() {
// (name, vertices, edges, pick, the vertices AutoCAD leaves). Lines at both ends, so either
// end could extend.
let cases: Vec<(&str, Vec<Vertex>, Vec<([f64; 2], [f64; 2])>, [f64; 2], Vec<(f64, f64)>)> = vec![
// 1.2 of 3 segments: the first end, though the pick is on a vertex of the middle one.
(
"1.2 of 3",
flat(&[(0.0, 160.0), (10.0, 160.0), (10.0, 165.0), (20.0, 165.0)]),
at(&[-5.0, 25.0], 155.0, 170.0),
[10.0, 161.0],
vec![(-5.0, 160.0), (10.0, 160.0), (10.0, 165.0), (20.0, 165.0)],
),
// 0.8: the first end, though the last vertex is nearer the pick.
(
"0.8, last vertex nearer",
flat(&[(0.0, 220.0), (20.0, 220.0), (20.0, 230.0), (15.0, 221.0)]),
vec![([-5.0, 215.0], [-5.0, 235.0]), ([0.0, 210.0], [30.0, 210.0])],
[16.0, 220.0],
vec![(-5.0, 220.0), (20.0, 220.0), (20.0, 230.0), (15.0, 221.0)],
),
(
"0.2",
flat(&[(0.0, 240.0), (20.0, 240.0), (20.0, 250.0), (5.0, 241.0)]),
vec![([-5.0, 235.0], [-5.0, 255.0]), ([-10.0, 230.0], [30.0, 230.0])],
[4.0, 240.0],
vec![(-5.0, 240.0), (20.0, 240.0), (20.0, 250.0), (5.0, 241.0)],
),
(
"1.9",
flat(&[(0.0, 260.0), (2.0, 260.0), (2.0, 280.0), (4.0, 280.0)]),
at(&[-5.0, 10.0], 255.0, 285.0),
[2.0, 278.0],
vec![(0.0, 260.0), (2.0, 260.0), (2.0, 280.0), (10.0, 280.0)],
),
// 0.9: the first end, though 18 of the 22 units along is nearer the last.
(
"0.9, length nearer the last",
flat(&[(0.0, 300.0), (20.0, 300.0), (20.0, 301.0), (21.0, 301.0)]),
at(&[-5.0, 25.0], 295.0, 305.0),
[18.0, 300.0],
vec![(-5.0, 300.0), (20.0, 300.0), (20.0, 301.0), (21.0, 301.0)],
),
(
"1.1",
flat(&[(0.0, 320.0), (2.0, 320.0), (2.0, 340.0), (4.0, 340.0)]),
at(&[-5.0, 10.0], 315.0, 345.0),
[2.0, 322.0],
vec![(-5.0, 320.0), (2.0, 320.0), (2.0, 340.0), (4.0, 340.0)],
),
(
"1.25",
flat(&[(0.0, 400.0), (30.0, 400.0), (30.0, 420.0), (31.0, 420.0)]),
at(&[-5.0, 40.0], 395.0, 425.0),
[30.0, 405.0],
vec![(-5.0, 400.0), (30.0, 400.0), (30.0, 420.0), (31.0, 420.0)],
),
(
"1.75",
flat(&[(0.0, 440.0), (1.0, 440.0), (1.0, 460.0), (31.0, 460.0)]),
at(&[-5.0, 40.0], 435.0, 465.0),
[1.0, 455.0],
vec![(0.0, 440.0), (1.0, 440.0), (1.0, 460.0), (40.0, 460.0)],
),
("0.6 of 1", flat(&[(0.0, 480.0), (20.0, 480.0)]), at(&[-5.0, 25.0], 475.0, 485.0), [12.0, 480.0], vec![(0.0, 480.0), (25.0, 480.0)]),
// 1.8 of 4, the end of the segment picked: the first end.
(
"1.8 of 4",
flat(&[(0.0, 500.0), (10.0, 500.0), (10.0, 510.0), (20.0, 510.0), (20.0, 520.0)]),
vec![([-5.0, 495.0], [-5.0, 525.0]), ([15.0, 530.0], [25.0, 530.0])],
[10.0, 508.0],
vec![(-5.0, 500.0), (10.0, 500.0), (10.0, 510.0), (20.0, 510.0), (20.0, 520.0)],
),
(
"2.8 of 4",
flat(&[(0.0, 540.0), (10.0, 540.0), (10.0, 550.0), (20.0, 550.0), (20.0, 560.0)]),
vec![([-5.0, 535.0], [-5.0, 565.0]), ([15.0, 570.0], [25.0, 570.0])],
[18.0, 550.0],
vec![(0.0, 540.0), (10.0, 540.0), (10.0, 550.0), (20.0, 550.0), (20.0, 570.0)],
),
// Right on the middle parameter, 1.5 of 3: the last end.
(
"1.5 of 3",
flat(&[(0.0, 600.0), (10.0, 600.0), (10.0, 610.0), (20.0, 610.0)]),
at(&[-5.0, 25.0], 595.0, 615.0),
[10.0, 605.0],
vec![(0.0, 600.0), (10.0, 600.0), (10.0, 610.0), (25.0, 610.0)],
),
];
for (name, vertices, edges, pick, want) in cases {
let got = extended(&vertices, &edges, pick);
assert!(same(&got, &flat(&want)), "{name}: {got:?}");
}
}
#[test]
fn the_parameter_runs_along_an_arc_segment_too() {
// The middle segment an arc of bulge -18, swinging round to within 2 of the first vertex:
// picked 60% along it (1.6 of 3), 3.6 from the first vertex and 18.3 from the last, the last
// end extends.
let got = extended(
&[(0.0, 0.0, 0.0), (10.0, 0.0, -18.0), (10.0, 1.0, 0.0), (20.0, 1.0, 0.0)],
&at(&[-5.0, 25.0], -10.0, 10.0),
[1.804081304825758, 3.0714821777453793],
);
assert!(same(&got, &[(0.0, 0.0, 0.0), (10.0, 0.0, -18.0), (10.0, 1.0, 0.0), (25.0, 1.0, 0.0)]), "{got:?}");
// The end segment an arc of bulge -0.5: picked on it (1.6 of 2) the last end runs on round
// its circle to x = 14.3; the same polyline turned round, picked on its first segment (0.4),
// the first end does.
let got = extended(&[(0.0, 40.0, 0.0), (10.0, 40.0, -0.5), (14.0, 40.0, 0.0)], &at(&[14.3], 30.0, 50.0), [12.0, 41.0]);
assert!(same(&got, &[(0.0, 40.0, 0.0), (10.0, 40.0, -0.5776771824075506), (14.3, 39.47979589711327, 0.0)]), "{got:?}");
let got = extended(&[(0.0, 60.0, -0.5), (4.0, 60.0, 0.0), (14.0, 60.0, 0.0)], &at(&[-0.3], 50.0, 70.0), [2.0, 61.0]);
assert!(same(&got, &[(-0.3, 59.47979589711327, -0.5776771824075504), (4.0, 60.0, 0.0), (14.0, 60.0, 0.0)]), "{got:?}");
}
#[test]
fn a_repeated_vertex_counts_as_a_segment() {
// (10, 0) twice: three segments, the middle one of no length. Picked on (10, 0), the end of
// the first, 1.0 of 3: the first end extends (counting two segments it would be the last).
// Picked 1 up the last segment, 2.1 of 3: the last end.
let vs = flat(&[(0.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 10.0)]);
let edges = vec![([-5.0, -10.0], [-5.0, 10.0]), ([-10.0, 15.0], [20.0, 15.0])];
let got = extended(&vs, &edges, [10.0, 0.0]);
assert!(same(&got, &flat(&[(-5.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 10.0)])), "{got:?}");
let got = extended(&vs, &edges, [10.0, 1.0]);
assert!(same(&got, &flat(&[(0.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 15.0)])), "{got:?}");
}
#[test]
fn a_pick_a_hair_outside_an_arc_end_counts_as_that_end() {
// A single semicircle from (1, 0) to (-1, 0). Picked 1e-13 outside its sweep at the first
// vertex, the pick is on the arc's start, not round the circle at its end: the first end runs
// on to x = 0, three quarters of the way round.
let b = 1.0 + 2f64.sqrt();
let got = extended(&[(1.0, 0.0, 1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], -2.0, -0.5), [1.0, -1e-13]);
assert!(same(&got, &[(0.0, -1.0, b), (-1.0, 0.0, 0.0)]), "{got:?}");
// A hair past its end is the last end.
let got = extended(&[(1.0, 0.0, 1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], -2.0, -0.5), [-1.0, -1e-13]);
assert!(same(&got, &[(1.0, 0.0, b), (0.0, -1.0, 0.0)]), "{got:?}");
// Turning clockwise, the arc's start angle is the polyline's last vertex: a hair outside it is
// the last end.
let got = extended(&[(1.0, 0.0, -1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], 0.5, 2.0), [-1.0, 1e-13]);
assert!(same(&got, &[(1.0, 0.0, -b), (0.0, 1.0, 0.0)]), "{got:?}");
}
+8
View File
@@ -17,9 +17,12 @@ mod block_keep;
mod block_redefine;
mod blockreplace;
mod break_closed_polyline;
mod break_ends_and_closing_side;
mod break_join_locked_layers;
mod break_keeps_z;
mod break_trim_keep_handle;
mod break_trim_polyline_rules;
mod breakatpoint_command_line;
mod burst;
mod change_command;
mod chprop_command;
@@ -52,6 +55,7 @@ mod dynamic_block_data;
mod dynamic_grips;
mod explode_stretched;
mod extend_polyline_arc_end;
mod extend_polyline_end_choice;
mod fillet_chamfer;
mod fix_holds_grips;
mod followups_626;
@@ -170,7 +174,11 @@ mod text_left_justify;
mod tolerance;
mod transparent;
mod trim_closed_polyline;
mod trim_cut_at_the_pick;
mod trim_cut_where_an_arc_span_starts;
mod trim_extend_json_pick;
mod trim_extend_options;
mod trim_keeps_z_and_width;
mod undo_count;
mod undo_layout_tab;
mod viewport_clip;
@@ -123,11 +123,13 @@ fn undo_restores_the_closed_polyline() {
}
#[test]
fn a_single_cut_still_opens_the_outline_there() {
fn a_single_cut_leaves_the_outline_as_it_was() {
// As AutoCAD 2024 does (measured with accoreconsole on a 100 x 10 rectangle cut once on its
// bottom): it refuses, "Curve must intersect cutting edges at least twice."
let mut s = Session::new();
let p = handle(s.execute("pline", &json!({ "vertices": square(), "closed": true })).unwrap());
let cutter = handle(s.execute("line", &json!({ "points": [[2, -1], [2, 1]] })).unwrap());
s.execute("trim", &json!({ "handle": p, "pick": [0, 2], "edges": [cutter] })).unwrap();
let all = [(2.0, 0.0, 0.0), (4.0, 0.0, 0.0), (4.0, 4.0, 0.0), (0.0, 4.0, 0.0), (0.0, 0.0, 0.0), (2.0, 0.0, 0.0)];
assert_eq!(polys(&s), vec![(false, all.to_vec())]);
let r = s.execute("trim", &json!({ "handle": p, "pick": [0, 2], "edges": [cutter] }));
assert!(r.is_err_and(|e| e.to_string() == "Curve must intersect cutting edges at least twice."));
assert_eq!(polys(&s), vec![(true, vec![(0.0, 0.0, 0.0), (4.0, 0.0, 0.0), (4.0, 4.0, 0.0), (0.0, 4.0, 0.0)])]);
}
@@ -0,0 +1,171 @@
//! TRIM of a line, an arc or a circle picked on a cut, as AutoCAD 2024 does it (measured with
//! accoreconsole on these drawings): a cut within 5e-7 of the pick, along the object, is passed
//! over, and the piece runs on across it to the next cut either side. With no cut left, nothing is
//! trimmed.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// Vertical lines through x = `xs`, from y = -15 to 15; their handles.
fn edges(s: &mut Session, xs: &[f64]) -> Vec<String> {
xs.iter().map(|x| handle(&s.execute("line", &json!({ "points": [[x, -15], [x, 15]] })).unwrap()).hex()).collect()
}
/// Every object but the edges: lines as their ends, arcs and circles as their angles in degrees.
fn shapes(s: &Session, edges: &[String]) -> Vec<(Handle, Vec<f64>)> {
let r = |v: f64| (v * 1e9).round() / 1e9;
s.doc()
.unwrap()
.model
.iter()
.filter(|e| !edges.contains(&e.handle.hex()))
.map(|e| {
let v = match &e.kind {
EntityKind::Line(l) => vec![l.a.x, l.a.y, l.b.x, l.b.y],
EntityKind::Arc(a) => vec![a.start.to_degrees(), a.end.to_degrees()],
EntityKind::Circle(_) => Vec::new(),
k => panic!("{k:?}"),
};
(e.handle, v.into_iter().map(r).collect())
})
.collect()
}
/// Trim `h` at `pick` with `edges`: whether the trim was made.
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edges: &[String]) -> bool {
s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "edges": edges })).is_ok()
}
/// A line from (0, 0) to (10, 0) with vertical lines through `xs`, trimmed at `pick`.
fn line_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn a_line_picked_on_its_only_cut_is_left_as_it_was() {
for pick in [[5.0, 0.0], [5.0000004, 0.0], [4.9999996, 0.0]] {
let (made, got, h) = line_trimmed(&[5.0], pick);
assert!(!made, "{pick:?}");
assert_eq!(got, vec![(h, vec![0.0, 0.0, 10.0, 0.0])], "{pick:?}");
}
}
#[test]
fn a_line_picked_on_one_of_two_cuts_loses_the_pieces_both_sides() {
// Cuts at x = 3 and 7: on 3, 0 to 7 goes; 4e-7 past 7, 3 to the end; between them, 3 to 7.
let (_, got, h) = line_trimmed(&[3.0, 7.0], [3.0, 0.0]);
assert_eq!(got, vec![(h, vec![7.0, 0.0, 10.0, 0.0])]);
let (_, got, h) = line_trimmed(&[3.0, 7.0], [7.0000004, 0.0]);
assert_eq!(got, vec![(h, vec![0.0, 0.0, 3.0, 0.0])]);
let (_, got, h) = line_trimmed(&[3.0, 7.0], [5.0, 0.0]);
assert_eq!(got.len(), 2);
assert_eq!(got[0], (h, vec![0.0, 0.0, 3.0, 0.0]));
assert_eq!(got[1].1, vec![7.0, 0.0, 10.0, 0.0]);
}
/// An arc of radius 10 about the origin from 0 to 180 degrees, with vertical lines through `xs`,
/// trimmed at `pick`.
fn arc_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("arc", &json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 180 })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn an_arc_picked_on_its_only_cut_is_left_as_it_was() {
// The line x = 0 cuts it at 90 degrees: on the cut and 4e-7 along from it nothing is trimmed,
// 6e-7 along the arc from 90 to 180 goes.
for pick in [[0.0, 10.0], [-4e-7, 10.0]] {
let (made, got, h) = arc_trimmed(&[0.0], pick);
assert!(!made, "{pick:?}");
assert_eq!(got, vec![(h, vec![0.0, 180.0])], "{pick:?}");
}
let (_, got, h) = arc_trimmed(&[0.0], [-6e-7, 10.0]);
assert_eq!(got, vec![(h, vec![0.0, 90.0])]);
}
#[test]
fn an_arc_picked_on_its_last_cut_loses_the_rest() {
// Cuts at 60 and 120 degrees, picked on 120: from 60 to the end goes.
let (_, got, h) = arc_trimmed(&[5.0, -5.0], [-5.0, 75f64.sqrt()]);
assert_eq!(got, vec![(h, vec![0.0, 60.0])]);
}
/// A circle of radius 10 about the origin, with vertical lines through `xs`, trimmed at `pick`.
fn circle_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn a_circle_picked_on_a_cut_loses_the_arcs_both_sides() {
// Lines at x = 5 and -5 cut it at 60, 120, 240 and 300 degrees. Picked on 60, and 4e-7 along
// from it, the arc from 300 round to 120 goes; picked at 90, the arc from 60 to 120.
let y = 75f64.sqrt();
for pick in [[5.0, y], [4.9999998, y + 2e-7 * 5.0 / y]] {
let (_, got, h) = circle_trimmed(&[5.0, -5.0], pick);
assert_eq!(got, vec![(h, vec![120.0, 300.0])], "{pick:?}");
}
let (_, got, h) = circle_trimmed(&[5.0, -5.0], [0.0, 10.0]);
assert_eq!(got, vec![(h, vec![120.0, 60.0])]);
}
#[test]
fn a_circle_picked_on_one_of_two_cuts_is_left_as_it_was() {
// One line, cutting it at 60 and 300 degrees: picked on 60, one cut is left and the trim is
// refused.
let (made, got, h) = circle_trimmed(&[5.0], [5.0, 75f64.sqrt()]);
assert!(!made);
assert_eq!(got, vec![(h, Vec::new())]);
}
#[test]
fn quick_mode_leaves_an_object_picked_on_its_only_cut() {
// The line, the arc and the circle each meet the edges, at the pick, so Quick mode doesn't
// erase them as objects no edge crosses.
let y = 75f64.sqrt();
let cases = [
("line", json!({ "points": [[0, 0], [10, 0]] }), 5.0, [5.0, 0.0]),
("arc", json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 180 }), 0.0, [0.0, 10.0]),
("circle", json!({ "center": [0, 0], "radius": 10 }), 5.0, [5.0, y]),
];
for (cmd, shape, x, pick) in cases {
let mut s = Session::new();
let h = handle(&s.execute(cmd, &shape).unwrap());
let es = edges(&mut s, &[x]);
let r = s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "mode": "quick" }));
assert!(r.is_err(), "{cmd}");
assert!(s.doc().unwrap().entity(h).is_some(), "{cmd} was erased");
assert_eq!(shapes(&s, &es).len(), 1, "{cmd}");
}
}
#[test]
fn an_arc_picked_just_off_one_end_loses_the_piece_at_that_end() {
// From 0 to 90 degrees, cut at 45: picked just before its start the piece from 0 goes, just
// past its end the piece to 90.
let x = 10.0 * std::f64::consts::FRAC_PI_4.cos();
let trimmed = |pick: [f64; 2]| {
let mut s = Session::new();
let h = handle(&s.execute("arc", &json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 90 })).unwrap());
let es = edges(&mut s, &[x]);
assert!(trim(&mut s, h, pick, &es));
shapes(&s, &es)
};
assert_eq!(trimmed([10.0, -0.01])[0].1, vec![45.0, 90.0]);
assert_eq!(trimmed([-0.01, 10.0])[0].1, vec![0.0, 45.0]);
}
@@ -0,0 +1,42 @@
//! TRIM on a polyline cut through the vertex where an arc span starts: the cut is at that vertex
//! only. Where the crossing came out a hair before the arc's start angle it was also put at the
//! arc's far end, round the circle, and TRIM took out the arc alone.
use cadcraft_engine::Session;
use cadcraft_engine::doc::EntityKind;
use serde_json::json;
fn handle(v: serde_json::Value) -> String {
v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_owned()
}
#[test]
fn the_cut_is_at_the_arc_spans_start_vertex_only() {
// (0, 0) to (10, 0), a semicircle round (15, 5) to (10, 10), then on to (0, 10). A line
// through (10, 0) running up to the left crosses the top span at x = 10 + 10 cot(angle);
// picked on the arc, the polyline goes from (10, 0) to there.
for k in 0..172 {
let th = (91.0 + f64::from(k) * 0.25).to_radians();
let d = [th.cos() * 30.0, th.sin() * 30.0];
let mut s = Session::new();
let p = handle(s.execute("pline", &json!({ "vertices": [[0, 0], { "p": [10, 0], "bulge": 1 }, [10, 10], [0, 10]] })).unwrap());
let e = handle(s.execute("line", &json!({ "points": [[10.0 - d[0], -d[1]], [10.0 + d[0], d[1]]] })).unwrap());
s.execute("trim", &json!({ "handle": p, "pick": [15, 5], "edges": [e] })).unwrap();
let pieces: Vec<Vec<(f64, f64)>> = s
.doc()
.unwrap()
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::LwPolyline(l) => Some(l.vertices.iter().map(|v| (v.p.x, v.p.y)).collect()),
_ => None,
})
.collect();
let x = 10.0 + 10.0 / th.tan();
let near = |a: (f64, f64), b: (f64, f64)| (a.0 - b.0).abs() < 1e-6 && (a.1 - b.1).abs() < 1e-6;
let ok = pieces.len() == 2
&& pieces.iter().any(|v| v.len() == 2 && near(v[0], (0.0, 0.0)) && near(v[1], (10.0, 0.0)))
&& pieces.iter().any(|v| v.len() == 2 && near(v[0], (x, 10.0)) && near(v[1], (0.0, 10.0)));
assert!(ok, "{:.2} degrees: {pieces:?}", th.to_degrees());
}
}
@@ -0,0 +1,177 @@
//! JSON execute pick roles and diagnostic-only refusals (#2750).
use cadcraft_doc::{Common, EntityKind, Handle, Line, Space};
use cadcraft_engine::{Session, find_command};
use cadcraft_geom::Vec3;
use serde_json::{Value, json};
type TestResult<T = ()> = Result<T, Box<dyn std::error::Error>>;
fn fixture(end: f64, edge_x: f64) -> TestResult<(Session, Handle, Handle)> {
let mut s = Session::new();
let a = s.doc_mut()?.add(&Space::Model, Common::default(), EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(end, 0.0, 0.0) }))?;
let b = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(edge_x, -20.0, 0.0), b: Vec3::new(edge_x, 20.0, 0.0) }),
)?;
Ok((s, a, b))
}
fn assert_line(s: &Session, h: Handle, start: f64, end: f64) -> TestResult {
let e = s.doc()?.entity(h).ok_or("line missing")?;
let EntityKind::Line(l) = &e.kind else { return Err("expected line".into()) };
assert_eq!((l.a, l.b), (Vec3::new(start, 0.0, 0.0), Vec3::new(end, 0.0, 0.0)));
Ok(())
}
fn failure(s: &mut Session, cmd: &str, params: Value, message: &str) -> TestResult {
let before = s.doc()?.clone();
let selection = s.state()?.selection.clone();
let error = s.execute(cmd, &params).err().ok_or("expected refusal")?;
assert_eq!(error.to_string(), message);
assert_eq!(s.doc()?, &before, "a failed JSON call must leave the whole drawing unchanged");
assert_eq!(s.state()?.selection, selection);
Ok(())
}
#[test]
fn trim_execute_pick_selects_the_portion_to_remove() -> TestResult {
// Off-object picks that already succeed by projection remain accepted.
for (pick, start, end) in [([5, 0], 25.0, 50.0), ([40, 0], 0.0, 25.0), ([5, 3], 25.0, 50.0)] {
let (mut s, a, b) = fixture(50.0, 25.0)?;
let boundary = s.doc()?.entity(b).cloned().ok_or("boundary missing")?;
let result = s.execute("trim", &json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick}))?;
let handles = result["handles"].as_array().ok_or("expected handles")?;
assert_eq!(handles.len(), 1);
let h = handles.first().and_then(Value::as_str).and_then(Handle::parse_hex).ok_or("expected trimmed handle")?;
assert_eq!(h, a, "TRIM keeps the original handle on the surviving piece");
assert_line(&s, h, start, end)?;
assert_eq!(s.doc()?.entity(b), Some(&boundary));
}
Ok(())
}
#[test]
fn extend_execute_pick_selects_the_end_toward_the_boundary() -> TestResult {
for pick in [[25, 10], [25, -15], [19, 0], [40, 0]] {
let (mut s, a, b) = fixture(20.0, 25.0)?;
let boundary = s.doc()?.entity(b).cloned().ok_or("boundary missing")?;
let result = s.execute("extend", &json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick}))?;
assert_eq!(result, Value::Null);
assert_line(&s, a, 0.0, 25.0)?;
assert_eq!(s.doc()?.entity(b), Some(&boundary));
}
Ok(())
}
#[test]
fn trim_execute_distinguishes_picks_at_or_projecting_onto_a_cut_from_no_cut() -> TestResult {
let (mut s, a, b) = fixture(50.0, 25.0)?;
for (pick, message) in [
([25, 10], "The `pick` point is off the line and projects onto a cutting intersection; pick away from that intersection."),
([25, 0], "The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection."),
] {
failure(&mut s, "trim", json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick, "mode": "standard"}), message)?;
}
let (mut s, a, b) = fixture(50.0, 75.0)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [5, 0]}),
"No usable cutting-edge intersection in the interior of the object to trim.",
)
}
#[test]
fn extend_execute_distinguishes_the_wrong_end_from_no_boundary_hit() -> TestResult {
let (mut s, a, b) = fixture(20.0, 25.0)?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [10, 0]}),
"The `pick` point selects an end with no boundary ahead; choose `pick` toward the boundary to extend to.",
)?;
s.doc_mut()?.modify_entity(b, |e| {
e.kind = EntityKind::Line(Line { a: Vec3::new(0.0, 20.0, 0.0), b: Vec3::new(25.0, 20.0, 0.0) });
})?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [25, 20]}),
"No usable boundary intersection was found for either end of the object to extend.",
)
}
#[test]
fn quick_erasure_and_unrelated_errors_keep_their_behavior() -> TestResult {
let (mut s, a, b) = fixture(50.0, 25.0)?;
// Quick mode leaves a line picked on its only cut in place (#2648), and the JSON form explains
// the refusal as Standard mode does.
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [25, 0], "mode": "quick"}),
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection.",
)?;
assert!(s.doc()?.entity(a).is_some());
assert!(s.doc()?.entity(b).is_some());
failure(&mut s, "trim", json!({"handle": "DEAD", "pick": [5, 0]}), "no such object")
}
#[test]
fn command_contracts_and_missing_pick_errors_explain_the_roles() -> TestResult {
let trim = find_command("trim").ok_or("trim not registered")?;
assert!(trim.params.contains("pick selects the portion of that object to remove"));
assert!(trim.params.contains("edges are the cutting edges"));
let extend = find_command("extend").ok_or("extend not registered")?;
assert!(extend.params.contains("pick points toward the boundary to extend to"));
assert!(extend.params.contains("selecting the nearer end"));
assert!(extend.params.contains("edges are the boundary edges"));
let (mut s, a, b) = fixture(20.0, 25.0)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()]}),
"invalid parameters for `trim`: `pick` ([x, y]) is required: select the portion of the object to trim away",
)?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()]}),
"invalid parameters for `extend`: `pick` ([x, y]) is required: point toward the boundary to extend to, selecting the nearer end",
)
}
#[test]
fn a_pick_on_the_line_far_from_the_origin_is_not_called_off_the_line() -> TestResult {
// Survey coordinates: rounding there is far above 1e-9 (the pick below is 3.7e-9 off the line
// after rounding), so a pick on the line still reads as on it.
let (x0, y0, k) = (123_456_789.1, 9_876_543.3, 33.3333);
let mut s = Session::new();
let a = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(x0, y0, 0.0), b: Vec3::new(x0 + 50.0, y0 + 30.0, 0.0) }),
)?;
let b = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(x0 + k, y0 - 20.0, 0.0), b: Vec3::new(x0 + k, y0 + 50.0, 0.0) }),
)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [x0 + k, y0 + k * 0.6]}),
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection.",
)
}
#[test]
fn the_extend_contract_names_the_polyline_end_rule() -> TestResult {
// An open polyline extends the end on the pick's side of its middle parameter (#2693), not
// the nearer end.
let extend = find_command("extend").ok_or("extend not registered")?;
assert!(extend.params.contains("middle"), "{}", extend.params);
Ok(())
}
+25 -2
View File
@@ -112,10 +112,33 @@ fn crossing_window_trims_what_it_touches() {
s.script("TRIM C 4,-1 6,1\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(lines(&s), with_edges(&[((-5.0, 0.0), (0.0, 0.0)), ((-5.0, 2.0), (15.0, 2.0)), ((10.0, 0.0), (15.0, 0.0))]));
// A pick in empty space opens a crossing window too.
}
#[test]
fn a_pick_in_empty_space_starts_a_fence_in_quick_mode_and_a_window_in_standard_mode() {
// #1594: Quick mode's two-point fence trims what it crosses and returns to the first prompt.
for cmd in ["TRIM", "EXTEND"] {
let mut s = ladder();
s.cmdline(cmd).unwrap();
s.cmdline("4,-4").unwrap();
assert!(s.prompt_text().contains("Specify next fence point"), "{cmd}: {}", s.prompt_text());
}
let mut s = ladder();
s.script("TRIM 4,-4 6,1\n\n").unwrap();
s.script("TRIM 4,-4 6,1\n").unwrap();
assert!(s.prompt_text().contains("Select object to trim"), "{}", s.prompt_text());
s.cmdline("").unwrap();
assert_eq!(lines(&s), with_edges(&[((-5.0, 0.0), (0.0, 0.0)), ((-5.0, 2.0), (15.0, 2.0)), ((10.0, 0.0), (15.0, 0.0))]));
// EXTEND's fence extends both lines it crosses to the boundary at x = 10.
let mut s = session(&["10,-5 10,5", "0,0 4,0", "0,2 4,2"]);
s.script("EXTEND 3,-1 3,3\n").unwrap();
assert!(s.prompt_text().contains("Select object to extend"), "{}", s.prompt_text());
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(lines(&s), vec![((0.0, 0.0), (10.0, 0.0)), ((0.0, 2.0), (10.0, 2.0)), ((10.0, -5.0), (10.0, 5.0))]);
// Standard mode keeps the crossing window.
let mut s = ladder();
s.script("TRIM O S\n\n4,-4\n").unwrap();
assert!(s.prompt_text().contains("Specify opposite corner"), "{}", s.prompt_text());
}
#[test]
@@ -0,0 +1,102 @@
//! TRIM keeps what the object has beyond its outline, as BREAK does: a line's Z, an arc's centre
//! Z (a circle trimmed into an arc), a polyline's elevation, and a polyline's constant width on
//! every piece. The Z cases and the width on BREAK were measured in AutoCAD 2024 (accoreconsole)
//! on these drawings.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Circle, Common, Entity, EntityKind, Handle, Line, LwPolyline};
use cadcraft_engine::geom::{PolyVertex, Vec2, Vec3};
use serde_json::json;
fn add(s: &mut Session, kind: EntityKind, thickness: f64) -> Handle {
let space = s.space();
let d = s.doc_mut().unwrap();
let handle = d.new_handle();
d.space_mut(&space).unwrap().push(Entity { handle, common: Common { thickness, ..Common::default() }, kind });
handle
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
let v = s.execute("line", &json!({ "points": [a, b] })).unwrap();
Handle::parse_hex(v["handles"][0].as_str().unwrap()).unwrap()
}
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edge: Handle) {
s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "edges": [edge.hex()] })).unwrap();
}
fn kind(s: &Session, h: Handle) -> EntityKind {
s.doc().unwrap().entity(h).unwrap().kind.clone()
}
fn polyline(vertices: &[(f64, f64, f64)], const_width: f64, elevation: f64, plinegen: bool) -> EntityKind {
let vertices = vertices.iter().map(|&(x, y, bulge)| PolyVertex { bulge, ..PolyVertex::new(Vec2::new(x, y)) }).collect();
EntityKind::LwPolyline(LwPolyline { vertices, closed: false, const_width, elevation, plinegen })
}
fn near(a: Vec3, b: Vec3, tol: f64) -> bool {
(a.x - b.x).abs() < tol && (a.y - b.y).abs() < tol && (a.z - b.z).abs() < tol
}
#[test]
fn trim_keeps_a_lines_z() {
let mut s = Session::new();
let a = add(&mut s, EntityKind::Line(Line { a: Vec3::new(0.5, 0.25, 0.007), b: Vec3::new(0.54, 0.25, 0.007) }), 0.0);
let b = line(&mut s, [0.52, 0.24], [0.52, 0.26]);
trim(&mut s, a, [0.53, 0.25], b);
let EntityKind::Line(l) = kind(&s, a) else { panic!("not a line") };
assert!(near(l.a, Vec3::new(0.5, 0.25, 0.007), 1e-12) && near(l.b, Vec3::new(0.52, 0.25, 0.007), 1e-12), "{l:?}");
}
#[test]
fn trim_keeps_the_centre_z_of_a_circle_made_an_arc() {
// At survey coordinates, with a thickness of 2.
let mut s = Session::new();
let c = add(&mut s, EntityKind::Circle(Circle { center: Vec3::new(612345.678, 2398765.432, 5.0), radius: 10.0 }), 2.0);
let b = line(&mut s, [612350.678, 2398745.432], [612350.678, 2398785.432]);
trim(&mut s, c, [612335.678, 2398765.432], b);
let e = s.doc().unwrap().entity(c).unwrap().clone();
let EntityKind::Arc(a) = &e.kind else { panic!("not an arc: {:?}", e.kind) };
assert!(near(a.center, Vec3::new(612345.678, 2398765.432, 5.0), 1e-9), "{a:?}");
assert!((a.start - 5.235987755978257).abs() < 1e-9 && (a.end - 1.047197551201328).abs() < 1e-9, "{a:?}");
assert_eq!(e.common.thickness, 2.0);
}
#[test]
fn trim_keeps_a_polylines_elevation() {
let mut s = Session::new();
let p = add(&mut s, polyline(&[(0.0, 0.0, 0.0), (20.0, 0.0, 0.4), (30.0, 15.0, 0.0), (5.0, 20.0, 0.0)], 0.0, 12.5, false), 1.0);
let b = line(&mut s, [10.0, -10.0], [10.0, 30.0]);
trim(&mut s, p, [5.0, 0.0], b);
let EntityKind::LwPolyline(l) = kind(&s, p) else { panic!("not a polyline") };
assert_eq!(l.elevation, 12.5);
let want = [(10.0, 0.0, 0.0), (20.0, 0.0, 0.4), (30.0, 15.0, 0.0), (5.0, 20.0, 0.0)];
assert_eq!(l.vertices.len(), want.len());
for (v, w) in l.vertices.iter().zip(want) {
assert!(near(Vec3::new(v.p.x, v.p.y, v.bulge), Vec3::new(w.0, w.1, w.2), 1e-12), "{v:?} != {w:?}");
}
}
#[test]
fn break_and_trim_keep_a_polylines_constant_width_on_every_piece() {
// Measured for BREAK: a width-2 polyline broken from (705, 0) to (735, 0) leaves two width-2
// pieces. TRIM leaves its pieces the same way. Linetype generation is the polyline's setting
// too, so the pieces keep it (not measured).
let shape = [(700.0, 0.0, 0.0), (720.0, 0.0, 0.0), (740.0, 0.0, 0.0)];
let mut s = Session::new();
let p = add(&mut s, polyline(&shape, 2.0, 0.0, true), 0.0);
let r = s.execute("break", &json!({ "handle": p.hex(), "p1": [705, 0], "p2": [735, 0] })).unwrap();
let mut s2 = Session::new();
let q = add(&mut s2, polyline(&shape, 2.0, 0.0, true), 0.0);
let k1 = line(&mut s2, [705.0, -5.0], [705.0, 5.0]);
let k2 = line(&mut s2, [735.0, -5.0], [735.0, 5.0]);
let t = s2.execute("trim", &json!({ "handle": q.hex(), "pick": [720, 0], "edges": [k1.hex(), k2.hex()] })).unwrap();
for (s, r) in [(&s, &r), (&s2, &t)] {
let hs = r["handles"].as_array().unwrap();
assert_eq!(hs.len(), 2);
for h in hs {
let EntityKind::LwPolyline(l) = kind(s, Handle::parse_hex(h.as_str().unwrap()).unwrap()) else { panic!("not a polyline") };
assert_eq!((l.const_width, l.plinegen), (2.0, true));
}
}
}
+2 -2
View File
@@ -41,8 +41,8 @@ use cadcraft_geom::Vec2;
use craft_shx::Record;
pub use craft_shx::{ShxError, ShxKind, compile};
pub use table::{
FontProvider, OpenGuard, add_drawing_dir, add_drawing_dir_guarded, clear_registered, drawing_dirs, find, font_map, generation, installed,
register, search_path, set_font_dirs, set_font_map, set_provider, set_search_path,
FontProvider, add_drawing_dir, clear_registered, drawing_dirs, find, font_map, generation, installed, register, search_path, set_font_dirs,
set_font_map, set_provider, set_search_path,
};
pub use text::ShxText;
pub(crate) use text::{shape, width};
+19 -108
View File
@@ -20,23 +20,14 @@ use super::{ShxError, ShxFont};
/// app's own font folder). Called with the normalised file name (`romans.shx`); returns the
/// file's bytes. Called without the font table's lock held.
pub trait FontProvider: Send + Sync {
/// The bytes of the font file `file_name`, or `None` when this provider has none by that name.
fn load(&self, file_name: &str) -> Option<Vec<u8>>;
}
/// Decides whether the file at a path may be opened by the font search; asked of every candidate in
/// a folder, before anything opens it.
pub type OpenGuard = Arc<dyn Fn(&Path) -> bool + Send + Sync>;
/// Most fonts kept loaded, and their total bytes.
const MAX_FONTS: usize = 128;
const MAX_LOADED_BYTES: usize = 256 << 20;
/// Most drawing folders and search path entries remembered.
const MAX_DIRS: usize = 32;
/// Most folders whose guards are kept.
const MAX_GUARDED_DIRS: usize = 1024;
/// Most guards kept past [`MAX_GUARDED_DIRS`], each applying to every folder searched.
const MAX_OVERFLOW_GUARDS: usize = 4096;
/// Most font map entries.
const MAX_MAP: usize = 1024;
@@ -47,12 +38,6 @@ struct Table {
loaded_bytes: usize,
provider: Option<Arc<dyn FontProvider>>,
drawing_dirs: Vec<PathBuf>,
/// The guards of the drawing folders that have any, by the owner that gave each one.
drawing_guards: HashMap<PathBuf, Vec<(String, OpenGuard)>>,
/// Guards given once [`MAX_GUARDED_DIRS`] folders had one: they apply to every folder searched.
overflow_guards: Vec<(String, OpenGuard)>,
/// The overflow guards ran out: every file is refused from then on.
overflow_closed: bool,
font_dirs: Vec<PathBuf>,
search_path: Vec<PathBuf>,
map: Vec<(String, String)>,
@@ -133,55 +118,16 @@ pub fn set_provider(provider: Option<Arc<dyn FontProvider>>) {
/// Search the folder of a drawing being opened for the fonts its styles name (most recent
/// first).
pub fn add_drawing_dir(dir: &Path) {
add_dir(dir, None);
}
/// Like [`add_drawing_dir`], with every file the search would open in `dir` put to `guard` first,
/// whatever its name and however it is found in the folder: a font the guard refuses is skipped.
///
/// The table is shared by the whole process, so a folder keeps the guard of every `owner` that gave
/// one (an owner giving it again replaces its own) and a font is opened only when all of them allow
/// it. Adding the folder without a guard never removes one. Fonts found are kept for every caller,
/// so owners with different rules shouldn't share a process.
pub fn add_drawing_dir_guarded(dir: &Path, owner: &str, guard: OpenGuard) {
add_dir(dir, Some((owner, guard)));
}
/// Remember `dir`, most recent first, with the guard it is searched under, if any. The folder's
/// guards are kept after it drops off the list of drawing folders.
fn add_dir(dir: &Path, guard: Option<(&str, OpenGuard)>) {
if dir.as_os_str().is_empty() {
return;
}
let mut t = table();
if guard.is_none() && t.drawing_dirs.first().is_some_and(|d| d == dir) {
if t.drawing_dirs.first().is_some_and(|d| d == dir) {
return;
}
// Guards outlive the drawing list: a folder dropped from it can still be reached as a font
// folder or on the search path. When there is no room for another folder's guards, they apply to
// every folder searched from then on, so nothing is left unguarded.
let no_room = !t.drawing_guards.contains_key(dir) && t.drawing_guards.len() >= MAX_GUARDED_DIRS;
t.drawing_dirs.retain(|d| d != dir);
t.drawing_dirs.insert(0, dir.to_path_buf());
t.drawing_dirs.truncate(MAX_DIRS);
if let Some((owner, guard)) = guard {
if no_room {
// Every overflow guard stays: none may be replaced by another folder's. When even these
// run out, everything is refused from then on.
let kept = &mut t.overflow_guards;
if !kept.iter().any(|(_, g)| Arc::ptr_eq(g, &guard)) {
if kept.len() < MAX_OVERFLOW_GUARDS {
kept.push((owner.to_string(), guard));
} else {
t.overflow_closed = true;
}
}
} else {
let guards = t.drawing_guards.entry(dir.to_path_buf()).or_default();
guards.retain(|(o, _)| o != owner);
guards.push((owner.to_string(), guard));
}
}
t.changed();
}
@@ -248,7 +194,7 @@ pub fn generation() -> u64 {
/// The SHX font file a style or linetype names, if CADCraft can find and read it.
pub fn find(name: &str) -> Option<Arc<ShxFont>> {
let mut k = key(name)?;
let (provider, folders, (guarded, overflow), generation) = {
let (provider, dirs, generation) = {
let t = table();
// The font map renames once (a map can't loop).
if let Some(to) = t.map.iter().find(|(from, _)| *from == k).and_then(|(_, to)| key(to)) {
@@ -260,29 +206,9 @@ pub fn find(name: &str) -> Option<Arc<ShxFont>> {
if let Some(r) = t.resolved.get(&k) {
return r.clone();
}
let folders: Vec<PathBuf> = t.drawing_dirs.iter().chain(t.font_dirs.iter()).chain(t.search_path.iter()).cloned().collect();
let guarded: Vec<(PathBuf, Vec<OpenGuard>)> =
t.drawing_guards.iter().map(|(d, g)| (d.clone(), g.iter().map(|(_, g)| g.clone()).collect())).collect();
let mut overflow: Vec<OpenGuard> = t.overflow_guards.iter().map(|(_, g)| g.clone()).collect();
if t.overflow_closed {
overflow.push(Arc::new(|_: &Path| false));
}
(t.provider.clone(), folders, (guarded, overflow), t.generation)
let dirs: Vec<PathBuf> = t.drawing_dirs.iter().chain(t.font_dirs.iter()).chain(t.search_path.iter()).cloned().collect();
(t.provider.clone(), dirs, t.generation)
};
// A guard belongs to the folder, however the search reaches it: a font folder or the search path
// naming the same folder as a drawing's is held to the same guards.
// Each folder is resolved once per lookup (spelled, and as the file system has it).
let resolved = |d: &Path| std::fs::canonicalize(d).ok();
let guarded: Vec<(PathBuf, Option<PathBuf>, Vec<OpenGuard>)> = guarded.into_iter().map(|(d, g)| (d.clone(), resolved(&d), g)).collect();
let dirs: Vec<(PathBuf, Vec<OpenGuard>)> = folders
.into_iter()
.map(|d| {
let real = resolved(&d);
let own = guarded.iter().filter(|(g, r, _)| *g == d || (real.is_some() && *r == real)).flat_map(|(_, _, g)| g.iter().cloned());
let guards = own.chain(overflow.iter().cloned()).collect();
(d, guards)
})
.collect();
let font = provider
.and_then(|p| p.load(&k))
.or_else(|| read_from(&dirs, &k))
@@ -340,24 +266,24 @@ pub fn installed() -> Vec<String> {
/// The file `name` (a lower-case key) in the first of `dirs` that has it, whatever the case of
/// its name: lower-case, upper-case, else any other case found in the directory (`Simplex.shx`
/// on a case-sensitive file system). Each of a folder's guards is asked about each candidate before
/// anything opens it, so a link is judged by where it leads.
/// on a case-sensitive file system).
#[cfg(not(target_arch = "wasm32"))]
fn read_from(dirs: &[(PathBuf, Vec<OpenGuard>)], name: &str) -> Option<Vec<u8>> {
for (d, guards) in dirs {
let read = |file: &Path| -> Option<Vec<u8>> {
if !guards.iter().all(|g| g(file)) {
return None;
}
read_file(file)
};
fn read_from(dirs: &[PathBuf], name: &str) -> Option<Vec<u8>> {
use std::io::Read as _;
let read = |file: &Path| -> Option<Vec<u8>> {
let meta = std::fs::metadata(file).ok()?;
if !meta.is_file() || meta.len() > MAX_FILE_BYTES as u64 {
return None;
}
let mut bytes = Vec::new();
let limit = u64::try_from(MAX_FILE_BYTES).unwrap_or(u64::MAX).saturating_add(1);
std::fs::File::open(file).and_then(|f| f.take(limit).read_to_end(&mut bytes)).ok()?;
Some(bytes)
};
for d in dirs {
if let Some(b) = [d.join(name), d.join(name.to_ascii_uppercase())].iter().find_map(|f| read(f)) {
return Some(b);
}
// The folder is listed only when its guards allow the folder itself.
if !guards.iter().all(|g| g(d)) {
continue;
}
let Ok(entries) = std::fs::read_dir(d) else { continue };
let found = entries
.take(MAX_DIR_ENTRIES)
@@ -371,22 +297,7 @@ fn read_from(dirs: &[(PathBuf, Vec<OpenGuard>)], name: &str) -> Option<Vec<u8>>
None
}
/// The bytes of the SHX file at `file`, when it is a file of a sensible size.
#[cfg(not(target_arch = "wasm32"))]
fn read_file(file: &Path) -> Option<Vec<u8>> {
use std::io::Read as _;
let meta = std::fs::metadata(file).ok()?;
if !meta.is_file() || meta.len() > MAX_FILE_BYTES as u64 {
return None;
}
let mut bytes = Vec::new();
let limit = u64::try_from(MAX_FILE_BYTES).unwrap_or(u64::MAX).saturating_add(1);
std::fs::File::open(file).and_then(|f| f.take(limit).read_to_end(&mut bytes)).ok()?;
Some(bytes)
}
/// On the web there are no folders to search.
#[cfg(target_arch = "wasm32")]
fn read_from(_dirs: &[(PathBuf, Vec<OpenGuard>)], _name: &str) -> Option<Vec<u8>> {
fn read_from(_dirs: &[PathBuf], _name: &str) -> Option<Vec<u8>> {
None
}
-100
View File
@@ -1,100 +0,0 @@
//! A guarded drawing folder: the font search asks the guard about every file it would open there,
//! before opening it (the automation roots use this to keep a font link from leading out of them).
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,guard\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// The lower-case file name of `file`, so a guard never reads the test folder's own name.
fn name(file: &Path) -> String {
file.file_name().map(|n| n.to_string_lossy().to_ascii_lowercase()).unwrap_or_default()
}
/// Every candidate the search opens in a guarded folder goes to the guard first, whatever its name
/// or how the search finds it, and a font the guard refuses is skipped while the others are used.
#[test]
fn every_file_the_search_opens_goes_to_the_guard_first() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("guard");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-guard-ok.shx"), &bytes).unwrap();
std::fs::write(dir.join("cadcraft-guard-bad.shx"), &bytes).unwrap();
// Found only by looking through the folder, as a link under another spelling would be.
std::fs::write(dir.join("CadCraft-Guard-Mixed.SHX"), &bytes).unwrap();
std::fs::write(dir.join("CadCraft-Guard-Badmixed.SHX"), &bytes).unwrap();
let asked: Arc<Mutex<Vec<PathBuf>>> = Arc::default();
let log = asked.clone();
shx::add_drawing_dir_guarded(
&dir,
"first",
Arc::new(move |file: &Path| {
log.lock().unwrap().push(file.to_path_buf());
!name(file).contains("bad")
}),
);
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
assert!(shx::find("cadcraft-guard-mixed.shx").is_some(), "a name found by looking through the folder");
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "a font the guard refuses is skipped");
assert!(shx::find("cadcraft-guard-badmixed.shx").is_none(), "also one found by looking through the folder");
let asked = asked.lock().unwrap();
// The guard saw each font's file under the spelling the search tried (a file system that
// ignores case answers the first one, so only the letters are compared).
for file in ["cadcraft-guard-ok.shx", "cadcraft-guard-bad.shx", "cadcraft-guard-mixed.shx", "cadcraft-guard-badmixed.shx"] {
let want = dir.join(file).to_string_lossy().to_ascii_lowercase();
assert!(asked.iter().any(|a| a.to_string_lossy().to_ascii_lowercase() == want), "the guard was asked about {file}: {asked:?}");
}
drop(asked);
// The folder added again without a guard (another session in the process) keeps its guard.
shx::add_drawing_dir(&dir);
assert!(shx::find("cadcraft-guard-bad.shx").is_none());
// Another owner's guard is required as well: a font is opened only when every owner allows it.
shx::add_drawing_dir_guarded(&dir, "second", Arc::new(|file: &Path| !name(file).contains("ok")));
assert!(shx::find("cadcraft-guard-ok.shx").is_none(), "refused by the second owner");
assert!(shx::find("cadcraft-guard-mixed.shx").is_some(), "allowed by both");
// An owner giving its guard again replaces its own, and the other's stays.
shx::add_drawing_dir_guarded(&dir, "second", Arc::new(|_: &Path| true));
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "the first owner's guard still holds");
// The same folder named as a font folder or on the search path is held to its guards too.
shx::set_font_dirs(vec![dir.clone()]);
shx::set_search_path(&dir.to_string_lossy());
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "a font folder or the search path doesn't lift the guard");
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
// The folder falling off the list of drawing folders (the list is short) keeps its guards while a
// font folder or the search path still reaches it.
for n in 0..40 {
shx::add_drawing_dir(&dir.join(format!("other-{n}")));
}
assert!(!shx::drawing_dirs().contains(&dir));
assert!(shx::find("cadcraft-guard-bad.shx").is_none(), "the outside font stays rejected after the eviction");
assert!(shx::find("cadcraft-guard-ok.shx").is_some());
}
-50
View File
@@ -1,50 +0,0 @@
//! When even the overflow guards run out, every font is refused, whatever name the owners gave.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::Path;
use std::sync::Arc;
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,closed\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Past every limit, a font that no guard objects to is still refused, also when an owner is called
/// `closed`.
#[test]
fn guards_that_ran_out_refuse_every_font() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("closed");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-closed-ok.shx"), &bytes).unwrap();
shx::set_font_dirs(vec![dir.clone()]);
assert!(shx::find("cadcraft-closed-ok.shx").is_some(), "found while nothing guards the folder");
for n in 0..6000 {
shx::add_drawing_dir_guarded(&dir.join(format!("drawings-{n}")), "closed", Arc::new(|_: &Path| true));
}
assert!(shx::find("cadcraft-closed-ok.shx").is_none(), "refused once the guards ran out");
}
-55
View File
@@ -1,55 +0,0 @@
//! A guarded folder is listed only when its guards allow the folder itself, so a folder outside the
//! automation roots isn't read even for the names in it.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
use cadcraft_fonts::shx;
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder: creating it must not find one already there.
fn fresh_dir() -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-listing-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// Looking for a font that isn't there makes the search list the folder, and the guard is asked
/// about the folder itself first; a guard that refuses it ends the search there.
#[test]
fn the_folder_itself_goes_to_the_guard_before_it_is_listed() {
let owner = fresh_dir();
let dir = owner.0.clone();
let asked: Arc<Mutex<Vec<PathBuf>>> = Arc::default();
let log = asked.clone();
let folder = dir.clone();
shx::add_drawing_dir_guarded(
&dir,
"listing",
Arc::new(move |path: &Path| {
log.lock().unwrap().push(path.to_path_buf());
path != folder
}),
);
assert!(shx::find("cadcraft-listing-missing.shx").is_none());
let seen = asked.lock().unwrap().clone();
assert!(seen.contains(&dir), "the guard was asked about the folder: {seen:?}");
}
-59
View File
@@ -1,59 +0,0 @@
//! Past the number of guarded folders kept, a new folder's guards apply to every folder searched, so
//! no font folder or search path entry is left unguarded.
// Integration tests: unwrapping on failure is fine here, unlike in shipped code (AGENTS.md).
#![allow(clippy::unwrap_used, clippy::expect_used)]
use std::path::Path;
use std::sync::Arc;
use cadcraft_fonts::shx;
const FONT: &str = "*0,4,overflow\n6,2,0,0\n*65,7,UCA\n1,064,040,06C,2,020,0\n";
/// A folder of this test's own, made here so nothing else put it there first, and removed when the
/// test ends, also when it fails.
struct TestDir(std::path::PathBuf);
impl Drop for TestDir {
/// Removes the folder and all it holds.
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
/// A new folder for `tag`: creating it must not find one already there.
fn fresh_dir(tag: &str) -> TestDir {
let mut n = 0u32;
loop {
let dir = std::env::temp_dir().join(format!("cadcraft-shx-{tag}-{}-{n}", std::process::id()));
match std::fs::create_dir(&dir) {
Ok(()) => return TestDir(dir),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => n += 1,
Err(e) => panic!("{}: {e}", dir.display()),
}
}
}
/// With far more guarded folders than are kept, a font folder holding a font the guards refuse still
/// has it refused, and one the guards allow is still found.
#[test]
fn guards_past_the_limit_apply_to_every_folder() {
let bytes = shx::compile(FONT).unwrap();
let owner = fresh_dir("overflow");
let dir = owner.0.clone();
std::fs::write(dir.join("cadcraft-overflow-bad.shx"), &bytes).unwrap();
std::fs::write(dir.join("cadcraft-overflow-ok.shx"), &bytes).unwrap();
for n in 0..1100 {
let folder = dir.join(format!("drawings-{n}"));
shx::add_drawing_dir_guarded(
&folder,
"session",
Arc::new(|file: &Path| !file.file_name().is_some_and(|n| n.to_string_lossy().contains("bad"))),
);
}
// A later folder with the same owner and a guard that allows everything doesn't lift the others.
shx::add_drawing_dir_guarded(&dir.join("last-drawings"), "session", Arc::new(|_: &Path| true));
shx::set_font_dirs(vec![dir.clone()]);
assert!(shx::find("cadcraft-overflow-bad.shx").is_none(), "refused by a guard given past the limit");
assert!(shx::find("cadcraft-overflow-ok.shx").is_some());
}
+4 -4
View File
@@ -9,7 +9,7 @@ use std::sync::Arc;
use cadcraft_doc::{Drawing, EntityKind, EntityStore, Handle, Image};
use cadcraft_geom::{Vec2, Vec3};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Most clip boundary vertices kept per image (hostile files).
const MAX_CLIP: usize = 100_000;
@@ -79,14 +79,14 @@ fn has_images(store: &EntityStore) -> bool {
}
/// Fill in each image's definition (path, name, pixel size) from the IMAGEDEF it points to.
pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
pub(crate) fn resolve(secs: &[Section], d: &mut Drawing) {
if !has_images(&d.model) && !d.layouts.iter().any(|l| has_images(&l.entities)) && !d.blocks.values().any(|b| has_images(&b.entities)) {
return;
}
// IMAGE handle → IMAGEDEF handle.
let mut refs: HashMap<Handle, String> = HashMap::new();
for s in secs.iter().filter(|s| s.name == "ENTITIES" || s.name == "BLOCKS") {
each_record(s.tags, |kind, tags| {
each_record(&s.tags, |kind, tags| {
if kind != "IMAGE" {
return;
}
@@ -101,7 +101,7 @@ pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
let mut defs: HashMap<String, Def> = HashMap::new();
let mut names: HashMap<String, String> = HashMap::new();
for s in secs.iter().filter(|s| s.name == "OBJECTS") {
each_record(s.tags, |kind, tags| match kind {
each_record(&s.tags, |kind, tags| match kind {
"IMAGEDEF" => {
let Some(h) = tags.iter().find(|t| t.code == 5).map(|t| key(&t.str())) else { return };
let start = tags.iter().position(|t| t.code == 100 && t.str() == "AcDbRasterImageDef").unwrap_or(0);
+3 -3
View File
@@ -13,7 +13,7 @@ use cadcraft_doc::{
MLineJust, MLineStyle, MLineVertex, STANDARD_MLINE_STYLE,
};
use cadcraft_geom::{Vec2, Vec3};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Most groups 41 kept per element and vertex (start, then break pairs).
const MAX_PARAMS: usize = 2 * MAX_MLINE_CUTS + 2;
@@ -333,10 +333,10 @@ fn has_mlines(store: &EntityStore) -> bool {
}
/// Read the multiline styles, then give every multiline its style's elements, caps and fill.
pub(crate) fn resolve(secs: &[SectionRef<'_>], d: &mut Drawing) {
pub(crate) fn resolve(secs: &[Section], d: &mut Drawing) {
let mut styles: Vec<MLineStyle> = Vec::new();
for s in secs.iter().filter(|s| s.name == "OBJECTS") {
each_record(s.tags, |kind, tags| {
each_record(&s.tags, |kind, tags| {
if kind == "MLINESTYLE"
&& styles.len() < MAX_STYLES
&& let Some(st) = read_style(tags)
+4 -4
View File
@@ -18,7 +18,7 @@ use std::sync::Arc;
use cadcraft_doc::foreign::{Foreign, ForeignExtra, ForeignKey, ForeignObject, class_group, class_index, class_number};
use cadcraft_doc::{Drawing, Entity, EntityKind, Handle, RawTag, Unknown};
use craft_dxf::{SectionRef, Tag};
use craft_dxf::{Section, Tag};
/// Named object dictionary entries CADCraft writes itself from its model (plus every key that
/// starts with `CADCRAFT`): they are read into the model, not kept raw. A change that starts
@@ -322,8 +322,8 @@ fn put_xdata(d: &mut Drawing, mut xdata: HashMap<Handle, Vec<RawTag>>) {
}
/// Keep what `secs` holds that the reader did not model in `d.foreign`.
pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) {
let get = |name: &str| secs.iter().find(|s| s.name == name).map(|s| split(s.tags)).unwrap_or_default();
pub(crate) fn read(secs: &[Section], d: &mut Drawing) {
let get = |name: &str| secs.iter().find(|s| s.name == name).map(|s| split(&s.tags)).unwrap_or_default();
let (classes, tables, blocks, entities, objects) = (get("CLASSES"), get("TABLES"), get("BLOCKS"), get("ENTITIES"), get("OBJECTS"));
// The drawing's entities by handle: whether each is of a type CADCraft doesn't model.
let ents = entity_types(d);
@@ -465,7 +465,7 @@ pub(crate) fn read(secs: &[SectionRef<'_>], d: &mut Drawing) {
/// The `$ACADVER` the file's own HEADER section declares, if it does. Not the drawing's: a new
/// drawing starts as AC1032, and a file without the variable would leave that default there.
fn file_version(secs: &[SectionRef<'_>]) -> Option<String> {
fn file_version(secs: &[Section]) -> Option<String> {
let header = secs.iter().find(|s| s.name.eq_ignore_ascii_case("HEADER"))?;
let at = header.tags.iter().position(|t| t.code == 9 && t.str().trim().eq_ignore_ascii_case("$ACADVER"))?;
let value = header.tags.get(at + 1).filter(|t| t.code != 9)?.str();
+8 -8
View File
@@ -10,7 +10,7 @@ use cadcraft_doc::{
RayLine, Solid, Table, TableCell, Text, TextStyle, Tolerance, Transparency, Ucs, Unknown, VAlign, Viewport, VportConfig, VportTile, Wipeout,
};
use cadcraft_geom::{PolyVertex, Spline, Vec2, Vec3};
use craft_dxf::{Tag, record_slices, section_slices};
use craft_dxf::{Tag, records, sections};
use crate::{IoError, Result};
@@ -85,7 +85,7 @@ type LayoutDef = (String, u32, String, PageSetup, Option<(Vec2, Vec2)>);
/// Import DXF sections while sharing one materialized-table-cell budget across blocks and entity sections.
fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
let tags = craft_dxf::parse(bytes).map_err(|e| IoError::Format(e.to_string()))?;
let secs = section_slices(&tags);
let secs = sections(&tags);
if secs.is_empty() {
return Err(IoError::Format("no sections found".into()));
}
@@ -112,17 +112,17 @@ fn read_budgeted(bytes: &[u8], mut table_cells_left: usize) -> Result<Drawing> {
let mut skipped = std::collections::BTreeMap::new();
count_skipped(&mut skipped, "(no section)", outside_sections(&tags));
for s in &secs {
match s.name {
"HEADER" => header(s.tags, &mut d),
"TABLES" => tables(s.tags, &mut d, &mut rx),
"BLOCKS" => blocks.extend(read_blocks(s.tags, &mut d, &mut rx, &mut table_cells_left, &mut skipped)),
match s.name.as_str() {
"HEADER" => header(&s.tags, &mut d),
"TABLES" => tables(&s.tags, &mut d, &mut rx),
"BLOCKS" => blocks.extend(read_blocks(&s.tags, &mut d, &mut rx, &mut table_cells_left, &mut skipped)),
// A damaged file may split its entities over several ENTITIES sections (#865).
"ENTITIES" => {
let mut n = 0;
entities.extend(parse_entities(&record_slices(s.tags), &mut d, &mut rx, &mut n, &mut table_cells_left));
entities.extend(parse_entities(&records(&s.tags), &mut d, &mut rx, &mut n, &mut table_cells_left));
count_skipped(&mut skipped, "ENTITIES", n);
}
"OBJECTS" => read_objects(s.tags, &mut objs, &mut layout_objs),
"OBJECTS" => read_objects(&s.tags, &mut objs, &mut layout_objs),
_ => {}
}
}
+5 -5
View File
@@ -1,10 +1,10 @@
use super::common::T;
use super::entities::{entity_extras, entity_plot_style, entity_with_table_budget, insert_attribs, polyline_entity};
use super::objects::{MAX_OBJECTS, Objects, page_setup};
use super::{Block, BlockDef, Drawing, Entity, EntityKind, Handle, HashMap, Layout, LayoutDef, Rx, Tag, Vec2, record_slices};
use super::{Block, BlockDef, Drawing, Entity, EntityKind, Handle, HashMap, Layout, LayoutDef, Rx, Tag, Vec2, records};
pub(super) fn parse_entities(
recs: &[(String, &[Tag])],
recs: &[(String, Vec<Tag>)],
d: &mut Drawing,
rx: &mut Rx,
skipped: &mut usize,
@@ -91,7 +91,7 @@ pub(super) fn read_blocks(
table_cells_left: &mut usize,
skipped: &mut std::collections::BTreeMap<String, usize>,
) -> Vec<BlockDef> {
let recs = record_slices(tags);
let recs = records(tags);
for (k, tg) in &recs {
let t = T(tg);
if k == "BLOCK" && t.i(70).unwrap_or(0) & 4 != 0 {
@@ -133,8 +133,8 @@ pub(super) fn read_blocks(
/// Read the OBJECTS section into `objs`, and each LAYOUT into `layout_objs`.
pub(super) fn read_objects(tags: &[Tag], objs: &mut Objects, layout_objs: &mut Vec<LayoutDef>) {
for (k, tg) in record_slices(tags) {
objs.add(&k, tg);
for (k, tg) in records(tags) {
objs.add(&k, &tg);
if k == "LAYOUT" {
// Fields after the AcDbLayout marker (AcDbPlotSettings also has a code 1).
let start = tg.iter().position(|x| x.code == 100 && x.str() == "AcDbLayout").unwrap_or(0);
+5 -5
View File
@@ -5,7 +5,7 @@ use super::text::{attdef, attrib_modes, attrib_props, mtext_from, multiline_attr
use super::{
Arc, Attrib, Circle, Common, DimKind, Dimension, Ellipse, EntityKind, Face3d, Handle, HashMap, Helix, HelixConstrain, Insert, Leader, Line,
LwPolyline, MAX_FRAME_CHARS, Point, PolyVertex, Polyline3d, RawTag, RayLine, Rx, Solid, Spline, Table, TableCell, Tag, Tolerance, Unknown, Vec2,
Vec3, Viewport, Wipeout, record_slices,
Vec3, Viewport, Wipeout, records,
};
use cadcraft_doc::PolyfaceMesh;
@@ -420,10 +420,10 @@ pub(super) fn acad_table(tags: &[Tag], table_cells_left: &mut usize) -> Table {
/// The plot style names of a file: the entries of the `ACAD_PLOTSTYLENAME` dictionary of the
/// named object dictionary (the first object), by placeholder handle.
pub(super) fn plot_style_names(secs: &[craft_dxf::SectionRef<'_>]) -> HashMap<String, String> {
pub(super) fn plot_style_names(secs: &[craft_dxf::Section]) -> HashMap<String, String> {
let mut out = HashMap::new();
let Some(objects) = secs.iter().find(|s| s.name == "OBJECTS") else { return out };
let recs = record_slices(objects.tags);
let recs = records(&objects.tags);
let entries = |tags: &[Tag]| {
let mut v: Vec<(String, String)> = Vec::new();
let mut name: Option<String> = None;
@@ -543,7 +543,7 @@ pub(super) fn entity_extras(kind: &str, tags: &[Tag], h: Handle, k: &mut EntityK
/// can't be placed are counted in `skipped`.
/// The entity of a POLYLINE, with its mesh faces (advancing `i` past its VERTEX records). `None`
/// for a mesh without faces.
pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -> Option<(Common, EntityKind, Vec<EntityKind>)> {
pub(super) fn polyline_entity(recs: &[(String, Vec<Tag>)], i: &mut usize, t: &T) -> Option<(Common, EntityKind, Vec<EntityKind>)> {
let flags = t.i(70).unwrap_or(0);
let mut pts: Vec<(Vec3, f64, f64, f64)> = Vec::new();
// Polyface face records (VERTEX 70 bit 128 without 64): vertex indices 71–74.
@@ -601,7 +601,7 @@ pub(super) fn polyline_entity(recs: &[(String, &[Tag])], i: &mut usize, t: &T) -
}
/// The ATTRIB records after an INSERT, advancing `i` past them and their SEQEND.
pub(super) fn insert_attribs(recs: &[(String, &[Tag])], i: &mut usize, ins_layer: &str) -> Vec<Attrib> {
pub(super) fn insert_attribs(recs: &[(String, Vec<Tag>)], i: &mut usize, ins_layer: &str) -> Vec<Attrib> {
let mut attribs = Vec::new();
while let Some((k2, t2)) = recs.get(*i) {
if k2 == "ATTRIB" {
+12 -12
View File
@@ -2,7 +2,7 @@ use super::common::T;
use super::objects::MAX_OBJECTS;
use super::{
Color, DashElement, DimStyle, Drawing, HVal, HashMap, Layer, Linetype, Lineweight, NamedView, Rgb, Rx, Tag, TextStyle, Ucs, Vec2, Vec3,
VportConfig, VportTile, record_slices,
VportConfig, VportTile, records,
};
use cadcraft_fonts::windows::windows_font;
@@ -92,7 +92,7 @@ fn style_font(tags: &[Tag], file: String) -> String {
/// Load symbol tables and resolve handle references, indexing layer names for case-insensitive updates.
pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let recs = record_slices(tags);
let recs = records(tags);
// STYLE handle → name, or the shape file of an unnamed shape style (linetype elements).
let ltype_styles: HashMap<String, String> = recs
.iter()
@@ -114,7 +114,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let mut linetype_names: std::collections::HashSet<String> = d.linetypes.iter().map(|l| l.name.to_ascii_lowercase()).collect();
let mut style_index: HashMap<String, usize> = d.text_styles.iter().enumerate().map(|(i, s)| (s.name.to_ascii_lowercase(), i)).collect();
for (kind, tg) in recs {
let t = T(tg);
let t = T(&tg);
match kind.as_str() {
"LAYER" => {
let name = t.s(2).unwrap_or_default();
@@ -141,11 +141,11 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
if let Some(n) = t.s(390).and_then(|h| rx.pstyles.get(&h.trim().to_ascii_uppercase())) {
l.plot_style = n.clone();
}
let alpha = crate::dxf_ext::xdata(tg, crate::dxf_ext::LAYER_TRANSPARENCY_APP).iter().find(|x| x.code == 1071);
let alpha = crate::dxf_ext::xdata(&tg, crate::dxf_ext::LAYER_TRANSPARENCY_APP).iter().find(|x| x.code == 1071);
if let Some(pct) = alpha.and_then(|x| crate::dxf_ext::transparency_from_dxf(x.i64())) {
l.transparency = pct;
}
if let Some(desc) = crate::dxf_ext::xdata(tg, crate::dxf_ext::LAYER_DESCRIPTION_APP).iter().filter(|x| x.code == 1000).nth(1) {
if let Some(desc) = crate::dxf_ext::xdata(&tg, crate::dxf_ext::LAYER_DESCRIPTION_APP).iter().filter(|x| x.code == 1000).nth(1) {
l.description = desc.str();
}
match layer_index.get(&name.to_ascii_lowercase()) {
@@ -166,7 +166,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
continue;
}
linetype_names.insert(name.to_ascii_lowercase());
let pattern = ltype_pattern(tg, &ltype_styles);
let pattern = ltype_pattern(&tg, &ltype_styles);
d.linetypes.push(Linetype { name, description: t.s(3).unwrap_or_default(), pattern });
}
"STYLE" => {
@@ -178,7 +178,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
let gen_flags = t.i(71).unwrap_or(0);
let st = TextStyle {
name: name.clone(),
font: style_font(tg, t.s(3).unwrap_or_default()),
font: style_font(&tg, t.s(3).unwrap_or_default()),
big_font: t.s(4).unwrap_or_default(),
height: t.fd(40, 0.0),
width_factor: t.fd(41, 1.0),
@@ -186,7 +186,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
backwards: gen_flags & 2 != 0,
upside_down: gen_flags & 4 != 0,
vertical: t.i(70).unwrap_or(0) & 4 != 0,
annotative: annotative(tg),
annotative: annotative(&tg),
};
match style_index.get(&name.to_ascii_lowercase()).and_then(|&i| d.text_styles.get_mut(i)) {
Some(x) => *x = st,
@@ -230,7 +230,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
if !(center.x.is_finite() && center.y.is_finite()) {
continue;
}
let x = crate::dxf_ext::xdata(tg, crate::dxf_ext::APP);
let x = crate::dxf_ext::xdata(&tg, crate::dxf_ext::APP);
let field = |key: &str| {
x.iter().position(|t| t.code == 1000 && t.str() == key).and_then(|i| x.get(i + 1)).filter(|t| t.code == 1000).map(Tag::str)
};
@@ -274,8 +274,8 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
fields.insert(field.to_string(), v);
}
}
fields.extend(crate::dxf_ext::read_newer_dimvars(tg, &rx.styles, &rx.brs, &rx.ltypes));
let mut st = DimStyle { name: name.clone(), annotative: annotative(tg), ..DimStyle::default() };
fields.extend(crate::dxf_ext::read_newer_dimvars(&tg, &rx.styles, &rx.brs, &rx.ltypes));
let mut st = DimStyle { name: name.clone(), annotative: annotative(&tg), ..DimStyle::default() };
st.apply_fields(&fields);
match d.dim_styles.iter_mut().find(|s| s.name.eq_ignore_ascii_case(&name)) {
Some(x) => *x = st,
@@ -292,7 +292,7 @@ pub(super) fn tables(tags: &[Tag], d: &mut Drawing, rx: &mut Rx) {
d.vports.retain(|c| c.tiles.len() > usize::from(c.is_active()) || c.tiles.first().is_some_and(|t| t.twist != 0.0));
}
fn index_table_handles(recs: &[(String, &[Tag])], rx: &mut Rx) {
fn index_table_handles(recs: &[(String, Vec<Tag>)], rx: &mut Rx) {
for (kind, tags) in recs {
let table = T(tags);
let (Some(handle), Some(name)) = (table.s(5), table.s(2)) else { continue };
+2 -2
View File
@@ -65,8 +65,8 @@ pub fn census(dxf: &[u8]) -> Option<Census> {
_ => {}
}
};
for s in craft_dxf::section_slices(&tags) {
let records = craft_dxf::record_slices(s.tags);
for s in craft_dxf::sections(&tags) {
let records = craft_dxf::records(&s.tags);
match s.name.trim().to_ascii_uppercase().as_str() {
"ENTITIES" => {
for (t, g) in &records {
+9 -29
View File
@@ -2,11 +2,9 @@
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{Ipv4Addr, SocketAddr, TcpStream, ToSocketAddrs};
use std::sync::Arc;
use std::time::Duration;
use cadcraft_engine::Session;
use cadcraft_engine::file_access::{self, AutomationRoots};
use serde_json::{Value, json};
/// Something that answers control-channel methods (`engine.execute`, `cmdline.input`,
@@ -300,7 +298,6 @@ impl Backend for Remote {
fn has_ui(&self) -> bool {
true
}
/// What this backend talks to, for messages.
fn describe(&self) -> String {
format!("connected to CADCraft at {}", self.addr)
}
@@ -324,19 +321,13 @@ const HEADLESS_METHODS: &[(&str, &str, &str)] = &[
];
/// An in-process headless session (no window).
#[derive(Default)]
pub struct Headless {
pub session: Session,
/// The folders its methods may read and write (`--automation-read-root`,
/// `--automation-write-root`); `None`: anywhere.
roots: Option<Arc<AutomationRoots>>,
}
impl Headless {
/// Confine the files every method reads and writes to `roots` ([`file_access`]).
pub fn with_automation_roots(mut self, roots: Option<Arc<AutomationRoots>>) -> Self {
self.roots = roots;
self
impl Default for Headless {
fn default() -> Self {
Headless { session: Session::new() }
}
}
@@ -355,9 +346,8 @@ fn state(s: &Session) -> Value {
})
}
impl Headless {
/// The reply to one control method; the caller holds it to the roots.
fn answer(&mut self, method: &str, p: &Value) -> Result<Value, String> {
impl Backend for Headless {
fn call(&mut self, method: &str, p: Value) -> Result<Value, String> {
let s = &mut self.session;
let str_p = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
match method {
@@ -417,14 +407,14 @@ impl Headless {
"engine.commands" => {
Ok(Value::Array(cadcraft_engine::command_specs().iter().map(|c| serde_json::to_value(c.info(s)).unwrap_or_default()).collect()))
}
"drawing.inspect" | "document.inspect" => s.execute("drawing.inspect", p).map_err(|e| e.to_string()),
"drawing.inspect" | "document.inspect" => s.execute("drawing.inspect", &p).map_err(|e| e.to_string()),
"ui.render" => {
let w = p.get("width").and_then(Value::as_f64).unwrap_or(1600.0).clamp(16.0, 8192.0) as u32;
let h = p.get("height").and_then(Value::as_f64).unwrap_or(1000.0).clamp(16.0, 8192.0) as u32;
let st = s.state().map_err(|e| e.to_string())?;
let window = render_window(p);
let window = render_window(&p);
// `background` and `plot_style` (#803), read as the app reads them.
let look = cadcraft_engine::render_look::RenderLook::from_params(&st.doc, p)?;
let look = cadcraft_engine::render_look::RenderLook::from_params(&st.doc, &p)?;
let opts = cadcraft_render::Options {
view: window,
transparency: s.settings.transparency_display,
@@ -447,7 +437,6 @@ impl Headless {
let mut r =
json!({"pngBase64": cadcraft_engine::cmd::file::base64_encode(&png), "width": w, "height": h, "truncated": list.truncated});
if let Some(path) = str_p("path") {
file_access::check_write(&path)?;
let file = std::path::Path::new(&path);
let folder = cadcraft_engine::atomic_write::missing_folder(file);
cadcraft_engine::atomic_write::write_atomic_making_folders(file, &png).map_err(|e| format!("{path}: {e}"))?;
@@ -463,7 +452,7 @@ impl Headless {
}
"app.save" => {
let id = if p.get("path").is_some() { "saveas" } else { "qsave" };
s.execute(id, p).map_err(|e| e.to_string())
s.execute(id, &p).map_err(|e| e.to_string())
}
"ui.screenshot" => Err("no UI in headless mode; use render".into()),
"control.methods" => Ok(HEADLESS_METHODS
@@ -474,18 +463,9 @@ impl Headless {
other => Err(format!("unknown method `{other}`; `control.methods` lists them (docs/control-protocol.md)")),
}
}
}
impl Backend for Headless {
/// Run one control method inside the roots, if any.
fn call(&mut self, method: &str, p: Value) -> Result<Value, String> {
let roots = self.roots.clone();
file_access::confine(roots.as_ref(), || self.answer(method, &p))
}
fn has_ui(&self) -> bool {
false
}
/// What this backend talks to, for messages.
fn describe(&self) -> String {
"headless CADCraft session".into()
}
-36
View File
@@ -412,39 +412,3 @@ fn legacy_protocol_routing_and_version_negotiation() {
json!([{"jsonrpc":"2.0","id":[1],"result":{}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"missing `method`"}}])
);
}
/// With a read root and no write root (the read-only use #1931 asks for), an agent still draws,
/// reads and renders, but no route writes a file outside: the save tool, `execute` of the
/// writers, a save hidden mid-line at the command line and one in a script. Carried from #1973's
/// read-only mode tests.
#[test]
fn a_read_root_alone_still_draws_but_writes_nothing() {
let base = std::env::temp_dir().join(format!("cc-mcp-readonly-{}", std::process::id()));
let (inside, outside) = (base.join("in"), base.join("outside"));
std::fs::create_dir_all(&inside).unwrap();
std::fs::create_dir_all(&outside).unwrap();
let roots = cadcraft_engine::file_access::AutomationRoots::new(Some(&inside), None).unwrap();
let mut s = Server::new(Box::new(Headless::default().with_automation_roots(roots)));
let _ = call(&mut s, 1, "initialize", json!({"protocolVersion": "2025-06-18"}));
let _ = s.handle_line(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
tool(&mut s, "command_line", json!({"text": "rectang 0,0 100,60"}));
tool(&mut s, "execute", json!({"command": "circle", "params": {"center": [10, 10], "radius": 4}}));
assert_eq!(tool(&mut s, "inspect_drawing", json!({}))["entityCount"], 2, "drawing edits are allowed");
assert_eq!(tool(&mut s, "render", json!({}))["type"], json!("image"), "a render without `path` writes nothing");
let out = |n: &str| outside.join(n).to_string_lossy().into_owned();
let refused = |s: &mut Server, name: &str, args: Value| {
let r = call(s, 98, "tools/call", json!({"name": name, "arguments": args}));
assert_eq!(r["result"]["isError"], json!(true), "{name} was not refused: {r}");
};
refused(&mut s, "save", json!({"path": out("a.dxf")}));
refused(&mut s, "execute", json!({"command": "saveas", "params": {"path": out("b.dxf")}}));
refused(&mut s, "execute", json!({"command": "wblock", "params": {"path": out("c.dxf")}}));
refused(&mut s, "render", json!({"path": out("d.png")}));
let _ = call(&mut s, 97, "tools/call", json!({"name": "command_line", "arguments": {"text": format!("zoom e save {}", out("e.dxf"))}}));
let _ = call(&mut s, 96, "tools/call", json!({"name": "script", "arguments": {"text": format!("circle 0,0 1\nsave {}\n", out("f.dxf"))}}));
let written: Vec<_> = std::fs::read_dir(&outside).unwrap().filter_map(Result::ok).map(|e| e.file_name()).collect();
assert!(written.is_empty(), "nothing is written outside the roots: {written:?}");
let _ = std::fs::remove_dir_all(&base);
}
+1
View File
@@ -36,6 +36,7 @@ mod selection_cycling;
mod shared_controls;
mod shortcut_menus;
mod shortcuts_checked;
mod space_at_options;
mod status_bar_toggles;
mod style_dialogs;
mod system_cursor;
@@ -0,0 +1,59 @@
//! Space is Enter at TRIM's and EXTEND's option prompts, as at AutoCAD's (#3092): typing `O`,
//! Space, `S`, Space switches to Standard mode instead of typing a space into the command line.
use cadcraft_engine::Session;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Key, Modifiers, vec2};
use egui_kittest::Harness;
fn harness() -> Harness<'static, CadApp> {
let app = CadApp::new(Session::new(), Services::default());
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(3);
h
}
/// Type `text` at the keyboard: a space arrives as the Space key and as text, like a real press.
fn type_keys(h: &mut Harness<'static, CadApp>, text: &str) {
for c in text.chars() {
if c == ' ' {
h.event(egui::Event::Key { key: Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
}
h.event(egui::Event::Text(c.to_string()));
h.run_steps(1);
}
h.run_steps(1);
}
fn header(h: &Harness<'static, CadApp>, name: &str) -> i64 {
h.state().session.doc().unwrap().header.i64(name, -1)
}
fn prompt(h: &Harness<'static, CadApp>) -> String {
h.state().session.current_prompt().map(|p| p.message).unwrap_or_default()
}
#[test]
fn space_answers_trim_and_extend_option_prompts() {
let mut h = harness();
type_keys(&mut h, "trim o s ");
assert_eq!(h.state().cmd.buffer, "", "Space typed a space instead of entering the option");
assert_eq!(header(&h, "TRIMEXTENDMODE"), 0, "S chose Standard mode");
// Standard mode asks for cutting edges; Enter selects all, then Project and Edge.
type_keys(&mut h, " p n e e ");
assert_eq!(h.state().cmd.buffer, "");
assert_eq!(header(&h, "PROJMODE"), 0, "N chose no projection");
assert_eq!(header(&h, "EDGEMODE"), 1, "E chose Extend");
assert!(prompt(&h).starts_with("Select object to trim"), "back at the trim prompt: {}", prompt(&h));
h.key_press(Key::Escape);
h.run_steps(2);
type_keys(&mut h, "extend o q ");
assert_eq!(h.state().cmd.buffer, "");
assert_eq!(header(&h, "TRIMEXTENDMODE"), 1, "Q chose Quick mode in EXTEND");
}
-69
View File
@@ -32,75 +32,6 @@ Example client configuration (Claude Code / Claude Desktop):
{ "mcpServers": { "cadcraft": { "command": "cadcraft-cli", "args": ["mcp"] } } }
```
## Confining file access
```sh
cadcraft-cli mcp --automation-read-root /work/project --automation-write-root /work/project/out
```
The two flags (PhotoCraft, VectorCraft and the other Craft apps take the same ones, so one client
configuration works across the suite) keep the agent to the folders you give it:
- Every file a command **reads** must lie inside the **read root or the write root**: `open`,
`recover`, `compare`, `script`, `import`, `insert`, `xattach` and every xref it loads, `new`
templates, `appload` and LISP `load`/`open`, support files (`linetype`, `hatch.patterns`,
`aliasedit`, `reinit`), data links, plot style and plotter configuration files named by a path,
and the shared plotter settings folder.
- Every file a command **writes** must lie inside the **write root**: `save`/`qsave`/`saveas`
(including the temporary file and `.bak` written beside the destination), `export`, `plot`, `publish`,
`pdfbook`, `wblock`, data extraction, table export, plot style and plotter saves, the shared
plotter settings folder, and `render {path}`. The write root itself is refused: a save's
temporary file would sit beside it, outside the root.
- Give the same folder twice for both. A root left out grants none of its *own* access: a read
root allows no writes, while a write root still allows reads inside it (files the agent wrote it
can read back). Without either flag nothing changes.
- A path is made absolute against the server's working directory, then its links are followed: a
file or folder link that leads out of a root is outside it. For a file that doesn't exist yet,
its nearest existing folder's links are followed and the rest must be plain names, so `..` below
a folder that doesn't exist is refused, as is a link that leads nowhere. The result is compared
with the root by whole folder names, exactly: `/work2/x` is not inside `/work`, and on Windows
a folder's own case comes from the file system, so a case-sensitive folder's `Root` is not
`root`. On Windows a UNC path (`\\server\share`, `\\?\UNC\...`, including `\\host@SSL\...`) is
refused before it is opened unless a root is on that same server and share. A device path
(`\\.\...`) is refused unless a root uses the same device, and a verbatim path that isn't a
disk is refused unless a root uses the same prefix. Device names (`CON`, `NUL`, `COM1`,
`LPT¹`…) are refused too.
- A path you write must also stand under the write root: a link outside it pointing in is refused,
because a drawing's `.bak` goes beside the link and a delete removes the link.
- A refused path in a tool other than `command_line` is an ordinary tool error with `isError: true`
that the agent can read and correct, for example `automation path rejected: outside the write root
/work/project/out: /etc/x.png`, `automation path rejected: outside the read root (or the write
root): /etc/x.png`, `automation path rejected: the write root itself cannot be written:
/work/project/out`, `automation path rejected: UNC paths are refused unless a root is on the
same server and share: \\203.0.113.5\s\x.dwg`, or `automation filesystem access is not granted:
write authority is absent: /work/project/out/x.png`.
- A refused path in a `command_line` line is not a tool error: the reply is an ordinary result, with
the refusal in its `error` field (and echoed in `output`) and without `isError`. A client that
drives `command_line` has to read `error`.
- A file a drawing names is held to the roots too: an image or xref saved with a path outside them is
not loaded from there, and the answer doesn't say whether the file exists. As without roots, a file
of the same name beside the host drawing is tried next, so when one is there and inside the roots
it is loaded in its place: check what a reference loaded when it matters.
- A command runs under the roots only if it is classified (`crates/engine/src/file_access/commands.rs`):
one nobody classified is refused, whatever it does. `drawingrecovery` is refused, and SAVEFILEPATH
can't be changed, because both work on the server's autosave folder.
- SHX fonts beside an opened drawing are searched, and each file the search would open there is
checked against the roots first, whatever its name: a font that is a link leading out of the
roots is skipped, and the rest of the folder is still used.
- The server itself still reads the system's fonts, from the system font folders and
`CADCRAFT_SHXPATH`. Their paths come from the server's setup, never from the agent, but a font file
named by a drawing can decide which of them is read.
- The roots must be existing folders; a missing one stops the server with an error. Each flag is
given once (`--flag <dir>` or `--flag=<dir>`).
The flags confine the headless server. `--connect` with them is an error, since the server would
otherwise talk to an app that isn't confined; the app's control channel does not take them yet
(#1585). Without `--connect` the server writes the files itself, so every check happens here.
A path is checked, then opened: another program on the computer that swaps in a link between the two
can still win that race, and a hard link can't be told from a file. Use the operating system's
sandbox as well if other programs can change these folders.
## Tools
| Tool | What it does |