mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-21 20:28:51 +00:00
Merge main into feat/distorted-image-commands
This commit is contained in:
@@ -24,6 +24,21 @@ jobs:
|
||||
# Same craft-fonts commit as release.yml.
|
||||
craft-fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
|
||||
timeout-minutes: 90
|
||||
# The gate's test binaries carry no debug info and no symbols (CARGO_PROFILE_TEST_DEBUG=0,
|
||||
# CARGO_PROFILE_TEST_STRIP=symbols), as photocraft's do: linking ~100 test binaries with line
|
||||
# tables ran the hosted runner out of resources, and it stopped mid-link with "received a
|
||||
# shutdown signal" (exit 143). Panics still name file and line; local builds keep Cargo.toml's
|
||||
# line tables.
|
||||
dev-strip: true
|
||||
# The workspace crates also build without line tables. A panic still names its file and line.
|
||||
dev-debug: "0"
|
||||
# Five legs instead of one: shards 1 to 4 each build and run the tests of their own crates,
|
||||
# and shard 5 runs the other `cargo xtask ci` steps (xtask/src/shards.rs). `gate (<os>)`
|
||||
# passes only when all five did. On pushes to main, a `cache warm` leg builds what every
|
||||
# shard builds and saves the dependency cache.
|
||||
test-shards: 5
|
||||
shard-command: cargo xtask ci shard
|
||||
warm-command: cargo xtask ci warm
|
||||
packages: >-
|
||||
pkg-config libxkbcommon-dev libwayland-dev libx11-dev libxcb1-dev libxcursor-dev
|
||||
libxrandr-dev libxi-dev libfontconfig1-dev libfreetype-dev mesa-vulkan-drivers
|
||||
|
||||
Generated
+14
-2
@@ -1048,6 +1048,11 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-eps"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec#cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec"
|
||||
|
||||
[[package]]
|
||||
name = "craft-eps"
|
||||
version = "0.1.0"
|
||||
@@ -1248,10 +1253,15 @@ dependencies = [
|
||||
[[package]]
|
||||
name = "craft-ps"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=d7c9632bfb3040cf45db394e7500cc93c81c49e0#d7c9632bfb3040cf45db394e7500cc93c81c49e0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec#cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec"
|
||||
dependencies = [
|
||||
"craft-eps 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec)",
|
||||
"flate2",
|
||||
"kurbo 0.13.1",
|
||||
"miniz_oxide 0.8.9",
|
||||
"pdf-writer",
|
||||
"skrifa 0.47.0",
|
||||
"weezl 0.1.12",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -6673,6 +6683,7 @@ dependencies = [
|
||||
"craft-image-codecs",
|
||||
"crc32fast",
|
||||
"proptest",
|
||||
"vectorcraft-affinity",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -6866,7 +6877,7 @@ dependencies = [
|
||||
name = "vectorcraft-eps"
|
||||
version = "0.24.1"
|
||||
dependencies = [
|
||||
"craft-eps",
|
||||
"craft-eps 0.1.0 (git+https://github.com/storytold/craft-libs?rev=d7c9632bfb3040cf45db394e7500cc93c81c49e0)",
|
||||
"craft-image-codecs",
|
||||
"craft-pdf",
|
||||
"craft-ps",
|
||||
@@ -7034,6 +7045,7 @@ dependencies = [
|
||||
"vectorcraft-doc",
|
||||
"vectorcraft-effects",
|
||||
"vectorcraft-geom 0.24.1",
|
||||
"vectorcraft-pdf",
|
||||
"vectorcraft-testkit",
|
||||
"vectorcraft-text",
|
||||
]
|
||||
|
||||
+1
-1
@@ -41,7 +41,7 @@ craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb
|
||||
craft-image-codecs = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
craft-gif = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
craft-tiff = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
craft-ps = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0", default-features = false, features = ["write"] }
|
||||
craft-ps = { git = "https://github.com/storytold/craft-libs", rev = "cfcc86242d56fe68117cd5dc2e5dd3b7a0e5b0ec", default-features = false, features = ["read", "write"] }
|
||||
craft-psd = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
craft-stream-codecs = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
craft-jxl = { git = "https://github.com/storytold/craft-libs", rev = "d7c9632bfb3040cf45db394e7500cc93c81c49e0" }
|
||||
|
||||
@@ -21,3 +21,6 @@ proptest = { workspace = true }
|
||||
# The tests build containers and decode previews.
|
||||
crc32fast = { workspace = true }
|
||||
craft-image-codecs = { workspace = true }
|
||||
# tests/it's `import_limits`, `outline_limits` and `text` modules need `synth`, also when this crate
|
||||
# is tested without vectorcraft-engine (`cargo xtask ci shard`).
|
||||
vectorcraft-affinity = { path = ".", features = ["synth"] }
|
||||
|
||||
@@ -3,8 +3,6 @@
|
||||
//! Format Specification, version 7.0, §5.3, §5.4 and §6), and the colors they write in place of
|
||||
//! the paint they can't hold.
|
||||
|
||||
use std::fmt::Write;
|
||||
|
||||
use vectorcraft_color::{Color, Gradient};
|
||||
use vectorcraft_doc::{LAYER_COLORS, LayerColor, LineCap, LineJoin, StrokeLayer};
|
||||
use vectorcraft_geom::{Affine, Anchor, AnchorKind, PathData, Point, Shape, SubPath};
|
||||
@@ -184,25 +182,15 @@ pub(crate) fn window_samples(samples: &[u8], w: u32, channels: usize, [x0, y0, x
|
||||
/// The stroke's width, cap, join, miter limit and dashes: `w J j M d`.
|
||||
pub(crate) fn line_style(s: &mut String, st: &StrokeLayer) {
|
||||
let cap = match st.cap {
|
||||
LineCap::Butt => 0,
|
||||
LineCap::Round => 1,
|
||||
LineCap::Square => 2,
|
||||
LineCap::Butt => ps::LineCap::Butt,
|
||||
LineCap::Round => ps::LineCap::Round,
|
||||
LineCap::Square => ps::LineCap::Square,
|
||||
};
|
||||
let join = match st.join {
|
||||
LineJoin::Miter => 0,
|
||||
LineJoin::Round => 1,
|
||||
LineJoin::Bevel => 2,
|
||||
LineJoin::Miter => ps::LineJoin::Miter,
|
||||
LineJoin::Round => ps::LineJoin::Round,
|
||||
LineJoin::Bevel => ps::LineJoin::Bevel,
|
||||
};
|
||||
ps::push_num(s, st.width);
|
||||
let _ = write!(s, " w {cap} J {join} j ");
|
||||
ps::push_num(s, if st.miter_limit.is_finite() { st.miter_limit.max(1.0) } else { 10.0 });
|
||||
s.push_str(" M [");
|
||||
let dash = st.dash.as_ref().filter(|d| d.is_dashed());
|
||||
if let Some(d) = dash {
|
||||
ps::push_nums(s, &d.pattern);
|
||||
s.pop();
|
||||
}
|
||||
s.push_str("] ");
|
||||
ps::push_num(s, dash.map_or(0.0, |d| d.offset));
|
||||
s.push_str(" d\n");
|
||||
let dash = st.dash.as_ref().filter(|d| d.is_dashed()).map(|d| (d.pattern.as_slice(), d.offset));
|
||||
ps::push_line_style(s, st.width, cap, join, st.miter_limit, dash);
|
||||
}
|
||||
|
||||
+60
-298
@@ -1,253 +1,17 @@
|
||||
//! The scanner: PostScript source into objects (numbers, names, strings, procedures), with the
|
||||
//! position the program's own data (`currentfile`) is read from.
|
||||
//!
|
||||
//! Backed by `craft_ps::read::lex`.
|
||||
|
||||
use std::rc::Rc;
|
||||
|
||||
use craft_ps::read::lex::{LexError, Number, Token};
|
||||
|
||||
use super::obj::{Obj, PsError, Res};
|
||||
use crate::ps;
|
||||
|
||||
/// Deepest procedure nesting the scanner reads.
|
||||
const MAX_NESTING: usize = 256;
|
||||
pub(crate) use craft_ps::read::lex::{IMMEDIATE, hex_decode};
|
||||
|
||||
pub(crate) struct Lexer<'a> {
|
||||
src: &'a [u8],
|
||||
pos: usize,
|
||||
/// The whitespace character that ended the last token is still unread (data the program
|
||||
/// reads from itself starts after it).
|
||||
fresh: bool,
|
||||
/// The last object read has immediately evaluated names (`//name`) in it, read as executable
|
||||
/// names starting with [`IMMEDIATE`] for the interpreter to replace by their values.
|
||||
pub immediate: bool,
|
||||
}
|
||||
|
||||
/// How an immediately evaluated name (`//name`) is read, until the interpreter replaces it.
|
||||
pub(crate) const IMMEDIATE: &str = "//";
|
||||
|
||||
fn is_space(b: u8) -> bool {
|
||||
matches!(b, b' ' | b'\t' | b'\r' | b'\n' | b'\x0c' | b'\0')
|
||||
}
|
||||
|
||||
fn is_delim(b: u8) -> bool {
|
||||
matches!(b, b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%')
|
||||
}
|
||||
|
||||
fn syntax<T>(what: &str) -> Res<T> {
|
||||
Err(PsError::Ps("syntaxerror", what.to_string()))
|
||||
}
|
||||
|
||||
impl<'a> Lexer<'a> {
|
||||
pub fn new(src: &'a [u8]) -> Self {
|
||||
Self { src, pos: 0, fresh: false, immediate: false }
|
||||
}
|
||||
|
||||
/// What is left to read.
|
||||
pub fn rest(&self) -> &'a [u8] {
|
||||
self.src.get(self.pos..).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// What is left to read as data: after the whitespace that ended the last token (a CR LF
|
||||
/// pair counts as one).
|
||||
pub fn data(&mut self) -> &'a [u8] {
|
||||
if std::mem::take(&mut self.fresh) {
|
||||
match self.peek() {
|
||||
Some(b'\r') => {
|
||||
self.pos += 1;
|
||||
if self.peek() == Some(b'\n') {
|
||||
self.pos += 1;
|
||||
}
|
||||
}
|
||||
Some(b) if is_space(b) => self.pos += 1,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
self.rest()
|
||||
}
|
||||
|
||||
/// Skip `n` bytes (the data a filter or `readstring` took).
|
||||
pub fn advance(&mut self, n: usize) {
|
||||
self.fresh = false;
|
||||
self.pos = self.pos.saturating_add(n).min(self.src.len());
|
||||
}
|
||||
|
||||
fn peek(&self) -> Option<u8> {
|
||||
self.src.get(self.pos).copied()
|
||||
}
|
||||
|
||||
fn skip_space(&mut self) {
|
||||
while let Some(b) = self.peek() {
|
||||
if is_space(b) {
|
||||
self.pos += 1;
|
||||
} else if b == b'%' {
|
||||
while let Some(c) = self.peek() {
|
||||
if c == b'\n' || c == b'\r' {
|
||||
break;
|
||||
}
|
||||
self.pos += 1;
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The next object at the top level (`None` at the end of the file).
|
||||
pub fn next(&mut self) -> Res<Option<Obj>> {
|
||||
self.immediate = false;
|
||||
let t = self.token(0);
|
||||
self.fresh = true;
|
||||
t
|
||||
}
|
||||
|
||||
fn token(&mut self, depth: usize) -> Res<Option<Obj>> {
|
||||
self.skip_space();
|
||||
let Some(b) = self.peek() else { return Ok(None) };
|
||||
self.pos += 1;
|
||||
Ok(Some(match b {
|
||||
b'(' => Obj::string(self.string()?),
|
||||
b'<' => match self.peek() {
|
||||
Some(b'<') => {
|
||||
self.pos += 1;
|
||||
Obj::Exec(Rc::from("<<"))
|
||||
}
|
||||
Some(b'~') => {
|
||||
self.pos += 1;
|
||||
Obj::string(self.ascii85()?)
|
||||
}
|
||||
_ => Obj::string(self.hex()?),
|
||||
},
|
||||
b'>' => {
|
||||
if self.peek() != Some(b'>') {
|
||||
return syntax(">");
|
||||
}
|
||||
self.pos += 1;
|
||||
Obj::Exec(Rc::from(">>"))
|
||||
}
|
||||
b'[' => Obj::Exec(Rc::from("[")),
|
||||
b']' => Obj::Exec(Rc::from("]")),
|
||||
b'{' => {
|
||||
if depth >= MAX_NESTING {
|
||||
return Err(PsError::Limit("procedures nested too deeply"));
|
||||
}
|
||||
let mut items = vec![];
|
||||
loop {
|
||||
self.skip_space();
|
||||
match self.peek() {
|
||||
None => return syntax("{"),
|
||||
Some(b'}') => {
|
||||
self.pos += 1;
|
||||
break;
|
||||
}
|
||||
_ => match self.token(depth + 1)? {
|
||||
Some(o) => items.push(o),
|
||||
None => return syntax("{"),
|
||||
},
|
||||
}
|
||||
}
|
||||
Obj::proc(items)
|
||||
}
|
||||
b'}' | b')' => return syntax(&char::from(b).to_string()),
|
||||
b'/' => {
|
||||
// `//name` stands for the name's value when it is read.
|
||||
let immediate = self.peek() == Some(b'/');
|
||||
if immediate {
|
||||
self.pos += 1;
|
||||
self.immediate = true;
|
||||
}
|
||||
let name = self.word();
|
||||
if immediate { Obj::Exec(Rc::from(format!("{IMMEDIATE}{name}").as_str())) } else { Obj::Name(Rc::from(name.as_str())) }
|
||||
}
|
||||
_ => {
|
||||
self.pos -= 1;
|
||||
let w = self.word();
|
||||
number(&w).unwrap_or_else(|| Obj::Exec(Rc::from(w.as_str())))
|
||||
}
|
||||
}))
|
||||
}
|
||||
|
||||
/// A regular token's characters.
|
||||
fn word(&mut self) -> String {
|
||||
let start = self.pos;
|
||||
while let Some(b) = self.peek() {
|
||||
if is_space(b) || is_delim(b) {
|
||||
break;
|
||||
}
|
||||
self.pos += 1;
|
||||
}
|
||||
String::from_utf8_lossy(self.src.get(start..self.pos).unwrap_or_default()).into_owned()
|
||||
}
|
||||
|
||||
/// A literal string after its `(`.
|
||||
fn string(&mut self) -> Res<Vec<u8>> {
|
||||
let mut out = vec![];
|
||||
let mut depth = 0usize;
|
||||
loop {
|
||||
let Some(b) = self.peek() else { return syntax("(") };
|
||||
self.pos += 1;
|
||||
match b {
|
||||
b'(' => {
|
||||
depth += 1;
|
||||
out.push(b);
|
||||
}
|
||||
b')' if depth == 0 => return Ok(out),
|
||||
b')' => {
|
||||
depth -= 1;
|
||||
out.push(b);
|
||||
}
|
||||
b'\\' => {
|
||||
let Some(e) = self.peek() else { return syntax("(") };
|
||||
self.pos += 1;
|
||||
match e {
|
||||
b'n' => out.push(b'\n'),
|
||||
b'r' => out.push(b'\r'),
|
||||
b't' => out.push(b'\t'),
|
||||
b'b' => out.push(8),
|
||||
b'f' => out.push(12),
|
||||
b'\r' => {
|
||||
if self.peek() == Some(b'\n') {
|
||||
self.pos += 1;
|
||||
}
|
||||
}
|
||||
b'\n' => {}
|
||||
b'0'..=b'7' => {
|
||||
let mut v = u32::from(e - b'0');
|
||||
for _ in 0..2 {
|
||||
match self.peek() {
|
||||
Some(d @ b'0'..=b'7') => {
|
||||
v = v * 8 + u32::from(d - b'0');
|
||||
self.pos += 1;
|
||||
}
|
||||
_ => break,
|
||||
}
|
||||
}
|
||||
out.push((v & 0xff) as u8);
|
||||
}
|
||||
other => out.push(other),
|
||||
}
|
||||
}
|
||||
_ => out.push(b),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A hexadecimal string after its `<`.
|
||||
fn hex(&mut self) -> Res<Vec<u8>> {
|
||||
let end = self.rest().iter().position(|b| *b == b'>').ok_or(PsError::Ps("syntaxerror", "<".into()))?;
|
||||
let body = self.rest().get(..end).unwrap_or_default();
|
||||
let out = hex_decode(body).ok_or(PsError::Ps("syntaxerror", "<".into()))?;
|
||||
self.advance(end + 1);
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// An ASCII85 string after its `<~`.
|
||||
fn ascii85(&mut self) -> Res<Vec<u8>> {
|
||||
let end = find(self.rest(), b"~>").ok_or(PsError::Ps("syntaxerror", "<~".into()))?;
|
||||
let text = String::from_utf8_lossy(self.rest().get(..end + 2).unwrap_or_default()).into_owned();
|
||||
self.advance(end + 2);
|
||||
ps::ascii85_decode(&text).ok_or(PsError::Ps("syntaxerror", "<~".into()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Where `needle` first starts in `hay`.
|
||||
/// Where `needle` first starts in `hay` (uses `memmem` so large inputs stay linear-time).
|
||||
pub(crate) fn find(hay: &[u8], needle: &[u8]) -> Option<usize> {
|
||||
if needle.is_empty() {
|
||||
return Some(0);
|
||||
@@ -255,39 +19,66 @@ pub(crate) fn find(hay: &[u8], needle: &[u8]) -> Option<usize> {
|
||||
memchr::memmem::find(hay, needle)
|
||||
}
|
||||
|
||||
/// Hexadecimal digits (whitespace ignored, an odd last digit padded with 0); `None` on others.
|
||||
pub(crate) fn hex_decode(body: &[u8]) -> Option<Vec<u8>> {
|
||||
// Callers pass an already-delimited body. Do not let the filter decoder's EOD
|
||||
// handling silently accept a stray terminator or discard bytes after it.
|
||||
if body.contains(&b'>') {
|
||||
return None;
|
||||
pub(crate) struct Lexer<'a> {
|
||||
inner: craft_ps::read::lex::Lexer<'a>,
|
||||
/// The last object read has immediately evaluated names (`//name`) in it, read as executable
|
||||
/// names starting with [`IMMEDIATE`] for the interpreter to replace by their values.
|
||||
pub immediate: bool,
|
||||
}
|
||||
|
||||
impl<'a> Lexer<'a> {
|
||||
pub fn new(src: &'a [u8]) -> Self {
|
||||
Self { inner: craft_ps::read::lex::Lexer::new(src), immediate: false }
|
||||
}
|
||||
|
||||
/// What is left to read.
|
||||
pub fn rest(&self) -> &'a [u8] {
|
||||
self.inner.rest()
|
||||
}
|
||||
|
||||
/// What is left to read as data: after the whitespace that ended the last token (a CR LF
|
||||
/// pair counts as one).
|
||||
pub fn data(&mut self) -> &'a [u8] {
|
||||
self.inner.data()
|
||||
}
|
||||
|
||||
/// Skip `n` bytes (the data a filter or `readstring` took).
|
||||
pub fn advance(&mut self, n: usize) {
|
||||
self.inner.advance(n);
|
||||
}
|
||||
|
||||
/// The next object at the top level (`None` at the end of the file).
|
||||
pub fn next(&mut self) -> Res<Option<Obj>> {
|
||||
let res = self.inner.next().map(|opt| opt.map(into_obj)).map_err(into_err);
|
||||
self.immediate = self.inner.immediate;
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
fn into_err(err: LexError) -> PsError {
|
||||
match err {
|
||||
LexError::Syntax(what) => PsError::Ps("syntaxerror", what),
|
||||
LexError::Limit(msg) => PsError::Limit(msg),
|
||||
}
|
||||
}
|
||||
|
||||
fn into_obj(tok: Token) -> Obj {
|
||||
match tok {
|
||||
Token::Int(i) => Obj::Int(i),
|
||||
Token::Real(r) => Obj::Real(r),
|
||||
Token::Name(n) => Obj::Name(Rc::from(n.as_str())),
|
||||
Token::Exec(n) => Obj::Exec(Rc::from(n.as_str())),
|
||||
Token::Str(s) => Obj::string(s),
|
||||
Token::Proc(items) => Obj::proc(items.into_iter().map(into_obj).collect()),
|
||||
}
|
||||
craft_stream_codecs::asciihex::decode(body, body.len().div_ceil(2)).ok()
|
||||
}
|
||||
|
||||
/// A number token (`12`, `-3.5`, `.5`, `1e-3`, `16#ff`), or `None`.
|
||||
pub(crate) fn number(w: &str) -> Option<Obj> {
|
||||
let first = w.bytes().next()?;
|
||||
if !(first.is_ascii_digit() || matches!(first, b'+' | b'-' | b'.')) {
|
||||
return None;
|
||||
match craft_ps::read::lex::number(w)? {
|
||||
Number::Int(i) => Some(Obj::Int(i)),
|
||||
Number::Real(r) => Some(Obj::Real(r)),
|
||||
}
|
||||
if let Ok(i) = w.parse::<i64>() {
|
||||
return Some(Obj::Int(i));
|
||||
}
|
||||
if let Some((base, digits)) = w.split_once('#') {
|
||||
let base: u32 = base.parse().ok().filter(|b| (2..=36).contains(b))?;
|
||||
// `from_str_radix` accepts a leading sign; a PostScript radix number has digits only.
|
||||
if digits.starts_with(['+', '-']) {
|
||||
return None;
|
||||
}
|
||||
return i64::from_str_radix(digits, base).ok().map(Obj::Int);
|
||||
}
|
||||
// Rust reads `inf` and `nan`; PostScript doesn't.
|
||||
if w.bytes().any(|b| b.is_ascii_alphabetic() && !matches!(b, b'e' | b'E')) {
|
||||
return None;
|
||||
}
|
||||
let v: f64 = w.parse().ok()?;
|
||||
v.is_finite().then_some(Obj::Real(v))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -300,33 +91,4 @@ mod tests {
|
||||
assert!(number("16#-ff").is_none());
|
||||
assert!(matches!(number("16#ff"), Some(Obj::Int(255))));
|
||||
}
|
||||
#[test]
|
||||
fn shared_hex_decode_keeps_body_boundaries_and_odd_nibbles() {
|
||||
assert_eq!(hex_decode(b" 4\t1\n4\r2\x0c4\0"), Some(vec![0x41, 0x42, 0x40]));
|
||||
assert_eq!(hex_decode(b""), Some(vec![]));
|
||||
for invalid in [b"41>42".as_slice(), b">", b"4g", b"4\x0b1", b"\xff"] {
|
||||
assert_eq!(hex_decode(invalid), None);
|
||||
}
|
||||
// Every byte pairs with each possible nibble, including all whitespace
|
||||
// and invalid-byte combinations; this is the former body-only contract.
|
||||
for first in 0..=255u8 {
|
||||
for second in 0..=255u8 {
|
||||
let input = [first, second];
|
||||
let mut digits = Vec::new();
|
||||
let mut valid = true;
|
||||
for b in input {
|
||||
if is_space(b) {
|
||||
continue;
|
||||
}
|
||||
match char::from(b).to_digit(16) {
|
||||
Some(d) => digits.push(d as u8),
|
||||
None => valid = false,
|
||||
}
|
||||
}
|
||||
let expected =
|
||||
if !valid { None } else { Some(digits.chunks(2).map(|pair| (pair[0] << 4) | pair.get(1).copied().unwrap_or(0)).collect()) };
|
||||
assert_eq!(hex_decode(&input), expected, "{input:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+30
-1
@@ -3,7 +3,10 @@
|
||||
|
||||
use vectorcraft_geom::{BezPath, FillRule};
|
||||
|
||||
pub(crate) use craft_ps::write::{bytes, deflate, inflate, matrix, num, push_num, push_num_places, push_nums, string, written};
|
||||
pub(crate) use craft_ps::write::{
|
||||
LineCap, LineJoin, ShadingKind, bytes, deflate, inflate, matrix, num, push_image_array_ref, push_inline_image, push_line_style, push_num,
|
||||
push_num_places, push_nums, push_reusable_image_ref, push_reusable_image_resource, push_shading, string, written,
|
||||
};
|
||||
|
||||
/// The procedures the page uses, in `VCdict`.
|
||||
pub(crate) const PROLOG: &str = "/VCdict 64 dict def
|
||||
@@ -121,4 +124,30 @@ mod tests {
|
||||
assert_eq!(places(2.5, 7), "2.5");
|
||||
assert_eq!(places(f64::NAN, 7), "0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn shared_scene_syntax_preserves_vc_names_and_shading() {
|
||||
let mut line = String::new();
|
||||
super::push_line_style(&mut line, 3.0, super::LineCap::Square, super::LineJoin::Round, 4.0, Some((&[5.0, 1.5], 0.5)));
|
||||
assert_eq!(line, "3 w 2 J 1 j 4 M [5 1.5] 0.5 d\n");
|
||||
|
||||
let mut shading = String::new();
|
||||
super::push_shading(
|
||||
&mut shading,
|
||||
super::ShadingKind::Axial,
|
||||
"/DeviceCMYK",
|
||||
&[0.0, 0.0, 100.0, 0.0],
|
||||
4,
|
||||
&[(0.0, vec![0.0, 1.0, 1.0, 0.0]), (1.0, vec![1.0, 0.0, 1.0, 0.0])],
|
||||
);
|
||||
assert!(shading.contains("/ShadingType 2 /ColorSpace /DeviceCMYK"));
|
||||
assert!(shading.ends_with(">> shfill\n"));
|
||||
|
||||
let mut inline = String::new();
|
||||
super::push_inline_image(&mut inline, "VCsrc", "", "<< /ImageType 1", "/FlateDecode", "image", "~>\n");
|
||||
assert_eq!(
|
||||
inline,
|
||||
"{ /VCsrc currentfile /ASCII85Decode filter def\n<< /ImageType 1\n/DataSource VCsrc /FlateDecode filter >> image\nVCsrc flushfile } exec\n~>\n"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+12
-63
@@ -50,8 +50,6 @@ const SPREAD_CAPPED: &str =
|
||||
"gradients that repeat or reflect are written with at most 256 runs of their stops (at most 16384 stops); they pad past those";
|
||||
/// Wedges a conic gradient is written as: one a degree.
|
||||
const CONIC_WEDGE_COUNT: usize = 360;
|
||||
/// Decimals of a smooth shading's stitching function bounds (stop offsets, 0 to 1).
|
||||
const BOUNDS_PLACES: u32 = 7;
|
||||
/// The most colorants a DeviceN color space may have (PostScript's limit).
|
||||
const MAX_DEVICE_N: usize = 32;
|
||||
const MISSING_PATTERN: &str = "missing patterns are written as mid-grey";
|
||||
@@ -63,8 +61,6 @@ const MAX_BODY: usize = 256 << 20;
|
||||
/// Most compressed bytes in one string of an image's samples at Level 2 (under PostScript's
|
||||
/// 65,535-byte string limit).
|
||||
const IMAGE_CHUNK: usize = 48 << 10;
|
||||
/// The start of the procedure that reads an image's data from the lines after it.
|
||||
const INLINE_SOURCE: &str = "{ /VCsrc currentfile /ASCII85Decode filter def\n";
|
||||
|
||||
/// An image as written: what sets up its color, its image dictionary and its compressed samples.
|
||||
/// Placed once, it is written where it is drawn, its data following the operators that read it.
|
||||
@@ -108,33 +104,20 @@ impl ImageCode {
|
||||
|
||||
/// The operators and data that draw the image where it is placed.
|
||||
fn push_inline(&self, s: &mut String) {
|
||||
s.push_str(&self.prelude);
|
||||
s.push_str(INLINE_SOURCE);
|
||||
s.push_str(&self.dict);
|
||||
s.push_str(&self.inline_read());
|
||||
s.push_str(&self.ascii);
|
||||
}
|
||||
|
||||
/// The end of the procedure [`ImageCode::push_inline`] writes. The procedure is read whole
|
||||
/// before it runs: the image data follows it, and flushing the ASCII85 filter afterwards reads
|
||||
/// past its end marker.
|
||||
fn inline_read(&self) -> String {
|
||||
format!("\n/DataSource VCsrc {} filter >> {}\nVCsrc flushfile }} exec\n", self.filter, self.op)
|
||||
ps::push_inline_image(s, "VCsrc", &self.prelude, &self.dict, self.filter, self.op, &self.ascii);
|
||||
}
|
||||
|
||||
/// The operators that draw the image `VCim<i>` holds, for an image placed more than once.
|
||||
fn reference(&self, i: usize, level: Level) -> String {
|
||||
let mut s = String::new();
|
||||
let name = format!("VCim{i}");
|
||||
match level {
|
||||
// The stream is read again from its start.
|
||||
Level::Three => {
|
||||
format!("{}VCim{i} resetfile\n{}\n/DataSource VCim{i} {} filter >> {}\n", self.prelude, self.dict, self.filter, self.op)
|
||||
}
|
||||
Level::Three => ps::push_reusable_image_ref(&mut s, &name, &self.prelude, &self.dict, self.filter, self.op),
|
||||
// A procedure gives the strings in turn, then an empty string: the end of the data.
|
||||
Level::Two => format!(
|
||||
"{}/VCi 0 def\n{}\n/DataSource {{VCi VCim{i} length lt {{VCim{i} VCi get /VCi VCi 1 add def}} {{()}} ifelse}} {} filter >> {}\n",
|
||||
self.prelude, self.dict, self.filter, self.op
|
||||
),
|
||||
Level::Two => ps::push_image_array_ref(&mut s, "VCi", &name, &self.prelude, &self.dict, self.filter, self.op),
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// The setup's definition of `VCim<i>`: the image's compressed samples, once.
|
||||
@@ -145,11 +128,7 @@ impl ImageCode {
|
||||
// The stream reads all of its data when it is made, so the data follows the
|
||||
// procedure that makes it.
|
||||
let intent = if self.op == "imagemask" { 1 } else { 0 };
|
||||
let _ = writeln!(
|
||||
s,
|
||||
"{{ /VCsrc currentfile /ASCII85Decode filter def\n/VCim{i} VCsrc << /Intent {intent} /AsyncRead false /CloseSource false >> /ReusableStreamDecode filter def\nVCsrc flushfile }} exec"
|
||||
);
|
||||
s.push_str(&self.ascii);
|
||||
ps::push_reusable_image_resource(&mut s, "VCsrc", &format!("VCim{i}"), intent, &self.ascii);
|
||||
}
|
||||
Level::Two => {
|
||||
let _ = writeln!(s, "/VCim{i} [");
|
||||
@@ -1489,44 +1468,12 @@ impl<'a> Scene<'a> {
|
||||
|
||||
/// A Level 3 smooth shading of `kind` (2 axial, 3 radial) at `coords`, extended both ways.
|
||||
fn shading(&mut self, kind: u8, space: &GradientSpace, coords: &[f64], stops: &[(f64, Vec<f32>)]) {
|
||||
let n = space.n();
|
||||
let comps = |c: &[f32]| -> String {
|
||||
let mut s = String::from("[");
|
||||
push_nums(&mut s, &c.iter().take(n).map(|v| f64::from(*v)).collect::<Vec<_>>());
|
||||
s.pop();
|
||||
s.push(']');
|
||||
s
|
||||
};
|
||||
let segments: Vec<_> = stops.windows(2).filter(|w| w[1].0 > w[0].0).collect();
|
||||
let interp = |w: &&[(f64, Vec<f32>)]| format!("<< /FunctionType 2 /Domain [0 1] /C0 {} /C1 {} /N 1 >>", comps(&w[0].1), comps(&w[1].1));
|
||||
let function = match segments.as_slice() {
|
||||
[one] => interp(one),
|
||||
many => {
|
||||
let mut f = String::from("<< /FunctionType 3 /Domain [0 1] /Functions [\n");
|
||||
for w in many {
|
||||
f.push_str(&interp(w));
|
||||
f.push('\n');
|
||||
}
|
||||
f.push_str("] /Bounds [");
|
||||
// Seven decimals: a gradient's stops repeated hundreds or thousands of times
|
||||
// (`Gradient::padded_over`) keep their places in each run.
|
||||
for w in many.iter().skip(1) {
|
||||
ps::push_num_places(&mut f, w[0].0, BOUNDS_PLACES);
|
||||
f.push(' ');
|
||||
}
|
||||
f.push_str("] /Encode [");
|
||||
f.push_str(&"0 1 ".repeat(many.len()));
|
||||
f.push_str("] >>");
|
||||
f
|
||||
}
|
||||
};
|
||||
let kind = if kind == 3 { ps::ShadingKind::Radial } else { ps::ShadingKind::Axial };
|
||||
let name = match space {
|
||||
GradientSpace::Process(s) => s.name(),
|
||||
GradientSpace::Inks(name, _) => name,
|
||||
};
|
||||
let _ = write!(self.body, "<< /ShadingType {kind} /ColorSpace {name} /Coords [");
|
||||
push_nums(&mut self.body, coords);
|
||||
let _ = writeln!(self.body, "] /Extend [true true]\n/Function {function} >> shfill");
|
||||
ps::push_shading(&mut self.body, kind, name, coords, space.n(), stops);
|
||||
}
|
||||
|
||||
/// The bands of each stretch between stops: how many, for colours `a` to `b` over `length`
|
||||
@@ -2090,7 +2037,9 @@ impl<'a> Scene<'a> {
|
||||
/// `data`, not yet placed.
|
||||
fn image_code(prelude: String, dict: String, filter: &'static str, op: &'static str, data: Vec<u8>) -> ImageCode {
|
||||
let mut code = ImageCode { prelude, dict, filter, op, ascii: ps::ascii85(&data), data, uses: 0, inline_len: 0, ref_len: 0 };
|
||||
code.inline_len = code.prelude.len() + INLINE_SOURCE.len() + code.dict.len() + code.inline_read().len() + code.ascii.len();
|
||||
let mut inline = String::new();
|
||||
ps::push_inline_image(&mut inline, "VCsrc", &code.prelude, &code.dict, code.filter, code.op, "");
|
||||
code.inline_len = inline.len() + code.ascii.len();
|
||||
code
|
||||
}
|
||||
|
||||
|
||||
@@ -56,6 +56,9 @@ serde_json = { workspace = true }
|
||||
krilla = { workspace = true, features = ["simple-text"] }
|
||||
# How many times the symbol list is read to find symbols by name.
|
||||
vectorcraft-doc = { workspace = true, features = ["symbol-read-count"] }
|
||||
# The counters vectorcraft-engine's tests turn on, also when this crate is tested without
|
||||
# vectorcraft-engine (`cargo xtask ci shard`).
|
||||
vectorcraft-pdf = { path = ".", features = ["read-count"] }
|
||||
|
||||
# An independent raster oracle for gradient placement in PDF forms. These are test-only macOS
|
||||
# bindings; the exporter stays portable Rust and does not depend on an OS PDF renderer.
|
||||
|
||||
@@ -764,6 +764,15 @@ fn menu_access_stationary_pointer_repeat_and_rerun_do_not_retarget_or_double_inv
|
||||
assert_eq!(s.app.ui.view.rulers, !before, "one Text/Key pair invokes exactly once across passes");
|
||||
|
||||
s.end_access();
|
||||
// Wait for any background font scan and ensure > 20 families even on minimal runners.
|
||||
let db = vectorcraft_text::FontDb::global();
|
||||
let _ = db.families();
|
||||
for i in 0..24 {
|
||||
if db.menu_family_list_now().len() > 20 {
|
||||
break;
|
||||
}
|
||||
db.add_font(vectorcraft_testkit::fonts::renamed(&format!("Menu Test Font {i:02}")));
|
||||
}
|
||||
let text = s.app.run("text.create", json!({"x": 250, "y": 200, "text": "Menu", "font": "Inter", "size": 12})).unwrap()["id"].clone();
|
||||
s.app.run("select.set", json!({"ids": [text]})).unwrap();
|
||||
let size = vec2(640.0, 420.0);
|
||||
|
||||
+158
-30
@@ -13,6 +13,7 @@ mod layers;
|
||||
mod pdf_deps;
|
||||
mod pngsuite;
|
||||
mod sha256;
|
||||
mod shards;
|
||||
mod stats;
|
||||
mod test262;
|
||||
mod ui_commands;
|
||||
@@ -37,6 +38,11 @@ commands:
|
||||
wasm cargo check --target wasm32-unknown-unknown for the wasm-safe crates and the web app
|
||||
test the workspace tests (cargo nextest when installed, else cargo test), then the doctests
|
||||
ci fmt --check, clippy -D warnings, test, doctests, no-bundled-fonts, pdf-deps, assets, brands, cursors (warnings only), ui-commands --check, layers, wasm (stops at first failure)
|
||||
ci shard shard $GATE_SHARD of $GATE_SHARDS of ci (xtask/src/shards.rs): a test shard runs
|
||||
the tests and doctests of its crates, the last shard the other steps
|
||||
ci warm build what every shard builds, without running it (fills the gate's cache)
|
||||
shards list the crates each shard tests; fails when a member is in no shard or in two,
|
||||
or builds with other features in its shard than in the whole workspace
|
||||
corpus [--download] [--affinity]
|
||||
show where test corpora live; --download fetches PngSuite into corpus/pngsuite,
|
||||
--affinity the pinned public Affinity documents into corpus/affinity
|
||||
@@ -66,7 +72,10 @@ fn main() -> ExitCode {
|
||||
Some("pdf-deps") => pdf_deps::run(&root()),
|
||||
Some("wasm") => cmd_wasm(),
|
||||
Some("test") => cmd_test().and_then(|()| cmd_doctests()),
|
||||
Some("ci") if rest.first() == Some(&"shard") => cmd_ci_shard(),
|
||||
Some("ci") if rest.first() == Some(&"warm") => cmd_ci_warm(),
|
||||
Some("ci") => cmd_ci(),
|
||||
Some("shards") => shards::run().map(drop),
|
||||
Some("corpus") if rest.contains(&"--affinity") => affinity_corpus::fetch(),
|
||||
Some("corpus") => cmd_corpus(rest.contains(&"--download")),
|
||||
Some("bundle") => bundle::run(&root()),
|
||||
@@ -246,30 +255,162 @@ fn has_nextest() -> bool {
|
||||
/// The workspace's unit and integration tests, without examples (clippy still checks those).
|
||||
/// nextest runs each test in its own process, in parallel across all test binaries.
|
||||
fn cmd_test() -> Result<(), String> {
|
||||
test_packages(&["--workspace".to_owned()], "--workspace")
|
||||
}
|
||||
|
||||
/// [`cmd_test`] for the packages `select` picks (`--workspace` or `-p` ids), shown as `shown`.
|
||||
fn test_packages(select: &[String], shown: &str) -> Result<(), String> {
|
||||
const TARGETS: [&str; 3] = ["--lib", "--bins", "--tests"];
|
||||
let mut c = cargo();
|
||||
if has_nextest() {
|
||||
c.args(["nextest", "run", "--workspace"]).args(TARGETS);
|
||||
run(c, "cargo nextest run --workspace --lib --bins --tests")
|
||||
c.args(["nextest", "run"]).args(select).args(TARGETS);
|
||||
run(c, &format!("cargo nextest run {shown} --lib --bins --tests"))
|
||||
} else {
|
||||
eprintln!("note: cargo-nextest is not installed; running cargo test (cargo install cargo-nextest for faster runs)");
|
||||
c.args(["test", "--workspace"]).args(TARGETS);
|
||||
run(c, "cargo test --workspace --lib --bins --tests")
|
||||
c.arg("test").args(select).args(TARGETS);
|
||||
run(c, &format!("cargo test {shown} --lib --bins --tests"))
|
||||
}
|
||||
}
|
||||
|
||||
/// The doctests, which nextest doesn't run.
|
||||
fn cmd_doctests() -> Result<(), String> {
|
||||
let mut c = cargo();
|
||||
c.args(["test", "--workspace", "--doc"]);
|
||||
run(c, "cargo test --workspace --doc")
|
||||
doctest_packages(&["--workspace".to_owned()], "--workspace")
|
||||
}
|
||||
|
||||
/// [`cmd_doctests`] for the packages `select` picks, shown as `shown`.
|
||||
fn doctest_packages(select: &[String], shown: &str) -> Result<(), String> {
|
||||
let mut c = cargo();
|
||||
c.arg("test").args(select).arg("--doc");
|
||||
run(c, &format!("cargo test {shown} --doc"))
|
||||
}
|
||||
|
||||
/// One `cargo xtask ci` step: its name and what it runs.
|
||||
type Step = (&'static str, Box<dyn Fn() -> Result<(), String>>);
|
||||
|
||||
/// The `ci` steps that build and run tests of the whole workspace; `ci shard` runs them per shard.
|
||||
const TEST_STEPS: [&str; 3] = ["test", "doctests", "i18n-report"];
|
||||
|
||||
/// `cargo xtask ci`: each step in turn, stopping at the first that fails; the summary names the
|
||||
/// steps that passed and, after a failure, the one that failed and those skipped.
|
||||
fn cmd_ci() -> Result<(), String> {
|
||||
type Step = (&'static str, Box<dyn Fn() -> Result<(), String>>);
|
||||
let steps: Vec<Step> = vec![
|
||||
run_steps(&ci_steps())
|
||||
}
|
||||
|
||||
/// `cargo xtask ci shard`: shard `GATE_SHARD` of `GATE_SHARDS` (1-based, as the shared gate
|
||||
/// workflow sets them). A test shard runs the shard checks, then the tests and doctests of its
|
||||
/// crates, and the i18n report where it tests vectorcraft-ui-egui. The checks shard runs every
|
||||
/// other `ci` step and the shard checks.
|
||||
fn cmd_ci_shard() -> Result<(), String> {
|
||||
let number = |key: &str| -> Result<usize, String> {
|
||||
let value = std::env::var(key).map_err(|_| format!("ci shard: {key} is not set (the gate workflow sets it)"))?;
|
||||
value.trim().parse().map_err(|_| format!("ci shard: {key} is `{value}`, not a number"))
|
||||
};
|
||||
let (shard, count) = (number("GATE_SHARD")?, number("GATE_SHARDS")?);
|
||||
if count != shards::GROUPS.len() {
|
||||
return Err(format!(
|
||||
"ci shard: GATE_SHARDS is {count}, and xtask/src/shards.rs has {} shards (test-shards in .github/workflows/ci.yml)",
|
||||
shards::GROUPS.len()
|
||||
));
|
||||
}
|
||||
if !(1..=count).contains(&shard) {
|
||||
return Err(format!("ci shard: GATE_SHARD is {shard}, not 1 to {count}"));
|
||||
}
|
||||
let checked = shards::run()?;
|
||||
let mut steps: Vec<Step> = Vec::new();
|
||||
match &checked[shard - 1] {
|
||||
shards::Shard::Tests(crates) => {
|
||||
let names = shards::names(crates);
|
||||
eprintln!("ci shard {shard}/{count}: the tests of {names}");
|
||||
let select = shards::select(crates);
|
||||
let shown = crates.iter().map(|m| format!("-p {}", m.name)).collect::<Vec<_>>().join(" ");
|
||||
let (s, w) = (select.clone(), shown.clone());
|
||||
steps.push(("test", Box::new(move || test_packages(&s, &w))));
|
||||
let (s, w) = (select.clone(), shown.clone());
|
||||
steps.push(("doctests", Box::new(move || doctest_packages(&s, &w))));
|
||||
if crates.iter().any(|m| m.name == "vectorcraft-ui-egui") {
|
||||
steps.push(("i18n-report", Box::new(move || i18n_report_packages(&select, &shown))));
|
||||
}
|
||||
}
|
||||
shards::Shard::Checks => {
|
||||
eprintln!("ci shard {shard}/{count}: the ci steps other than the tests");
|
||||
steps.extend(ci_steps().into_iter().filter(|(name, _)| !TEST_STEPS.contains(name)));
|
||||
}
|
||||
}
|
||||
run_steps(&steps)
|
||||
}
|
||||
|
||||
/// `cargo xtask ci warm`: for each test shard, builds its crates' library and binary tests without
|
||||
/// running them, then builds what the checks shard builds, so one dependency-cache entry holds the
|
||||
/// dependencies of every shard with the features that shard builds them with (cargo resolves
|
||||
/// features over the packages each command selects). The integration tests are left out: they
|
||||
/// build no dependency that the library tests do not, since both take the crate's dev-dependencies.
|
||||
fn cmd_ci_warm() -> Result<(), String> {
|
||||
let checked = shards::run()?;
|
||||
let mut steps: Vec<Step> = Vec::new();
|
||||
for shard in checked {
|
||||
if let shards::Shard::Tests(crates) = shard {
|
||||
steps.push((
|
||||
"build tests",
|
||||
Box::new(move || {
|
||||
let mut c = cargo();
|
||||
c.arg("test").args(shards::select(&crates)).args(["--lib", "--bins", "--no-run"]);
|
||||
run(c, &format!("cargo test --lib --bins --no-run ({})", shards::names(&crates)))
|
||||
}),
|
||||
));
|
||||
}
|
||||
}
|
||||
steps.push((
|
||||
"clippy",
|
||||
Box::new(|| {
|
||||
let mut c = cargo();
|
||||
c.args(["clippy", "--workspace", "--all-targets", "--keep-going"]);
|
||||
run(c, "cargo clippy --workspace --all-targets --keep-going")
|
||||
}),
|
||||
));
|
||||
steps.push((
|
||||
"no-bundled-fonts",
|
||||
Box::new(|| {
|
||||
let mut c = cargo();
|
||||
c.args(["test", "-p", "vectorcraft-text", "--no-default-features", "--test", "without_bundled_fonts", "--no-run"]);
|
||||
run(c, "cargo test -p vectorcraft-text --no-default-features --test without_bundled_fonts --no-run")?;
|
||||
let mut c = cargo();
|
||||
c.args(["clippy", "-p", "vectorcraft-ui-egui", "--no-default-features", "--all-targets"]);
|
||||
run(c, "cargo clippy -p vectorcraft-ui-egui --no-default-features --all-targets")?;
|
||||
let mut c = cargo();
|
||||
c.args(["test", "-p", "vectorcraft-ui-egui", "--no-default-features", "--test", "install_fonts", "--no-run"]);
|
||||
run(c, "cargo test -p vectorcraft-ui-egui --no-default-features --test install_fonts --no-run")
|
||||
}),
|
||||
));
|
||||
steps.push(("wasm", Box::new(cmd_wasm)));
|
||||
run_steps(&steps)
|
||||
}
|
||||
|
||||
/// Runs `steps` in turn, stopping at the first that fails; the summary names the steps that passed
|
||||
/// and, after a failure, the one that failed and those skipped.
|
||||
fn run_steps(steps: &[Step]) -> Result<(), String> {
|
||||
let mut done = Vec::new();
|
||||
for (name, f) in steps {
|
||||
eprintln!("\n=== ci: {name} ===");
|
||||
if let Err(e) = f() {
|
||||
println!("\nCI summary:");
|
||||
for d in &done {
|
||||
println!(" ok {d}");
|
||||
}
|
||||
println!(" FAIL {name}: {e}");
|
||||
for (n, _) in steps.iter().skip(done.len() + 1) {
|
||||
println!(" skip {n}");
|
||||
}
|
||||
return Err(format!("ci failed at `{name}`"));
|
||||
}
|
||||
done.push(*name);
|
||||
}
|
||||
println!("\nCI summary: all {} steps passed ({})", done.len(), done.join(", "));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Every `cargo xtask ci` step, in order.
|
||||
fn ci_steps() -> Vec<Step> {
|
||||
vec![
|
||||
(
|
||||
"fmt",
|
||||
Box::new(|| {
|
||||
@@ -316,25 +457,7 @@ fn cmd_ci() -> Result<(), String> {
|
||||
("ui-commands", Box::new(|| ui_commands::run(&root(), true))),
|
||||
("layers", Box::new(cmd_layers)),
|
||||
("wasm", Box::new(cmd_wasm)),
|
||||
];
|
||||
let mut done = Vec::new();
|
||||
for (name, f) in &steps {
|
||||
eprintln!("\n=== ci: {name} ===");
|
||||
if let Err(e) = f() {
|
||||
println!("\nCI summary:");
|
||||
for d in &done {
|
||||
println!(" ok {d}");
|
||||
}
|
||||
println!(" FAIL {name}: {e}");
|
||||
for (n, _) in steps.iter().skip(done.len() + 1) {
|
||||
println!(" skip {n}");
|
||||
}
|
||||
return Err(format!("ci failed at `{name}`"));
|
||||
}
|
||||
done.push(*name);
|
||||
}
|
||||
println!("\nCI summary: all {} steps passed ({})", done.len(), done.join(", "));
|
||||
Ok(())
|
||||
]
|
||||
}
|
||||
|
||||
fn cmd_corpus(download: bool) -> Result<(), String> {
|
||||
@@ -379,7 +502,12 @@ fn cmd_i18n_report() -> Result<(), String> {
|
||||
/// differently and recompiled for about 3.5 minutes. Every other test binary runs with no test
|
||||
/// matching the filter.
|
||||
fn cmd_ci_i18n_report() -> Result<(), String> {
|
||||
i18n_report_packages(&["--workspace".to_owned()], "--workspace")
|
||||
}
|
||||
|
||||
/// [`cmd_ci_i18n_report`] for the packages `select` picks (a `ci shard`'s), shown as `shown`.
|
||||
fn i18n_report_packages(select: &[String], shown: &str) -> Result<(), String> {
|
||||
let mut c = cargo();
|
||||
c.args(["test", "--workspace", "--lib", "--bins", "--tests", "--", "i18n::tests::untranslated_report", "--exact", "--nocapture"]);
|
||||
run(c, "cargo test --workspace --lib --bins --tests -- i18n::tests::untranslated_report --exact --nocapture")
|
||||
c.arg("test").args(select).args(["--lib", "--bins", "--tests", "--", "i18n::tests::untranslated_report", "--exact", "--nocapture"]);
|
||||
run(c, &format!("cargo test {shown} --lib --bins --tests -- i18n::tests::untranslated_report --exact --nocapture"))
|
||||
}
|
||||
|
||||
@@ -0,0 +1,294 @@
|
||||
//! The gate's shards (`cargo xtask ci shard`, with `GATE_SHARD` of `GATE_SHARDS` set by the shared
|
||||
//! gate workflow): which workspace crates each shard tests, and the checks that keep the split
|
||||
//! complete.
|
||||
//!
|
||||
//! Each test shard builds and runs the tests of its own crates and what they depend on. The last
|
||||
//! shard runs the `cargo xtask ci` steps that are not tests. [`GROUPS`] names the crates of the
|
||||
//! first shards; every other workspace member goes to the [`Group::Rest`] shard, so a new crate is
|
||||
//! tested without a change here. [`check`] fails when a named crate is not a workspace member or
|
||||
//! is named twice, when a group is empty, and when a crate's features in its shard differ from
|
||||
//! its features in `cargo test --workspace`. Cargo resolves features over the packages a command
|
||||
//! selects, so a feature that only another crate's dev-dependencies turn on is off in a shard
|
||||
//! without that crate, and the tests behind it do not build.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
/// What one shard runs.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Group {
|
||||
/// The tests of these workspace crates (package names).
|
||||
Crates(&'static [&'static str]),
|
||||
/// The tests of every workspace member no other group names.
|
||||
Rest,
|
||||
/// The `cargo xtask ci` steps that are not tests.
|
||||
Checks,
|
||||
}
|
||||
|
||||
/// The shards in order; `test-shards` in `.github/workflows/ci.yml` is its length.
|
||||
pub const GROUPS: &[Group] = &[
|
||||
Group::Crates(&["vectorcraft-ui-egui"]),
|
||||
Group::Crates(&["vectorcraft-engine"]),
|
||||
Group::Crates(&["vectorcraft", "vectorcraft-web", "vectorcraft-cli", "vectorcraft-mcp", "xtask"]),
|
||||
Group::Rest,
|
||||
Group::Checks,
|
||||
];
|
||||
|
||||
/// A workspace member, as `cargo metadata` gives it.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct Member {
|
||||
pub name: String,
|
||||
/// The package id, which `-p` takes where the name would be ambiguous: craft-libs builds
|
||||
/// against this repo's geom and pathops by git, so the graph holds a second copy of each.
|
||||
pub id: String,
|
||||
pub version: String,
|
||||
}
|
||||
|
||||
/// What one shard runs, with its crates resolved.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum Shard {
|
||||
Tests(Vec<Member>),
|
||||
Checks,
|
||||
}
|
||||
|
||||
/// The workspace members of `cargo metadata --no-deps` output, in its order.
|
||||
pub fn members(meta: &Value) -> Result<Vec<Member>, String> {
|
||||
let ids: BTreeSet<&str> = meta["workspace_members"].as_array().into_iter().flatten().filter_map(Value::as_str).collect();
|
||||
let members: Vec<Member> = meta["packages"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter(|p| p["id"].as_str().is_some_and(|id| ids.contains(id)))
|
||||
.map(|p| {
|
||||
let field = |key: &str| p[key].as_str().map(str::to_owned).ok_or_else(|| format!("cargo metadata: a workspace package has no `{key}`"));
|
||||
Ok(Member { name: field("name")?, id: field("id")?, version: field("version")? })
|
||||
})
|
||||
.collect::<Result<_, String>>()?;
|
||||
if members.is_empty() {
|
||||
return Err("cargo metadata lists no workspace members".into());
|
||||
}
|
||||
Ok(members)
|
||||
}
|
||||
|
||||
/// Each group of `groups` with its crates: a named crate must be a workspace member and named
|
||||
/// once, there must be exactly one [`Group::Rest`], and no test shard may be empty.
|
||||
pub fn assign(groups: &[Group], members: &[Member]) -> Result<Vec<Shard>, String> {
|
||||
const WHERE: &str = "xtask/src/shards.rs › GROUPS";
|
||||
let mut named: BTreeMap<&str, usize> = BTreeMap::new();
|
||||
for (i, g) in groups.iter().enumerate() {
|
||||
if let Group::Crates(names) = g {
|
||||
if names.is_empty() {
|
||||
return Err(format!("shard {} names no crates ({WHERE})", i + 1));
|
||||
}
|
||||
for name in *names {
|
||||
if !members.iter().any(|m| m.name == *name) {
|
||||
return Err(format!("shard {} names `{name}`, which is not a workspace member ({WHERE})", i + 1));
|
||||
}
|
||||
if let Some(first) = named.insert(name, i) {
|
||||
return Err(format!("`{name}` is in shard {} and shard {} ({WHERE})", first + 1, i + 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let rests = groups.iter().filter(|g| **g == Group::Rest).count();
|
||||
if rests != 1 {
|
||||
return Err(format!("{rests} shards take the remaining crates, not 1 ({WHERE})"));
|
||||
}
|
||||
let pick = |f: &dyn Fn(&Member) -> bool| members.iter().filter(|m| f(m)).cloned().collect::<Vec<_>>();
|
||||
groups
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, g)| match g {
|
||||
Group::Crates(names) => Ok(Shard::Tests(pick(&|m| names.contains(&m.name.as_str())))),
|
||||
Group::Rest => {
|
||||
let rest = pick(&|m| !named.contains_key(m.name.as_str()));
|
||||
if rest.is_empty() {
|
||||
return Err(format!("shard {} takes the remaining crates, and there are none ({WHERE})", i + 1));
|
||||
}
|
||||
Ok(Shard::Tests(rest))
|
||||
}
|
||||
Group::Checks => Ok(Shard::Checks),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The features `cargo tree -e normal,dev,build --prefix none -f '{p}|{f}'` shows for each of
|
||||
/// `members`, by name; a crate the tree holds twice (once for the host, say) has two entries.
|
||||
/// Other copies of a member's name (craft-libs' git copies of geom and pathops) are not members.
|
||||
pub fn tree_features(tree: &str, members: &[Member]) -> BTreeMap<String, BTreeSet<String>> {
|
||||
let mut found: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
|
||||
for line in tree.lines() {
|
||||
let line = line.trim_end();
|
||||
let line = line.strip_suffix(" (*)").unwrap_or(line);
|
||||
let Some((package, features)) = line.split_once('|') else { continue };
|
||||
let Some(m) =
|
||||
members.iter().find(|m| package.strip_prefix(&format!("{} v{} (", m.name, m.version)).is_some_and(|source| !source.contains("://")))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let mut features: Vec<&str> = features.split(',').map(str::trim).filter(|f| !f.is_empty()).collect();
|
||||
features.sort_unstable();
|
||||
found.entry(m.name.clone()).or_default().insert(features.join(","));
|
||||
}
|
||||
found
|
||||
}
|
||||
|
||||
/// One line for each crate of `shard` whose features in `alone` (the shard's tree) differ from
|
||||
/// `workspace` (the whole workspace's tree).
|
||||
pub fn feature_differences(
|
||||
shard: usize,
|
||||
crates: &[Member],
|
||||
workspace: &BTreeMap<String, BTreeSet<String>>,
|
||||
alone: &BTreeMap<String, BTreeSet<String>>,
|
||||
) -> Vec<String> {
|
||||
let show = |set: Option<&BTreeSet<String>>| match set {
|
||||
None => "absent".to_owned(),
|
||||
Some(set) => set.iter().map(|f| format!("[{f}]")).collect::<Vec<_>>().join(" "),
|
||||
};
|
||||
crates
|
||||
.iter()
|
||||
.filter(|m| workspace.get(&m.name) != alone.get(&m.name))
|
||||
.map(|m| {
|
||||
format!("{}: features {} in shard {shard}, {} with the whole workspace", m.name, show(alone.get(&m.name)), show(workspace.get(&m.name)))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `cargo tree` with the features of each package, for `select` (`--workspace` or `-p` ids).
|
||||
fn tree(select: &[String]) -> Result<String, String> {
|
||||
let mut c = crate::cargo();
|
||||
// Without `--color never`, CARGO_TERM_COLOR=always (as the gate sets it) colors the ` (*)` marks.
|
||||
c.args(["tree", "--color", "never", "-e", "normal,dev,build", "--prefix", "none", "-f", "{p}|{f}"]).args(select);
|
||||
let out = c.output().map_err(|e| format!("cargo tree: failed to spawn: {e}"))?;
|
||||
if !out.status.success() {
|
||||
return Err(format!("cargo tree {}: exited with {}:\n{}", select.join(" "), out.status, String::from_utf8_lossy(&out.stderr)));
|
||||
}
|
||||
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
|
||||
}
|
||||
|
||||
/// `-p <id>` for each crate.
|
||||
pub fn select(crates: &[Member]) -> Vec<String> {
|
||||
crates.iter().flat_map(|m| ["-p".to_owned(), m.id.clone()]).collect()
|
||||
}
|
||||
|
||||
/// The package names of `crates`, for messages.
|
||||
pub fn names(crates: &[Member]) -> String {
|
||||
crates.iter().map(|m| m.name.as_str()).collect::<Vec<_>>().join(", ")
|
||||
}
|
||||
|
||||
/// The shards of this workspace, after the checks in [`assign`] and [`feature_differences`].
|
||||
pub fn check() -> Result<Vec<Shard>, String> {
|
||||
let members = members(&crate::metadata()?)?;
|
||||
let shards = assign(GROUPS, &members)?;
|
||||
let workspace = tree_features(&tree(&["--workspace".to_owned()])?, &members);
|
||||
let mut differences = Vec::new();
|
||||
for (i, shard) in shards.iter().enumerate() {
|
||||
if let Shard::Tests(crates) = shard {
|
||||
let alone = tree_features(&tree(&select(crates))?, &members);
|
||||
differences.extend(feature_differences(i + 1, crates, &workspace, &alone));
|
||||
}
|
||||
}
|
||||
if !differences.is_empty() {
|
||||
return Err(format!(
|
||||
"{} crate(s) build with other features in their shard than in `cargo test --workspace`, so some of their tests \
|
||||
would build differently or not at all (turn the feature on in the crate's own dev-dependencies, or move the crate \
|
||||
to the shard of the crate that turns it on):\n {}",
|
||||
differences.len(),
|
||||
differences.join("\n ")
|
||||
));
|
||||
}
|
||||
Ok(shards)
|
||||
}
|
||||
|
||||
/// `cargo xtask shards`: prints each shard's crates after [`check`], and returns the shards.
|
||||
pub fn run() -> Result<Vec<Shard>, String> {
|
||||
let shards = check()?;
|
||||
for (i, shard) in shards.iter().enumerate() {
|
||||
match shard {
|
||||
Shard::Tests(crates) => println!("shard {}/{}: tests of {} crate(s): {}", i + 1, shards.len(), crates.len(), names(crates)),
|
||||
Shard::Checks => println!("shard {}/{}: the other ci steps", i + 1, shards.len()),
|
||||
}
|
||||
}
|
||||
println!("OK: every workspace member is tested on one shard, with the features `cargo test --workspace` gives it.");
|
||||
Ok(shards)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn m(name: &str) -> Member {
|
||||
Member { name: name.into(), id: format!("path+file:///w/{name}#0.1.0"), version: "0.1.0".into() }
|
||||
}
|
||||
|
||||
fn crates(shard: &Shard) -> Vec<&str> {
|
||||
match shard {
|
||||
Shard::Tests(c) => c.iter().map(|m| m.name.as_str()).collect(),
|
||||
Shard::Checks => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_rest_shard_takes_every_crate_no_group_names() {
|
||||
let ws = [m("a"), m("b"), m("c"), m("d")];
|
||||
let shards = assign(&[Group::Crates(&["c"]), Group::Rest, Group::Checks], &ws).unwrap();
|
||||
assert_eq!(shards.iter().map(crates).collect::<Vec<_>>(), [vec!["c"], vec!["a", "b", "d"], vec![]]);
|
||||
assert_eq!(shards[2], Shard::Checks);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_crate_named_twice_or_unknown_fails() {
|
||||
let ws = [m("a"), m("b")];
|
||||
let twice = assign(&[Group::Crates(&["a"]), Group::Crates(&["a"]), Group::Rest], &ws).unwrap_err();
|
||||
assert!(twice.contains("`a` is in shard 1 and shard 2"), "{twice}");
|
||||
let unknown = assign(&[Group::Crates(&["z"]), Group::Rest], &ws).unwrap_err();
|
||||
assert!(unknown.contains("`z`, which is not a workspace member"), "{unknown}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_groups_and_a_missing_or_second_rest_fail() {
|
||||
let ws = [m("a"), m("b")];
|
||||
assert!(assign(&[Group::Crates(&[]), Group::Rest], &ws).unwrap_err().contains("names no crates"));
|
||||
assert!(assign(&[Group::Crates(&["a", "b"]), Group::Rest], &ws).unwrap_err().contains("there are none"));
|
||||
assert!(assign(&[Group::Crates(&["a"])], &ws).unwrap_err().contains("0 shards take the remaining crates"));
|
||||
assert!(assign(&[Group::Rest, Group::Rest], &ws).unwrap_err().contains("2 shards take the remaining crates"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_workspace_member_is_tested_on_exactly_one_shard() {
|
||||
let ws = members(&crate::metadata().unwrap()).unwrap();
|
||||
let shards = assign(GROUPS, &ws).unwrap();
|
||||
let mut tested: Vec<&str> = shards.iter().flat_map(crates).collect();
|
||||
tested.sort_unstable();
|
||||
let mut all: Vec<&str> = ws.iter().map(|m| m.name.as_str()).collect();
|
||||
all.sort_unstable();
|
||||
assert_eq!(tested, all);
|
||||
assert_eq!(shards.iter().filter(|s| **s == Shard::Checks).count(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_feature_only_another_shard_turns_on_is_a_difference() {
|
||||
let ws = [m("lib"), m("geom")];
|
||||
let workspace = "\
|
||||
lib v0.1.0 (/w/lib)|default,synth
|
||||
geom v0.1.0 (/w/geom)|
|
||||
geom v0.18.0 (https://github.com/x/y?rev=1#1)|old
|
||||
lib v0.1.0 (/w/lib)|default,synth (*)
|
||||
";
|
||||
let alone = "\
|
||||
lib v0.1.0 (/w/lib)|default
|
||||
geom v0.1.0 (/w/geom)|
|
||||
";
|
||||
let workspace = tree_features(workspace, &ws);
|
||||
assert_eq!(workspace["lib"], BTreeSet::from(["default,synth".to_owned()]));
|
||||
assert_eq!(workspace["geom"], BTreeSet::from([String::new()]));
|
||||
let alone = tree_features(alone, &ws);
|
||||
assert_eq!(feature_differences(4, &ws, &workspace, &alone), ["lib: features [default] in shard 4, [default,synth] with the whole workspace"]);
|
||||
assert!(feature_differences(4, &ws, &workspace, &workspace).is_empty());
|
||||
assert_eq!(
|
||||
feature_differences(4, &[m("lib")], &workspace, &BTreeMap::new()),
|
||||
["lib: features absent in shard 4, [default,synth] with the whole workspace"]
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user