88f5a00e389b
export_batch.rs
//! File › Export Layouts and Versions: the document's alternate layouts, one file per layout or
//! all in one, in several versions at once (a press PDF with marks and bleed, a screen PDF, PNG or
//! JPEG images…), each version in a folder of its own, named from a template. A job can be saved
//! as a preset and run again.
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use super::{CommandSpec, bad, cmd, has_doc, ok, str_param};
use crate::{EngineError, Result, Session};
const ID: &str = "file.exportBatch";
/// The most files one export writes.
const MAX_FILES: usize = 5_000;
/// The most versions in a job.
const MAX_VERSIONS: usize = 24;
/// The most pixels in one exported image (the limit EPUB page images have: an RGBA buffer of
/// about 320 MB before encoding).
const MAX_PIXELS: f64 = 8.0e7;
/// The most characters in a file or folder name.
const MAX_NAME: usize = 120;
/// The most bytes an export returns in its reply (no `dir`): past it, export to a folder.
const MAX_INLINE_BYTES: usize = 512 << 20;
/// The most saved export presets, and the longest preset name.
const MAX_PRESETS: usize = 100;
const MAX_PRESET_NAME: usize = 80;
/// What a version is exported as.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ExportFormat {
#[default]
Pdf,
Png,
Jpeg,
}
impl ExportFormat {
pub fn ext(self) -> &'static str {
match self {
ExportFormat::Pdf => "pdf",
ExportFormat::Png => "png",
ExportFormat::Jpeg => "jpg",
}
}
}
/// Printer's marks of a PDF version.
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct VersionMarks {
pub crop: bool,
pub bleed: bool,
pub page_info: bool,
}
/// One output of a job: a format and its settings. Its name is its folder.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ExportVersion {
pub name: String,
pub format: ExportFormat,
/// PDF: the document's bleed.
pub bleed: bool,
/// PDF: printer's marks.
pub marks: VersionMarks,
/// PDF: none | x4 | a2b.
pub standard: String,
/// PDF: spreads rather than pages.
pub spreads: bool,
/// PDF: downsample and compress images.
pub compress_images: bool,
/// PNG / JPEG: pixels per inch.
pub ppi: f64,
/// JPEG: quality, 1–100.
pub quality: u8,
}
impl Default for ExportVersion {
fn default() -> Self {
ExportVersion {
name: "PDF".into(),
format: ExportFormat::Pdf,
bleed: false,
marks: VersionMarks::default(),
standard: "none".into(),
spreads: false,
compress_images: false,
ppi: 150.0,
quality: 85,
}
}
}
/// An export job (and what a preset keeps).
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ExportJob {
/// The layouts to export, by name (empty: all of them).
pub layouts: Vec<String>,
/// PDF versions: all the chosen layouts in one file rather than a file per layout.
pub combine: bool,
/// File name template: {document}, {layout}, {version}, {date}.
pub file_name: String,
pub versions: Vec<ExportVersion>,
/// Each version in a folder of its own (named after it).
pub folders: bool,
}
impl Default for ExportJob {
fn default() -> Self {
ExportJob { layouts: Vec::new(), combine: false, file_name: "{document} - {layout}".into(), versions: vec![], folders: true }
}
}
/// A saved export preset.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ExportPreset {
pub name: String,
pub job: ExportJob,
}
/// The ready-made versions: a press PDF (crop and bleed marks, bleed), a PDF with bleed and no
/// marks, a screen PDF, and PNG and JPEG images.
pub fn version_templates() -> Vec<ExportVersion> {
let pdf = ExportVersion::default();
vec![
ExportVersion {
name: "PDF Print (marks + bleed)".into(),
bleed: true,
marks: VersionMarks { crop: true, bleed: true, page_info: true },
..pdf.clone()
},
ExportVersion { name: "PDF Bleed (no marks)".into(), bleed: true, ..pdf.clone() },
ExportVersion { name: "PDF Screen".into(), compress_images: true, ..pdf.clone() },
ExportVersion { name: "PNG".into(), format: ExportFormat::Png, ..pdf.clone() },
ExportVersion { name: "JPEG".into(), format: ExportFormat::Jpeg, ..pdf },
]
}
/// The built-in presets, listed before the saved ones; they can't be replaced or deleted.
pub fn builtin_presets() -> Vec<ExportPreset> {
let t = version_templates();
let pick = |names: &[&str]| -> Vec<ExportVersion> { t.iter().filter(|v| names.contains(&v.name.as_str())).cloned().collect() };
vec![
ExportPreset {
name: "Print + Screen".into(),
job: ExportJob { versions: pick(&["PDF Print (marks + bleed)", "PDF Screen", "PNG"]), ..ExportJob::default() },
},
ExportPreset {
name: "Press PDF per Layout".into(),
job: ExportJob { versions: pick(&["PDF Print (marks + bleed)", "PDF Bleed (no marks)"]), ..ExportJob::default() },
},
ExportPreset { name: "Images per Layout".into(), job: ExportJob { versions: pick(&["PNG", "JPEG"]), ..ExportJob::default() } },
ExportPreset {
name: "All Layouts in One PDF".into(),
job: ExportJob {
combine: true,
folders: false,
file_name: "{document}".into(),
versions: pick(&["PDF Bleed (no marks)"]),
..ExportJob::default()
},
},
]
}
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(noundo "file.exportBatch", "Export Layouts and Versions…", ["File"], None,
"{job?: {layouts?: [layout names] (default all), combine?: bool (PDF: all the layouts in one file), fileName?: \"{document} - {layout}\" (also {version}, {date}), versions: [{name, format: pdf|png|jpeg, bleed?, marks?: {crop?, bleed?, pageInfo?}, standard?: none|x4|a2b, spreads?, compressImages?, ppi?: 150, quality?: 85}], folders?: bool (default true: a folder per version)}, preset?: name (instead of or under `job`), dir?: folder to write into, dryRun?: bool (list the files only), date?: \"YYYY-MM-DD\" (for {date})} → {files: [{path, version, layout, pages, bytes, base64? (no dir)}], warnings}",
has_doc, export_batch),
cmd!(query "file.exportPresets", "Export Presets", [], None,
"{} → {presets: [{name, job, builtIn}], versions: [the ready-made versions]}", super::always, |s, _| {
let mut presets: Vec<Value> = builtin_presets().into_iter().map(|p| json!({"name": p.name, "job": p.job, "builtIn": true})).collect();
presets.extend(s.prefs.export_presets.iter().map(|p| json!({"name": p.name, "job": p.job, "builtIn": false})));
Ok(json!({"presets": presets, "versions": version_templates()}))
}),
cmd!(noundo "file.saveExportPreset", "Save Export Preset", [], None,
"{name, job} — kept with the preferences; a saved preset of that name is replaced, built-in names are refused", super::always, save_preset),
cmd!(noundo "file.deleteExportPreset", "Delete Export Preset", [], None, "{name} — a saved export preset", super::always, |s, p| {
let name = str_param(p, "name").unwrap_or_default().trim().to_string();
let before = s.prefs.export_presets.len();
s.prefs.export_presets.retain(|x| !x.name.eq_ignore_ascii_case(&name));
if s.prefs.export_presets.len() == before {
return Err(bad("file.deleteExportPreset", format!("no saved export preset `{name}`")));
}
ok()
}),
]
}
fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
const CMD: &str = "file.saveExportPreset";
let name = str_param(p, "name").map(str::trim).filter(|n| !n.is_empty()).ok_or_else(|| bad(CMD, "missing `name`"))?.to_string();
if name.chars().count() > MAX_PRESET_NAME {
return Err(bad(CMD, format!("a preset name has at most {MAX_PRESET_NAME} characters")));
}
if builtin_presets().iter().any(|b| b.name.eq_ignore_ascii_case(&name)) {
return Err(bad(CMD, format!("`{name}` is a built-in preset")));
}
let job = job_param(CMD, p.get("job").ok_or_else(|| bad(CMD, "missing `job`"))?)?;
let presets = &mut s.prefs.export_presets;
presets.retain(|x| !x.name.eq_ignore_ascii_case(&name));
if presets.len() >= MAX_PRESETS {
return Err(bad(CMD, format!("at most {MAX_PRESETS} saved export presets")));
}
presets.push(ExportPreset { name: name.clone(), job });
Ok(json!({"name": name}))
}
/// A job from JSON, checked: versions present and sane, numbers in range.
fn job_param(cmd: &str, v: &Value) -> Result<ExportJob> {
let mut job: ExportJob = serde_json::from_value(v.clone()).map_err(|e| bad(cmd, format!("bad `job`: {e}")))?;
if job.versions.is_empty() {
return Err(bad(cmd, "a job needs at least one version"));
}
if job.versions.len() > MAX_VERSIONS {
return Err(bad(cmd, format!("at most {MAX_VERSIONS} versions")));
}
if job.file_name.chars().count() > 400 {
return Err(bad(cmd, "the file name template is too long"));
}
for v in &mut job.versions {
if !v.ppi.is_finite() {
return Err(bad(cmd, format!("version `{}`: `ppi` is a number", v.name)));
}
v.ppi = v.ppi.clamp(36.0, 1200.0);
v.quality = v.quality.clamp(1, 100);
if designcraft_pdf::Standard::parse(&v.standard).is_none() {
return Err(bad(cmd, format!("version `{}`: unknown standard `{}` (none, x4, a2b)", v.name, v.standard)));
}
}
Ok(job)
}
/// The pages (absolute, 0-based) of each chosen layout, by name; `names` empty: every layout.
pub(crate) fn layout_pages(cmd: &str, d: &designcraft_doc::Document, names: &[String]) -> Result<Vec<(String, Vec<usize>)>> {
let layouts = d.layouts();
if names.is_empty() {
return Ok(layouts.into_iter().map(|l| (l.name, (l.start..l.end).collect())).collect());
}
for n in names {
if !layouts.iter().any(|l| l.name == *n) {
return Err(bad(cmd, format!("no layout `{n}`")));
}
}
// In document order, whatever order they were named in.
Ok(layouts.into_iter().filter(|l| names.contains(&l.name)).map(|l| (l.name, (l.start..l.end).collect())).collect())
}
/// `s` as a file or folder name: no path separators, reserved or control characters, no leading
/// dots, no Windows device name (`CON`, `NUL`… get a leading `_`), at most [`MAX_NAME`]
/// characters; "Untitled" when nothing is left.
pub fn safe_name(s: &str) -> String {
let cleaned: String = s.chars().map(|c| if c.is_control() || r#"/\:*?"<>|"#.contains(c) { ' ' } else { c }).collect();
let words: Vec<&str> = cleaned.split_whitespace().collect();
let joined = words.join(" ");
let trimmed = joined.trim_start_matches('.').trim();
let capped: String = trimmed.chars().take(MAX_NAME).collect();
let capped = capped.trim_end_matches(['.', ' ']).to_string();
if capped.is_empty() {
"Untitled".into()
} else if crate::file_access::is_device_name(&capped) {
format!("_{capped}")
} else {
capped
}
}
/// `name.ext`, or `name 2.ext`, `name 3.ext`… when `taken` has it (case-insensitively).
fn unique(taken: &mut Vec<String>, name: &str, ext: &str) -> String {
let mut k = 1usize;
loop {
let candidate = if k == 1 { format!("{name}.{ext}") } else { format!("{name} {k}.{ext}") };
if !taken.iter().any(|t| t.eq_ignore_ascii_case(&candidate)) {
taken.push(candidate.clone());
return candidate;
}
k = k.saturating_add(1);
}
}
/// Today as YYYY-MM-DD (UTC), where there is a clock (chrono, through `designcraft_doc::time`).
fn today() -> String {
#[cfg(not(target_arch = "wasm32"))]
{
let (y, date) = designcraft_doc::time::date_parts(designcraft_doc::vars::now().div_euclid(86_400));
format!("{y:04}-{}", date.format("%m-%d"))
}
#[cfg(target_arch = "wasm32")]
String::new()
}
/// One file a job writes.
struct Planned {
/// Relative to the export folder: `version folder/name.ext`.
path: String,
version: usize,
layout: String,
/// Absolute, 0-based.
pages: Vec<usize>,
}
/// The files `job` writes, in order: for each version, a PDF per layout (or one for all), or an
/// image per page.
fn plan(s: &Session, job: &ExportJob, date: &str) -> Result<Vec<Planned>> {
let d = &s.doc()?.doc;
let groups = layout_pages(ID, d, &job.layouts)?;
if groups.iter().all(|(_, p)| p.is_empty()) {
return Err(bad(ID, "the chosen layouts have no pages"));
}
let document = if d.title.trim().is_empty() { "Untitled" } else { d.title.as_str() };
let mut out = Vec::new();
let mut folders: Vec<String> = Vec::new();
for (vi, v) in job.versions.iter().enumerate() {
let folder = if job.folders {
let f = safe_name(&v.name);
// Two versions with one name share no folder.
let f = unique(&mut folders, &f, "").trim_end_matches('.').to_string();
format!("{f}/")
} else {
String::new()
};
let mut taken: Vec<String> = out.iter().filter_map(|p: &Planned| p.path.strip_prefix(folder.as_str()).map(str::to_string)).collect();
let name = |layout: &str| {
safe_name(
&job.file_name.replace("{document}", document).replace("{layout}", layout).replace("{version}", &v.name).replace("{date}", date),
)
};
match v.format {
ExportFormat::Pdf if job.combine => {
let pages: Vec<usize> = groups.iter().flat_map(|(_, p)| p.iter().copied()).collect();
let file = unique(&mut taken, &name("All Layouts"), "pdf");
out.push(Planned { path: format!("{folder}{file}"), version: vi, layout: "All Layouts".into(), pages });
}
ExportFormat::Pdf => {
for (layout, pages) in groups.iter().filter(|(_, p)| !p.is_empty()) {
let file = unique(&mut taken, &name(layout), "pdf");
out.push(Planned { path: format!("{folder}{file}"), version: vi, layout: layout.clone(), pages: pages.clone() });
}
}
ExportFormat::Png | ExportFormat::Jpeg => {
for (layout, pages) in &groups {
let base = name(layout);
for &abs in pages {
let stem = safe_name(&format!("{base} - {}", s.page_label(abs)));
let file = unique(&mut taken, &stem, v.format.ext());
out.push(Planned { path: format!("{folder}{file}"), version: vi, layout: layout.clone(), pages: vec![abs] });
}
}
}
}
if out.len() > MAX_FILES {
return Err(bad(ID, format!("the export would write more than {MAX_FILES} files")));
}
}
Ok(out)
}
/// The `file.exportPdf` parameters of a PDF version for `pages` (absolute, 0-based).
fn pdf_params(v: &ExportVersion, pages: &[usize], title: &str) -> Value {
json!({
"pages": pages.iter().map(|p| p.saturating_add(1)).collect::<Vec<_>>(),
"bleed": v.bleed,
"marks": {"crop": v.marks.crop, "bleed": v.marks.bleed, "pageInfo": v.marks.page_info},
"standard": v.standard,
"spreads": v.spreads,
"compressImages": v.compress_images,
"tagged": true,
"title": title,
})
}
/// The bytes of one planned file.
fn render(s: &Session, v: &ExportVersion, f: &Planned) -> Result<(Vec<u8>, Vec<String>)> {
let d = &s.doc()?.doc;
match v.format {
ExportFormat::Pdf => {
let r = super::export::pdf_report(d, &s.cache, &pdf_params(v, &f.pages, &d.title))?;
Ok((r.bytes, r.warnings))
}
ExportFormat::Png | ExportFormat::Jpeg => {
let abs = f.pages.first().copied().ok_or_else(|| bad(ID, "no page"))?;
let page = d.page(abs).ok_or_else(|| bad(ID, format!("no page {}", abs.saturating_add(1))))?;
let scale = v.ppi / 72.0;
if page.width * scale * page.height * scale > MAX_PIXELS {
return Err(bad(ID, format!("page {} at {} ppi is too large for an image; lower the resolution", s.page_label(abs), v.ppi)));
}
let mut r = designcraft_render::Renderer::new();
let opts = designcraft_render::RenderOptions { printing_only: true, rich_black: s.prefs.rich_black_output, ..Default::default() };
let img = r.render_page(d, &s.cache, abs, scale, false, &opts).ok_or_else(|| bad(ID, "the page couldn't be rendered"))?;
Ok((if v.format == ExportFormat::Png { img.to_png() } else { img.to_jpeg(v.quality) }, vec![]))
}
}
}
/// `e` for the file at `path`, saying how many files were written to disk before it (they stay).
fn partly(e: EngineError, path: &str, written: usize, to_disk: bool) -> EngineError {
if to_disk && written > 0 { bad(ID, format!("{path}: {e}; the {written} file(s) before it were written")) } else { e }
}
/// Write `bytes` at `rel` inside `dir`, making the version's folder.
#[cfg(not(target_arch = "wasm32"))]
fn write_into(dir: &str, rel: &str, bytes: &[u8]) -> Result<String> {
let path = std::path::Path::new(dir).join(rel);
if let Some(parent) = path.parent() {
crate::io::create_dir_all(parent).map_err(EngineError::Other)?;
}
let s = path.to_string_lossy().into_owned();
crate::io::write_file(&s, bytes).map_err(EngineError::Other)?;
Ok(s)
}
#[cfg(target_arch = "wasm32")]
fn write_into(_dir: &str, _rel: &str, _bytes: &[u8]) -> Result<String> {
Err(EngineError::Other("no file system on the web; omit `dir` to get the files".into()))
}
fn export_batch(s: &mut Session, p: &Value) -> Result<Value> {
let job = match (p.get("job"), str_param(p, "preset")) {
(Some(j), _) => job_param(ID, j)?,
(None, Some(name)) => {
let preset = builtin_presets()
.into_iter()
.chain(s.prefs.export_presets.iter().cloned())
.find(|x| x.name.eq_ignore_ascii_case(name.trim()))
.ok_or_else(|| bad(ID, format!("no export preset `{name}`")))?;
job_param(ID, &serde_json::to_value(&preset.job).map_err(|e| bad(ID, e.to_string()))?)?
}
(None, None) => return Err(bad(ID, "give a `job` or a `preset`")),
};
let date = match str_param(p, "date") {
Some(d) => safe_name(d),
None => today(),
};
let dir = str_param(p, "dir").map(str::to_string);
let planned = plan(s, &job, &date)?;
let dry = p.get("dryRun").and_then(Value::as_bool).unwrap_or(false);
let mut files = Vec::with_capacity(planned.len());
let mut warnings: Vec<String> = Vec::new();
let mut inline = 0usize;
for f in &planned {
let v = job.versions.get(f.version).ok_or_else(|| bad(ID, "no such version"))?;
let mut entry = json!({
"path": f.path,
"version": v.name,
"layout": f.layout,
"pages": f.pages.iter().map(|p| p.saturating_add(1)).collect::<Vec<_>>(),
});
if !dry {
let (bytes, w) = render(s, v, f).map_err(|e| partly(e, &f.path, files.len(), dir.is_some()))?;
for w in w {
let w = format!("{}: {w}", f.path);
if !warnings.contains(&w) {
warnings.push(w);
}
}
entry["bytes"] = json!(bytes.len());
match &dir {
Some(dir) => entry["path"] = json!(write_into(dir, &f.path, &bytes).map_err(|e| partly(e, &f.path, files.len(), true))?),
None => {
inline = inline.saturating_add(bytes.len());
if inline > MAX_INLINE_BYTES {
return Err(bad(ID, format!("the files come to more than {} MB: give a `dir` to export to", MAX_INLINE_BYTES >> 20)));
}
entry["base64"] = json!(super::base64_encode(&bytes));
}
}
}
files.push(entry);
}
Ok(json!({"files": files, "warnings": warnings}))
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::*;
fn two_layouts() -> Session {
let mut s = Session::new();
s.execute("file.new", &json!({"pages": 2, "facingPages": false, "width": 300, "height": 400, "bleed": 9, "title": "Mag"})).unwrap();
s.execute("frame.create", &json!({"rect": [20, 20, 200, 200]})).unwrap();
s.execute("layout.createAlternate", &json!({"name": "Tablet H", "width": 400, "height": 300, "fromName": "Print"})).unwrap();
s
}
fn job(versions: &[&str]) -> Value {
let t = version_templates();
let v: Vec<_> = versions.iter().map(|n| t.iter().find(|x| x.name == *n).unwrap().clone()).collect();
json!({"versions": v})
}
fn paths(r: &Value) -> Vec<String> {
r["files"].as_array().unwrap().iter().map(|f| f["path"].as_str().unwrap().to_string()).collect()
}
#[test]
fn a_file_per_layout_and_version_in_folders() {
let mut s = two_layouts();
let r = s.execute(ID, &json!({"job": job(&["PDF Print (marks + bleed)", "PNG"]), "dryRun": true})).unwrap();
assert_eq!(
paths(&r),
[
"PDF Print (marks + bleed)/Mag - Print.pdf",
"PDF Print (marks + bleed)/Mag - Tablet H.pdf",
"PNG/Mag - Print - 1.png",
"PNG/Mag - Print - 2.png",
"PNG/Mag - Tablet H - 1.png",
"PNG/Mag - Tablet H - 2.png",
]
);
assert_eq!(r["files"][1]["pages"], json!([3, 4]));
// One layout on its own, all layouts in one PDF, no folders, another name.
let mut one = job(&["PDF Screen"]);
one["layouts"] = json!(["Tablet H"]);
assert_eq!(paths(&s.execute(ID, &json!({"job": one, "dryRun": true})).unwrap()), ["PDF Screen/Mag - Tablet H.pdf"]);
let mut all = job(&["PDF Screen"]);
all["combine"] = json!(true);
all["folders"] = json!(false);
all["fileName"] = json!("{document} {version} {date}");
let r = s.execute(ID, &json!({"job": all, "dryRun": true, "date": "2026-10-20"})).unwrap();
assert_eq!(paths(&r), ["Mag PDF Screen 2026-10-20.pdf"]);
assert_eq!(r["files"][0]["pages"], json!([1, 2, 3, 4]));
}
#[test]
fn the_export_renders_each_file() {
let mut s = two_layouts();
let r = s.execute(ID, &json!({"job": job(&["PDF Print (marks + bleed)", "PDF Bleed (no marks)", "JPEG"])})).unwrap();
let files = r["files"].as_array().unwrap();
assert_eq!(files.len(), 2 + 2 + 4);
let bytes = |i: usize| super::super::file::base64_decode(files[i]["base64"].as_str().unwrap());
for (i, f) in files.iter().enumerate().take(4) {
assert!(bytes(i).starts_with(b"%PDF-"), "{}", f["path"]);
}
assert!(bytes(4).starts_with(&[0xFF, 0xD8]), "a JPEG");
// Marks need room around the bleed: the marked PDF's page is larger.
let size = |b: &[u8]| designcraft_render::pdf_page_size(b, 0).unwrap();
let (marked, bled) = (size(&bytes(0)), size(&bytes(2)));
assert!(marked.0 > bled.0 && marked.1 > bled.1, "{marked:?} {bled:?}");
assert_eq!(designcraft_render::pdf_page_count(&bytes(1)), Some(2));
}
#[test]
fn files_go_into_a_folder_per_version() {
let dir = tempfile::tempdir().unwrap();
let mut s = two_layouts();
let r = s.execute(ID, &json!({"preset": "Print + Screen", "dir": dir.path().to_str().unwrap()})).unwrap();
assert_eq!(r["files"].as_array().unwrap().len(), 2 + 2 + 4);
for f in ["PDF Print (marks + bleed)/Mag - Print.pdf", "PDF Screen/Mag - Tablet H.pdf", "PNG/Mag - Tablet H - 2.png"] {
assert!(dir.path().join(f).is_file(), "{f}");
}
let pdf = std::fs::read(dir.path().join("PDF Screen/Mag - Print.pdf")).unwrap();
assert!(pdf.starts_with(b"%PDF-"));
}
/// An export name drops reserved characters, and a Windows device name (`CON`, `COM¹`, `LPT³`)
/// is written with a leading `_`. Two files built from one name stay distinct.
#[test]
fn names_are_made_safe_and_unique() {
assert_eq!(safe_name("../a/b:c*?"), "a b c");
assert_eq!(safe_name(" ... "), "Untitled");
assert_eq!(safe_name(&"x".repeat(500)).chars().count(), MAX_NAME);
// Windows device names name no file.
for (name, safe) in
[("CON", "_CON"), ("nul", "_nul"), ("com1.x", "_com1.x"), ("COM¹", "_COM¹"), ("lpt³.x", "_lpt³.x"), ("Console", "Console")]
{
assert_eq!(safe_name(name), safe);
}
let mut s = two_layouts();
let mut j = job(&["PNG", "PNG"]);
j["fileName"] = json!("../{document}");
let r = s.execute(ID, &json!({"job": j, "dryRun": true})).unwrap();
let p = paths(&r);
assert!(p.iter().all(|x| !x.contains("..")), "{p:?}");
assert!(p.contains(&"PNG/Mag - 1.png".to_string()) && p.contains(&"PNG/Mag - 1 2.png".to_string()), "{p:?}");
assert!(p.iter().any(|x| x.starts_with("PNG 2/")), "two versions, two folders: {p:?}");
}
#[test]
fn bad_jobs_are_refused() {
let mut s = two_layouts();
for p in [
json!({}),
json!({"job": {"versions": []}}),
json!({"job": {"versions": [{"format": "tiff"}]}}),
json!({"job": {"versions": [{"standard": "x9"}]}}),
json!({"job": {"versions": [{"format": "png"}], "layouts": ["Nope"]}}),
json!({"job": "pdf"}),
json!({"preset": "Nope"}),
] {
assert!(s.execute(ID, &p).is_err(), "{p}");
}
// A huge resolution is capped, not a crash; past 80 million pixels an image is refused.
let mut tall = Session::new();
tall.execute("file.new", &json!({"pages": 1, "width": 3000, "height": 3000})).unwrap();
assert!(tall.execute(ID, &json!({"job": {"versions": [{"format": "png", "ppi": 300}]}})).is_err(), "12500² pixels");
let r = s.execute(ID, &json!({"job": {"versions": [{"format": "png", "ppi": 1e12}], "layouts": ["Print"]}, "dryRun": true})).unwrap();
assert_eq!(r["files"].as_array().unwrap().len(), 2);
let mut big = Session::new();
big.execute("file.new", &json!({"pages": 1, "width": 10000, "height": 10000})).unwrap();
assert!(big.execute(ID, &json!({"job": {"versions": [{"format": "png", "ppi": 1200}]}})).is_err(), "too many pixels");
}
#[test]
fn presets_are_saved_listed_and_deleted() {
let mut s = two_layouts();
let builtin = s.execute("file.exportPresets", &json!({})).unwrap()["presets"].as_array().unwrap().len();
s.execute("file.saveExportPreset", &json!({"name": "Client", "job": job(&["PNG"])})).unwrap();
s.execute("file.saveExportPreset", &json!({"name": "client", "job": job(&["JPEG"])})).unwrap();
let list = s.execute("file.exportPresets", &json!({})).unwrap();
assert_eq!(list["presets"].as_array().unwrap().len(), builtin + 1, "same name replaces");
let r = s.execute(ID, &json!({"preset": "CLIENT", "dryRun": true})).unwrap();
assert!(paths(&r)[0].ends_with(".jpg"));
assert!(s.execute("file.saveExportPreset", &json!({"name": "Print + Screen", "job": job(&["PNG"])})).is_err());
assert!(s.execute("file.saveExportPreset", &json!({"name": "X", "job": {"versions": []}})).is_err());
assert!(s.execute("file.deleteExportPreset", &json!({"name": "Print + Screen"})).is_err());
s.execute("file.deleteExportPreset", &json!({"name": "Client"})).unwrap();
assert!(s.execute(ID, &json!({"preset": "Client", "dryRun": true})).is_err());
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.