mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 02:07:09 -06:00
dotCooCoo
5709e636a5
When a document opens with fonts that aren't available, fonts used
only in its symbols included, VectorCraft lists them in a Missing
Fonts dialog after the missing linked file questions, one document at
a time, with Find Fonts and Close. Find Fonts opens Type › Find Font
on the first missing font of the layers' type, to replace it. After
Find Fonts or Close the dialog doesn't open again for that open; when
another dialog replaces it, it opens again once that dialog closes.
Search Fonts Folder (the Fonts folder File › Package writes next to
the document) and Find in Folder… search a folder and its subfolders
for the fonts' files, and Add Fonts copies the files the user chooses
into a Fonts folder next to the preferences. The desktop app and
vectorcraft-cli read that folder with the system's font folders. Type
› Find Font has a Find in Folder… button too when fonts the document
uses are missing. The web app shows no dialog; a status message says
how many fonts aren't available.
- text.missingFonts lists each missing family and style once,
whatever version the document's type names, and leaves out CSS
generic families such as sans-serif. text.findFontFiles searches a
folder on up to 8 threads and returns at once; text.findFontFiles {}
reports the search, and {stop: true} stops it. A search reads only
what the font scan reads of font files (their table directories and
name, fvar and OS/2 tables) and, on macOS, of suitcase fonts, and
lists a file for a font only when the file makes the font resolve
exactly. It does not enter app packages, the Program Files and
ProgramData folders, the system's folders at the root of a volume,
the Shared and Public folders in Users, a home folder's Library,
AppData, Applications, snap and dot folders, a Library folder's app
data folders or the folders the environment names for apps, and it
skips other hidden folders and does not follow links below the
picked folder. It ends after 60 s by default, after 10,000,000
entries listed, with more than 1,000,000 folders waiting, after
10,000 font files read or 1,000 kept, or once every font has a file;
Stop and Close end it too.
- text.addFontFiles copies only files the last search found. Of
those, it copies only regular .ttf, .otf, .ttc, .otc, .woff and
.woff2 files and suitcase fonts with their resource fork, at most
256 MB a file and 1 GB in all. It never replaces a file: a file with
the same contents is kept, and when another file has that name, the
copy gets a number (Name 2.otf). The fonts are then scanned again,
and type set in them redraws.
- ui.missingFontsDialog and ui.findFontsInFolder open the dialog for
agents; docs/control-protocol.md lists its fields.
- File › Package gives a font file whose name has no font extension
the extension that matches its data (.ttf, .otf or .ttc).
- vectorcraft-text adds set_app_font_dir, which system_font_dirs
reads, WantedFonts, which reads a font file's names as the font scan
does, is_font_file and is_suitcase. #762 split its face reader, which
now takes read budgets: file_face_names_within tries the suitcase
reader first, and reader_face_names_within applies the budgets to
each font. vectorcraft-format adds write_new_with.
Docs: docs/mcp.md, docs/control-protocol.md, ROADMAP.
67 lines
3.1 KiB
Rust
67 lines
3.1 KiB
Rust
//! VectorCraft test helpers.
|
||
//!
|
||
//! - [`fixtures`]: sessions and documents in known states (empty, single/multi selection, a "rich"
|
||
//! document touching most node kinds), plus a [`fixtures::DocBuilder`] for building documents
|
||
//! directly (render tests).
|
||
//! - [`strategies`]: proptest strategies for geometry and for engine command sequences ([`strategies::Op`]), and
|
||
//! junk-parameter generators for fuzzing the command registry.
|
||
//! - [`invariants`]: structural checks for documents and sessions, and round-trip checks
|
||
//! (`.vectorcraft`, SVG, `document.inspect`).
|
||
//! - [`raster`]: rendering helpers and image comparison with a perceptual tolerance.
|
||
//! - [`geom`]: geometry assertions (approximate equality, curve sampling, Hausdorff distance).
|
||
//! - [`pdf`]: hand-written PDF files (page boxes, colour spaces, encryption) for import tests.
|
||
//! - [`ai`]: hand-written Illustrator editing data, and the EPS and `.ai` files that carry it.
|
||
//! - [`ase`]: hand-written swatch exchange (`.ase`) files for swatch library tests.
|
||
//! - [`fonts`]: font files made from the bundled fonts (a renamed family) for font tests.
|
||
//!
|
||
//! This crate may only be used as a dev-dependency (enforced by `cargo xtask layers`).
|
||
// Test support only (a dev-dependency of every crate that uses it): a failed setup or assertion
|
||
// must panic, like `assert!`, so the shipped-code ban on panicking (AGENTS.md › Robustness) doesn't
|
||
// apply here.
|
||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||
#![forbid(unsafe_code)]
|
||
|
||
pub mod ai;
|
||
pub mod ase;
|
||
pub mod fixtures;
|
||
pub mod fonts;
|
||
pub mod geom;
|
||
pub mod invariants;
|
||
pub mod pdf;
|
||
pub mod raster;
|
||
pub mod strategies;
|
||
|
||
pub use serde_json::{Value, json};
|
||
pub use vectorcraft_engine::{Session, doc::NodeId};
|
||
/// Re-exports so dependents without direct dependencies (e.g. app test crates) can use them.
|
||
pub use {vectorcraft_doc as doc, vectorcraft_format as format, vectorcraft_render as render, vectorcraft_svg as svg};
|
||
|
||
/// A per-process temporary directory for test output (created on first use).
|
||
pub fn temp_dir(tag: &str) -> std::path::PathBuf {
|
||
let dir = std::env::temp_dir().join(format!("vectorcraft-testkit-{tag}-{}", std::process::id()));
|
||
std::fs::create_dir_all(&dir).expect("create temp dir");
|
||
dir
|
||
}
|
||
|
||
thread_local! {
|
||
static QUIET: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
|
||
}
|
||
|
||
/// Run `f`, catching a panic without printing it (other threads' panics still print). Returns the
|
||
/// panic message on panic.
|
||
pub fn catch_quiet<T>(f: impl FnOnce() -> T) -> Result<T, String> {
|
||
static HOOK: std::sync::Once = std::sync::Once::new();
|
||
HOOK.call_once(|| {
|
||
let prev = std::panic::take_hook();
|
||
std::panic::set_hook(Box::new(move |info| {
|
||
if !QUIET.with(|q| q.get()) {
|
||
prev(info);
|
||
}
|
||
}));
|
||
});
|
||
QUIET.with(|q| q.set(true));
|
||
let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f));
|
||
QUIET.with(|q| q.set(false));
|
||
r.map_err(|p| p.downcast_ref::<String>().cloned().or_else(|| p.downcast_ref::<&str>().map(|s| s.to_string())).unwrap_or_else(|| "panic".into()))
|
||
}
|