Files
vectorcraft/crates/engine/src/cmd/variablecmds/library.rs
T
dotCooCoo c6e65c3968 Variables: SVG variable data reads only the text values of its library
An SVG keeps only its text variables, so the values of its visibility, image and graph variables are passed over unread, and one that Load Variable Library would refuse no longer keeps the text variables from opening.
2026-11-14 14:10:15 -08:00

985 lines
50 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use std::collections::HashMap;
use std::fmt::Write as _;
use vectorcraft_doc::{GraphSpec, MAX_GRAPH_CATEGORIES, MAX_GRAPH_SERIES};
use super::{
BTreeMap, BTreeSet, DataSet, DataValue, Document, EngineError, MAX_GRAPH_CSV, MAX_NAME, NodeId, NodeKind, Result, Session, Value, Variable,
VariableKind, Variables, absolute_path, bad, json, named, read_file_head, str_param, variables_unlocked, write_file,
};
/// The namespace of a variable library's elements, the default namespace of its data sets' values,
/// and the `category` of its visibility and image variables.
const NS_VARIABLES: &str = "http://ns.adobe.com/Variables/1.0/"; // brand-ok: the namespace variable libraries use
const NS_CUSTOM: &str = "http://ns.adobe.com/GenericCustomNamespace/1.0/"; // brand-ok: the namespace variable libraries use
/// The `category` of a library's text variables.
const NS_FLOWS: &str = "http://ns.adobe.com/Flows/1.0/"; // brand-ok: the namespace variable libraries use
/// The `category` of a library's graph variables.
const NS_GRAPHS: &str = "http://ns.adobe.com/Graphs/1.0/"; // brand-ok: the namespace variable libraries use
/// The white space XML puts round a value: a value's text is read without it at either end.
const XML_SPACE: [char; 4] = [' ', '\t', '\n', '\r'];
/// Caps on a variable library (paths and MCP payloads are untrusted): its size, its XML nodes, how
/// deep its elements nest, and the entities, variables and data sets it declares.
const MAX_LIBRARY_BYTES: usize = 8 << 20;
const MAX_LIBRARY_ENTITIES: usize = 64;
const MAX_LIBRARY_NODES: u32 = 2_000_000;
const MAX_LIBRARY_NESTING: usize = 256;
const MAX_LIBRARY_VARIABLES: usize = 256;
const MAX_LIBRARY_DATASETS: usize = 1_000;
/// Bytes of a variable library from `path`, `xml` or `dataBase64`.
fn library_bytes(p: &Value, cmd: &str) -> Result<Vec<u8>> {
let bytes = match (str_param(p, "path"), str_param(p, "xml"), str_param(p, "dataBase64")) {
// One byte past the cap is enough to refuse the file below.
(Some(path), ..) => read_file_head(&absolute_path(path), MAX_LIBRARY_BYTES + 1)?,
(None, Some(xml), _) => xml.as_bytes().to_vec(),
(None, None, Some(b64)) => vectorcraft_format::base64_decode(b64).ok_or_else(|| bad(cmd, "bad dataBase64"))?,
_ => return Err(bad(cmd, "give `path`, `xml` or `dataBase64`")),
};
if bytes.len() > MAX_LIBRARY_BYTES {
return Err(bad(cmd, format!("the variable library is larger than {MAX_LIBRARY_BYTES} bytes")));
}
Ok(bytes)
}
/// `xml` without the document type declaration of its prolog, with each reference to a general
/// entity that the declaration defines replaced by the entity's value, its quotes and `>` escaped,
/// outside CDATA sections, comments and processing instructions. The declaration may hold an
/// external identifier and an internal subset of white space, comments, processing instructions and
/// up to [`MAX_LIBRARY_ENTITIES`] entity declarations, each with a name of at most [`MAX_NAME`]
/// bytes and a quoted value that holds no `<`, `&` or `%`. Anything else in it is refused, and so is
/// a text that the replacements make longer than [`MAX_LIBRARY_BYTES`]. The XML parser then refuses
/// any other document type declaration, so [`nesting`](super::place::docx::nesting) counts the
/// elements the parser reads.
fn without_doctype(xml: &str, cmd: &str) -> Result<String> {
let b = xml.as_bytes();
let past = |from: usize, end: &str| xml.get(from..).and_then(|rest| rest.find(end)).map(|at| from + at + end.len());
let spaces = |from: usize| from + b.get(from..).map_or(0, |rest| rest.iter().take_while(|c| c.is_ascii_whitespace()).count());
let at = |i: usize, s: &str| xml.get(i..).is_some_and(|rest| rest.starts_with(s));
let refused = || bad(cmd, "the variable library's document type declaration holds something other than entities of plain text");
// The prolog: an XML declaration, white space, comments and processing instructions.
let mut i = 0;
loop {
i = spaces(i);
if at(i, "<?") {
i = past(i + 2, "?>").ok_or_else(refused)?;
} else if at(i, "<!--") {
i = past(i + 4, "-->").ok_or_else(refused)?;
} else {
break;
}
}
if !at(i, "<!DOCTYPE") {
return Ok(xml.to_string());
}
let start = i;
// A quoted literal starting at `i` → the index past it and its text.
let literal = |i: usize| -> Option<(usize, &str)> {
let quote = *b.get(i).filter(|c| matches!(c, b'"' | b'\''))?;
let len = b.get(i + 1..)?.iter().position(|c| *c == quote)?;
Some((i + len + 2, xml.get(i + 1..i + 1 + len)?))
};
// `<!DOCTYPE` S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>'
i = spaces(i + "<!DOCTYPE".len());
i += b.get(i..).map_or(0, |rest| rest.iter().take_while(|c| !c.is_ascii_whitespace() && !matches!(c, b'[' | b'>')).count());
i = spaces(i);
for (id, literals) in [("SYSTEM", 1), ("PUBLIC", 2)] {
if at(i, id) {
i += id.len();
for _ in 0..literals {
i = literal(spaces(i)).ok_or_else(refused)?.0;
}
i = spaces(i);
}
}
let mut entities: Vec<(&str, String)> = Vec::new();
if at(i, "[") {
i += 1;
loop {
i = spaces(i);
if at(i, "]") {
i = spaces(i + 1);
break;
} else if at(i, "<!--") {
i = past(i + 4, "-->").ok_or_else(refused)?;
} else if at(i, "<?") {
i = past(i + 2, "?>").ok_or_else(refused)?;
} else if at(i, "<!ENTITY") {
i = spaces(i + "<!ENTITY".len());
let len =
b.get(i..).map_or(0, |rest| rest.iter().take_while(|c| !c.is_ascii_whitespace() && !matches!(c, b'"' | b'\'' | b'>')).count());
let name = xml.get(i..i + len).filter(|n| !n.is_empty() && n.len() <= MAX_NAME && !n.starts_with('%')).ok_or_else(refused)?;
let (end, value) = literal(spaces(i + len)).ok_or_else(refused)?;
if value.contains(['<', '&', '%']) {
return Err(refused());
}
i = spaces(end);
if !at(i, ">") {
return Err(refused());
}
i += 1;
if entities.len() == MAX_LIBRARY_ENTITIES {
return Err(bad(cmd, format!("the variable library declares more than {MAX_LIBRARY_ENTITIES} entities")));
}
entities.push((name, value.replace('"', "&quot;").replace('\'', "&apos;").replace('>', "&gt;")));
} else {
return Err(refused());
}
}
}
if !at(i, ">") {
return Err(refused());
}
let mut out = String::with_capacity(xml.len());
out.push_str(xml.get(..start).unwrap_or_default());
// The rest, copied with the references replaced outside CDATA sections, comments and
// processing instructions, where the parser reads none.
let mut i = i + 1;
while let Some(c) = xml.get(i..).and_then(|rest| rest.chars().next()) {
let verbatim = [("<![CDATA[", "]]>"), ("<!--", "-->"), ("<?", "?>")].into_iter().find(|(open, _)| at(i, open));
if let Some((open, close)) = verbatim {
let end = past(i + open.len(), close).unwrap_or(xml.len());
out.push_str(xml.get(i..end).unwrap_or_default());
i = end;
continue;
}
// Entity names are at most `MAX_NAME` bytes long, so the `;` is looked for that far.
let entity = if c == '&' {
let name = xml.get(i + 1..).and_then(|rest| rest.get(..rest.bytes().take(MAX_NAME + 1).position(|b| b == b';')?));
name.and_then(|name| entities.iter().find(|(n, _)| *n == name))
} else {
None
};
match entity {
Some((name, value)) => {
out.push_str(value);
i += name.len() + 2;
if out.len() > MAX_LIBRARY_BYTES {
return Err(bad(cmd, format!("the variable library's entities expand to more than {MAX_LIBRARY_BYTES} bytes")));
}
}
None => {
out.push(c);
i += c.len_utf8();
}
}
}
if out.len() > MAX_LIBRARY_BYTES {
return Err(bad(cmd, format!("the variable library's entities expand to more than {MAX_LIBRARY_BYTES} bytes")));
}
Ok(out)
}
/// One variable a library declares: its name, its kind, and its `trait` as the library spells it
/// (`None` when it has none).
struct LibraryVariable {
name: String,
kind: VariableKind,
trait_name: Option<String>,
}
/// A variable library as Load Variable Library reads it: its variables in the order it declares
/// them, its data sets with their values, and the element id each text variable's `docRef` names.
pub(crate) struct Library {
variables: Vec<LibraryVariable>,
datasets: Vec<DataSet>,
refs: Vec<(String, String)>,
}
/// The kind of a library variable whose `trait` is `t`: `textcontent` is text, `visibility` is
/// visibility, `fileref` (a linked file) is image and `graphdata` is graph. A variable without a
/// `trait`, or with one VectorCraft doesn't know, is of unknown kind.
fn trait_kind(t: Option<&str>) -> VariableKind {
match t {
Some("textcontent") => VariableKind::Text,
Some("visibility") => VariableKind::Visibility,
Some("fileref") => VariableKind::Image,
Some("graphdata") => VariableKind::Graph,
_ => VariableKind::Unknown,
}
}
/// The `trait` and the `category` reference a library declares a variable of `kind` with, or `None`
/// for a variable of unknown kind, which is declared with neither.
fn kind_trait(kind: VariableKind) -> Option<(&'static str, &'static str)> {
match kind {
VariableKind::Text => Some(("textcontent", "&ns_flows;")),
VariableKind::Visibility => Some(("visibility", "&ns_vars;")),
VariableKind::Image => Some(("fileref", "&ns_vars;")),
VariableKind::Graph => Some(("graphdata", "&ns_graphs;")),
VariableKind::Unknown => None,
}
}
impl Library {
/// The element ids the text variables' `docRef`s name.
pub(crate) fn elements(&self) -> std::collections::HashSet<String> {
self.refs.iter().map(|(_, e)| e.clone()).collect()
}
}
/// Read a variable library: XML whose `variableSets` element holds `variableSet` elements, each
/// with a `variables` element of `variable` elements (`varName`, `trait`) and a `sampleDataSets`
/// element of `sampleDataSet` elements (`dataSetName`). Elements are matched by their local names.
/// A variable's kind comes from its `trait` ([`trait_kind`]). In a data set, an element named after
/// a variable gives its value, as [`library_value`] reads it. A variable or data set declared
/// twice, a value for a variable the library doesn't declare, a value that doesn't fit its
/// variable's kind, and a library past the caps are refused. With `text_only`, only text values
/// are read, and the values of the other kinds are passed over unread. Entities that its document
/// type declaration defines are read as [`without_doctype`] says.
fn parse_library(xml: &str, cmd: &str, text_only: bool) -> Result<Library> {
let xml = without_doctype(xml, cmd)?;
// roxmltree parses nested elements recursively.
if crate::cmd::place::docx::nesting(&xml) > MAX_LIBRARY_NESTING {
return Err(bad(cmd, format!("the variable library nests elements more than {MAX_LIBRARY_NESTING} deep")));
}
let opts = roxmltree::ParsingOptions { nodes_limit: MAX_LIBRARY_NODES, ..roxmltree::ParsingOptions::default() };
let doc =
roxmltree::Document::parse_with_options(&xml, opts).map_err(|e| bad(cmd, format!("the variable library is not well-formed XML: {e}")))?;
let is = |n: &roxmltree::Node, name: &str| n.is_element() && n.tag_name().name() == name;
let Some(root) = doc.descendants().find(|n| is(n, "variableSets")) else {
return Err(bad(cmd, "the file holds no `variableSets` element"));
};
let sets: Vec<roxmltree::Node> = root.children().filter(|n| is(n, "variableSet")).collect();
let (mut variables, mut kinds, mut refs) = (Vec::new(), BTreeMap::new(), Vec::new());
for var in sets.iter().flat_map(|s| s.children()).filter(|n| is(n, "variables")).flat_map(|v| v.children()).filter(|n| is(n, "variable")) {
let name = named(var.attribute("varName"), "varName", cmd)?;
let trait_name = var.attribute("trait").map(|t| t.chars().take(MAX_NAME).collect::<String>());
let kind = trait_kind(trait_name.as_deref());
if kinds.insert(name.clone(), kind).is_some() {
return Err(bad(cmd, format!("variable `{name}` is declared twice")));
}
if kinds.len() > MAX_LIBRARY_VARIABLES {
return Err(bad(cmd, format!("the variable library declares more than {MAX_LIBRARY_VARIABLES} variables")));
}
if kind == VariableKind::Text {
// `docRef="id('…')"` names the element of the variable's bound object.
let element = var.attribute("docRef").and_then(|r| r.trim().strip_prefix("id('")?.strip_suffix("')")).filter(|e| !e.is_empty());
if let Some(element) = element {
refs.push((name.clone(), element.to_string()));
}
}
variables.push(LibraryVariable { name, kind, trait_name });
}
if variables.is_empty() {
return Err(bad(cmd, "the variable library declares no variables"));
}
let (mut datasets, mut seen) = (Vec::new(), BTreeSet::new());
for row in
sets.iter().flat_map(|s| s.children()).filter(|n| is(n, "sampleDataSets")).flat_map(|d| d.children()).filter(|n| is(n, "sampleDataSet"))
{
let name = named(row.attribute("dataSetName"), "dataSetName", cmd)?;
if !seen.insert(name.clone()) {
return Err(bad(cmd, format!("data set `{name}` is declared twice")));
}
if seen.len() > MAX_LIBRARY_DATASETS {
return Err(bad(cmd, format!("the variable library declares more than {MAX_LIBRARY_DATASETS} data sets")));
}
let (mut values, mut held) = (BTreeMap::new(), BTreeSet::new());
for el in row.children().filter(roxmltree::Node::is_element) {
let var = el.tag_name().name();
let Some(kind) = kinds.get(var) else {
return Err(bad(cmd, format!("data set `{name}` holds a value for `{var}`, which the library doesn't declare")));
};
if !held.insert(var) {
return Err(bad(cmd, format!("data set `{name}` holds two values for `{var}`")));
}
if text_only && *kind != VariableKind::Text {
continue;
}
if let Some(value) = library_value(el, *kind, &name, cmd)? {
values.insert(var.to_string(), value);
}
}
datasets.push(DataSet { name, values });
}
Ok(Library { variables, datasets, refs })
}
/// The value a data set's element `el` gives a variable of `kind`, or `None` when it gives none.
/// A text value is the text of its `p` elements, one paragraph each, and none without a `p`
/// element. A visibility value is `true` or `false`, in any case. An image value is the absolute
/// path of a file, or a `file:` URL of one ([`library_path`]); the file isn't read. A graph value is
/// a `data` element ([`graph_value`]). Visibility, image and graph values are read without the
/// white space round them, and an element holding only white space gives none. A variable of
/// unknown kind takes no value, so what its element holds is passed over. `set` names the data set
/// in the errors.
fn library_value(el: roxmltree::Node, kind: VariableKind, set: &str, cmd: &str) -> Result<Option<DataValue>> {
let refused = |what: &str| bad(cmd, format!("data set `{set}` holds a value for `{}` that isn't {what}", el.tag_name().name()));
let text = || if elements(el).next().is_some() { None } else { Some(deep_text(el)) };
match kind {
VariableKind::Text => {
let paras: Vec<String> = elements(el).filter(|n| n.tag_name().name() == "p").map(deep_text).collect();
Ok((!paras.is_empty()).then(|| DataValue::Text(paras.join("\n"))))
}
VariableKind::Visibility => {
let what = "`true` or `false`";
let text = text().ok_or_else(|| refused(what))?;
match text.trim_matches(XML_SPACE) {
"" => Ok(None),
t if t.eq_ignore_ascii_case("true") => Ok(Some(DataValue::Visible(true))),
t if t.eq_ignore_ascii_case("false") => Ok(Some(DataValue::Visible(false))),
_ => Err(refused(what)),
}
}
VariableKind::Image => {
let what = "a file's absolute path or `file:` URL";
let text = text().ok_or_else(|| refused(what))?;
match text.trim_matches(XML_SPACE) {
"" => Ok(None),
t => library_path(t).map(|p| Some(DataValue::Image(p))).ok_or_else(|| refused(what)),
}
}
VariableKind::Graph => graph_value(el, set, cmd),
VariableKind::Unknown => Ok(None),
}
}
/// The elements among `n`'s children.
fn elements<'a, 'i>(n: roxmltree::Node<'a, 'i>) -> impl Iterator<Item = roxmltree::Node<'a, 'i>> {
n.children().filter(roxmltree::Node::is_element)
}
/// The text of every text node inside `n`, in order.
fn deep_text(n: roxmltree::Node) -> String {
n.descendants().filter(roxmltree::Node::is_text).filter_map(|t| t.text()).collect()
}
/// The absolute path a library's image value `text` names: a `file:` URL's path (`file:///…`,
/// `file://localhost/…` or `file:/…`), its `%XX` escapes decoded (a URL with a host names a share,
/// `//host/…`), or `text` itself. `None` unless that is an absolute path: one starting with `/` or
/// `\\`, or a drive's path from its root (`C:\…`, `C:/…`).
fn library_path(text: &str) -> Option<String> {
let drive = |p: &str| matches!(p.as_bytes(), [l, b':', b'\\' | b'/', ..] if l.is_ascii_alphabetic());
let url = match (text.strip_prefix("file://"), text.strip_prefix("file:")) {
(Some(rest), _) => Some(rest.strip_prefix("localhost").filter(|r| r.starts_with('/')).unwrap_or(rest)),
// `file:/…` names a path without a host.
(None, Some(rest)) if rest.starts_with('/') => Some(rest),
_ => None,
};
let path = match url {
Some(rest) => {
if rest.starts_with('/') {
let p = percent_decoded(rest.trim_start_matches('/'));
if drive(&p) { p } else { format!("/{p}") }
} else {
format!("//{}", percent_decoded(rest))
}
}
None => text.to_string(),
};
(path.len() > 1 && (path.starts_with('/') || path.starts_with("\\\\") || drive(&path))).then_some(path)
}
/// `s` with its `%XX` escapes decoded, or as it is when the decoded bytes aren't UTF-8.
fn percent_decoded(s: &str) -> String {
let hex = |b: u8| char::from(b).to_digit(16);
let (mut out, mut rest) = (Vec::with_capacity(s.len()), s.as_bytes());
while let Some((&b, tail)) = rest.split_first() {
match tail {
[h, l, more @ ..] if b == b'%' && hex(*h).is_some() && hex(*l).is_some() => {
out.push(((hex(*h).unwrap_or(0) << 4) | hex(*l).unwrap_or(0)) as u8);
rest = more;
}
_ => {
out.push(b);
rest = tail;
}
}
}
String::from_utf8(out).unwrap_or_else(|_| s.to_string())
}
/// How a library writes the image value `path`: an absolute path from the root of a Unix file
/// system as a `file:` URL (`file:///` and the path, with `%`, `#`, `?`, spaces, controls and
/// bytes past ASCII escaped), any other path as it is. [`library_path`] reads it back.
fn library_file(path: &str) -> String {
if !path.starts_with('/') || path.starts_with("//") {
return path.to_string();
}
let mut url = String::from("file:///");
for &b in path.as_bytes() {
if matches!(b, b'%' | b'#' | b'?') || !(0x21..=0x7e).contains(&b) {
let _ = write!(url, "%{b:02X}");
} else {
url.push(char::from(b));
}
}
url
}
/// A library's graph value: the `data` element that `el` holds, read as CSV of the kind Graph
/// Data takes. Its `propertyRow` holds a corner cell and then the names of the series, and each
/// `row` of its `values` holds the row's category in a first `value` whose `key` is `name`, then
/// the row's values. The graph has categories when a row's name isn't blank or is marked
/// `type="string"`. Labels are read as they are; a value is read without the white space round it,
/// and one that is empty, marked `type="string"` or not a finite number is a blank. Without rows or
/// series, or when `el` holds only white space, there is no value. Anything else in `el`, more than
/// [`MAX_GRAPH_CATEGORIES`] rows or [`MAX_GRAPH_SERIES`] series (what a graph holds), and CSV longer
/// than graph values hold, are refused.
fn graph_value(el: roxmltree::Node, set: &str, cmd: &str) -> Result<Option<DataValue>> {
let var = el.tag_name().name();
let refused = || bad(cmd, format!("data set `{set}` holds a value for `{var}` that isn't a graph's `data` element"));
let named = |name: &'static str| move |n: &roxmltree::Node| n.tag_name().name() == name;
let mut children = elements(el);
let data = match (children.next(), children.next()) {
(None, _) if deep_text(el).trim_matches(XML_SPACE).is_empty() => return Ok(None),
(Some(data), None) if data.tag_name().name() == "data" => data,
_ => return Err(refused()),
};
// Labels keep their white space; numbers are read without it.
let series: Vec<String> =
elements(data).find(named("propertyRow")).map(|r| elements(r).filter(named("value")).skip(1).map(deep_text).collect()).unwrap_or_default();
let rows: Vec<roxmltree::Node> =
elements(data).filter(named("values")).flat_map(elements).filter(named("row")).take(MAX_GRAPH_CATEGORIES + 1).collect();
if rows.is_empty() && series.is_empty() {
return Ok(None);
}
let too_many = || bad(cmd, format!("data set `{set}` holds a graph value for `{var}` with {}", graph_limits()));
// A row's values after its name.
let wide = |row: &roxmltree::Node| {
let mut values = elements(*row).filter(named("value")).peekable();
let _name = values.next_if(|v| v.attribute("key") == Some("name"));
values.count() > MAX_GRAPH_SERIES
};
if rows.len() > MAX_GRAPH_CATEGORIES || series.len() > MAX_GRAPH_SERIES || rows.iter().any(wide) {
return Err(too_many());
}
// Each row's name and the values after it. A blank name marked `type="string"` is a blank
// category, so a graph whose categories are all blank keeps them.
let mut labelled = false;
let read: Vec<(Option<String>, Vec<Option<f64>>)> = rows
.iter()
.map(|row| {
let mut values = elements(*row).filter(named("value")).peekable();
let name = values.next_if(|v| v.attribute("key") == Some("name"));
labelled |= name.is_some_and(|v| v.attribute("type") == Some("string") || !deep_text(v).is_empty());
let name = name.map(deep_text);
let number = |v: roxmltree::Node| deep_text(v).trim_matches(XML_SPACE).parse::<f64>().ok().filter(|n| n.is_finite());
let numbers = values.map(|v| if v.attribute("type") == Some("string") { None } else { number(v) });
(name, numbers.collect())
})
.collect();
let categories = if labelled { read.iter().map(|(name, _)| name.clone().unwrap_or_default()).collect() } else { vec![] };
let mut spec = GraphSpec { series, categories, ..GraphSpec::default() };
spec.set_cells(read.into_iter().map(|(_, numbers)| numbers).collect());
// Data set values hold graph data without the line break at its end.
let csv = spec.to_csv().trim_end().to_string();
if csv.len() > MAX_GRAPH_CSV {
return Err(bad(cmd, format!("data set `{set}` holds a graph value for `{var}` longer than {MAX_GRAPH_CSV} bytes")));
}
Ok(Some(DataValue::Graph(csv)))
}
/// The variable library an SVG carries (SVG Options › Include Variable Data), read as
/// [`parse_library`] reads one, or `None` when the SVG holds no `variableSets` element. The
/// element is read on its own, from its start tag to the end tag that closes it
/// ([`variable_sets_range`]), with each reference to an
/// entity whose name starts with `ns_` replaced by the value the text before the element declares
/// for it (up to [`MAX_LIBRARY_ENTITIES`] of them, plain text of at most [`MAX_NAME`] bytes), as
/// files name the library's namespaces with such entities. The `ns_vars`, `ns_custom` and
/// `ns_flows` entities take the library's namespaces when the file doesn't declare them. An
/// element larger than [`MAX_LIBRARY_BYTES`], before or after the replacements, is refused.
pub(crate) fn svg_library(svg: &str) -> Option<Result<Library>> {
const C: &str = "document.open";
let (start, end) = variable_sets_range(svg)?;
let read = || {
let end = end.ok_or_else(|| bad(C, "the variable library declares no variables"))?;
let element = svg.get(start..end).unwrap_or_default();
if element.len() > MAX_LIBRARY_BYTES {
return Err(bad(C, format!("the variable library is larger than {MAX_LIBRARY_BYTES} bytes")));
}
let mut entities: Vec<(String, String)> = Vec::new();
for decl in svg.get(..start).unwrap_or_default().split("<!ENTITY").skip(1).take(MAX_LIBRARY_ENTITIES) {
let decl = decl.trim_start();
let Some((name, rest)) = decl.split_once(|c: char| c.is_ascii_whitespace()) else { continue };
let rest = rest.trim_start();
let Some(quote) = rest.chars().next().filter(|q| matches!(q, '"' | '\'')) else { continue };
let Some(value) = rest.get(1..).and_then(|v| v.split(quote).next()) else { continue };
if name.starts_with("ns_") && name.len() <= MAX_NAME && value.len() <= MAX_NAME && !value.contains(['<', '&', '%', '"']) {
entities.push((format!("&{name};"), value.to_string()));
}
}
for (name, value) in [("&ns_vars;", NS_VARIABLES), ("&ns_custom;", NS_CUSTOM), ("&ns_flows;", NS_FLOWS)] {
if !entities.iter().any(|(n, _)| n == name) {
entities.push((name.to_string(), value.to_string()));
}
}
// Counted before anything is replaced, so a hostile file can't make a large text first.
let grown =
entities.iter().map(|(name, value)| element.matches(name.as_str()).count() * value.len().saturating_sub(name.len())).sum::<usize>();
if element.len() + grown > MAX_LIBRARY_BYTES {
return Err(bad(C, format!("the variable library's entities expand to more than {MAX_LIBRARY_BYTES} bytes")));
}
let mut element = element.to_string();
for (name, value) in &entities {
element = element.replace(name.as_str(), value);
}
// The SVG keeps only the text variables, so the values of the other kinds aren't read.
parse_library(&format!("<svg>{element}</svg>"), C, true)
};
Some(read())
}
/// Where the first `variableSets` element of `svg` that is markup starts, and where the end tag
/// that closes it ends (`None` when no end tag does), or `None` when there is no such element.
/// Comments, CDATA sections, processing instructions and the document type declaration are
/// skipped, so text inside them that looks like the element is not taken for it.
fn variable_sets_range(svg: &str) -> Option<(usize, Option<usize>)> {
const NAME: &str = "variableSets";
// The element's name ends at white space, `>` or `/`.
let named = |rest: &str| rest.strip_prefix(NAME).is_some_and(|r| r.starts_with(|c: char| c.is_ascii_whitespace() || matches!(c, '>' | '/')));
if !svg.contains("<variableSets") {
return None;
}
let (mut at, mut start, mut depth) = (0, None, 0usize);
while let Some(off) = svg.get(at..).and_then(|s| s.find('<')) {
at += off;
let rest = svg.get(at..).unwrap_or_default();
// The end of a construct that holds text, or of the tag at `at`.
let past = |close: &str| rest.find(close).map(|e| at + e + close.len());
let next = if rest.starts_with("<!--") {
past("-->")
} else if rest.starts_with("<![CDATA[") {
past("]]>")
} else if rest.starts_with("<?") {
past("?>")
} else if rest.starts_with("<!DOCTYPE") {
// An internal subset ends at `]`, then the declaration at `>`.
match (rest.find('['), rest.find('>')) {
(Some(open), Some(gt)) if open < gt => {
rest.get(open..).and_then(|s| s.find(']')).and_then(|c| rest.get(open + c..)?.find('>').map(|g| at + open + c + g + 1))
}
(_, gt) => gt.map(|g| at + g + 1),
}
} else if let Some(close) = rest.strip_prefix("</") {
let tag_end = past(">");
if let Some(s) = start
&& named(close)
{
depth = depth.saturating_sub(1);
if depth == 0 {
return Some((s, tag_end));
}
}
tag_end
} else {
let tag_end = past(">");
if named(rest.get(1..).unwrap_or_default()) {
let empty = tag_end.and_then(|e| svg.get(..e)).is_some_and(|t| t.ends_with("/>"));
if start.is_none() {
start = Some(at);
}
if empty && depth == 0 {
return Some((at, tag_end));
}
depth += usize::from(!empty);
}
tag_end
};
let Some(next) = next else { break };
at = next;
}
start.map(|s| (s, None))
}
/// Give `doc`, opened from an SVG, the variable data `lib` it carries ([`svg_library`]): the
/// library's text variables, its data sets, no active data set, and each text variable bound to
/// the type object made of the element its `docRef` names, or the one type object among the
/// objects a group made of it holds (`found`: the object made of each element, by id). A `docRef`
/// that names no type object, or one another variable is bound to already, binds nothing. The art
/// stays as the file draws it. Variables of other kinds are left out with their values. The
/// warning about those variables, if any.
pub(crate) fn give_svg_library(doc: &mut Document, lib: Library, found: &HashMap<String, NodeId>) -> Option<String> {
let (text, other): (Vec<LibraryVariable>, Vec<LibraryVariable>) = lib.variables.into_iter().partition(|v| v.kind == VariableKind::Text);
let mut vars =
Variables { variables: text.iter().map(|v| Variable { name: v.name.clone(), kind: VariableKind::Text }).collect(), ..Variables::default() };
vars.datasets = lib.datasets;
for ds in &mut vars.datasets {
ds.values.retain(|_, v| matches!(v, DataValue::Text(_)));
}
// A type object written with a paint of its own, or with fills and strokes of its appearance,
// is a group around its text (and the appearance's paths).
let text_of = |id: NodeId| match doc.node(id).map(|n| &n.kind) {
Some(NodeKind::Text(_)) => Some(id),
Some(NodeKind::Group { children, .. }) => {
let mut texts = children.iter().filter(|c| matches!(c.kind, NodeKind::Text(_)));
match (texts.next(), texts.next()) {
(Some(one), None) => Some(one.id),
_ => None,
}
}
_ => None,
};
for (name, element) in &lib.refs {
let Some(id) = found.get(element).and_then(|id| text_of(*id)) else { continue };
if !vars.bindings.contains_key(&id) {
vars.bind(id, name);
}
}
doc.variables = vars.into();
left_out_warning(other.iter().map(|v| v.trait_name.as_deref().unwrap_or_else(|| v.kind.label())))
}
/// Load Variable Library: replace the document's variables and data sets with a variable library's
/// ([`parse_library`]) in one undo step, or none when the document already holds what the library
/// gives. Every data set is deleted, and every variable of the document is deleted with its
/// bindings and values, except a variable the library also declares with the same kind: it stays
/// bound to its objects, so the library's data sets change them (#4136; a template's bound
/// variables take a library of the same names:
/// <https://community.adobe.com/questions-652/illustrator-error-with-csv-files-812184>). The
/// library's other variables are then defined with their kinds, unbound, and its data sets are
/// added.
pub(super) fn load_library(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "variable.loadLibrary";
let bytes = library_bytes(p, C)?;
let xml = std::str::from_utf8(bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(&bytes)).map_err(|_| bad(C, "the variable library is not UTF-8"))?;
let lib = parse_library(xml, C, false)?;
let vars = &s.doc()?.doc.variables;
let kept = |v: &Variable| lib.variables.iter().any(|l| l.name == v.name && l.kind == v.kind);
let deleted: Vec<String> = vars.variables.iter().filter(|v| !kept(v)).map(|v| v.name.clone()).collect();
let deleted_sets: Vec<String> = vars.datasets.iter().map(|d| d.name.clone()).collect();
let added: Vec<Variable> = lib
.variables
.iter()
.filter(|l| !vars.variables.iter().any(|v| kept(v) && v.name == l.name))
.map(|l| Variable { name: l.name.clone(), kind: l.kind })
.collect();
// Lock Variables refuses New Variable and Delete Variable, so the load is refused when it would
// delete or define a variable.
if !deleted.is_empty() || !added.is_empty() {
variables_unlocked(s).map_err(|why| EngineError::Disabled(C.into(), why))?;
}
let names: Vec<String> = lib.datasets.iter().map(|d| d.name.clone()).collect();
// A load that leaves the variables and data sets as they were adds no undo step.
super::edit_variables(s, "Load Variable Library", |vars| {
vars.prune(&deleted);
vars.variables.extend(added);
vars.datasets = lib.datasets;
vars.active_dataset = None;
Ok(())
})?;
// A highlight of a variable that is gone highlights nothing.
let st = s.doc_mut()?;
st.drop_stale_variables_highlight();
st.revision += 1;
let declared: Vec<&str> = lib.variables.iter().map(|l| l.name.as_str()).collect();
Ok(json!({"variables": declared, "deleted": deleted, "deletedDataSets": deleted_sets, "names": names}))
}
/// The warning about variables that aren't text and were left out, given the kind of each: every
/// kind once, in the order it first comes, with how many variables have it. `None` without any.
fn left_out_warning<'a>(kinds: impl Iterator<Item = &'a str>) -> Option<String> {
let mut counted: Vec<(&str, usize)> = Vec::new();
for t in kinds {
match counted.iter_mut().find(|(k, _)| *k == t) {
Some((_, n)) => *n += 1,
None => counted.push((t, 1)),
}
}
if counted.is_empty() {
return None;
}
let kinds = counted.iter().map(|(k, n)| format!("{k} ({n})")).collect::<Vec<_>>().join(", ");
Some(format!("variables that aren't text were left out: {kinds}"))
}
/// Whether `name` can name an element: an XML name without a colon (XML 1.0, productions 4, 4a and
/// 5). A data set holds a text variable's value in an element named after the variable.
fn element_name(name: &str) -> bool {
let start = |c: char| {
matches!(c, 'A'..='Z' | '_' | 'a'..='z' | '\u{C0}'..='\u{D6}' | '\u{D8}'..='\u{F6}' | '\u{F8}'..='\u{2FF}' | '\u{370}'..='\u{37D}'
| '\u{37F}'..='\u{1FFF}' | '\u{200C}'..='\u{200D}' | '\u{2070}'..='\u{218F}' | '\u{2C00}'..='\u{2FEF}' | '\u{3001}'..='\u{D7FF}'
| '\u{F900}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}' | '\u{10000}'..='\u{EFFFF}')
};
let more = |c: char| start(c) || matches!(c, '-' | '.' | '0'..='9' | '\u{B7}' | '\u{300}'..='\u{36F}' | '\u{203F}'..='\u{2040}');
let mut chars = name.chars();
chars.next().is_some_and(start) && chars.all(more)
}
/// Whether XML can hold `c` (XML 1.0, production 2): tab, line feed, carriage return, and the
/// characters from U+0020 on except U+FFFE and U+FFFF.
fn xml_char(c: char) -> bool {
matches!(c, '\t' | '\n' | '\r' | '\u{20}'..='\u{FFFD}' | '\u{10000}'..='\u{10FFFF}')
}
/// `s` escaped for XML text, or with `attribute` for a quoted attribute value. `&`, `<` and `>`
/// become entity references, and so do quotes in an attribute value. A carriage return, and a tab
/// or line feed in an attribute value, become character references, which the parser reads back
/// as they are.
fn escaped(s: &str, attribute: bool) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
push_escaped(&mut out, c, attribute);
}
out
}
/// `c` added to `out`, escaped as [`escaped`] says.
fn push_escaped(out: &mut String, c: char, attribute: bool) {
match c {
'&' => out.push_str("&amp;"),
'<' => out.push_str("&lt;"),
'>' => out.push_str("&gt;"),
'\r' => out.push_str("&#13;"),
'"' if attribute => out.push_str("&quot;"),
'\'' if attribute => out.push_str("&apos;"),
'\t' if attribute => out.push_str("&#9;"),
'\n' if attribute => out.push_str("&#10;"),
c => out.push(c),
}
}
/// Add the graph value `csv` of the variable `var` to `xml` as the `data` element [`graph_value`]
/// reads: the CSV read as Graph Data reads it, a `propertyRow` with a blank corner cell and the
/// series names when it names series, and a `row` per category, its name in a first `value` with
/// `key="name"` (blank without categories) and then a `value` per series, blank where the row has
/// none. A label that isn't a number is marked `type="string"`, and so is a blank category. CSV
/// that names series and has no rows is written as the `propertyRow` alone. Refused for CSV with
/// neither rows nor series, which reads back as no value, for more than [`MAX_GRAPH_CATEGORIES`]
/// rows or [`MAX_GRAPH_SERIES`] series (what a graph holds), when a label holds a character XML
/// can't hold, and when `xml` grows past `room` bytes.
fn push_graph(xml: &mut String, var: &str, csv: &str, room: usize) -> std::result::Result<(), GraphRefusal> {
let (series, categories, rows) = super::super::graph::parse_csv(csv);
if rows.is_empty() && series.is_empty() {
return Err(GraphRefusal::Empty);
}
let width = rows.iter().map(Vec::len).max().unwrap_or(0).max(series.len());
if rows.len() > MAX_GRAPH_CATEGORIES || width > MAX_GRAPH_SERIES {
return Err(GraphRefusal::TooMany);
}
if !series.iter().chain(&categories).all(|l| l.chars().all(xml_char)) {
return Err(GraphRefusal::Control);
}
let labelled = !categories.is_empty();
let label = |l: &str, category: bool| {
let text = !l.is_empty() && l.trim().parse::<f64>().is_err();
let blank_category = category && labelled && l.is_empty();
let key = if category { " key=\"name\"" } else { "" };
let string = if text || blank_category { " type=\"string\"" } else { "" };
format!("<value{key}{string}>{}</value>", escaped(l, false))
};
let _ = writeln!(xml, "\t\t\t\t<{var}>\n\t\t\t\t\t<data numDataColumns=\"{}\">", width + usize::from(labelled));
if !series.is_empty() {
let names: String = (0..width).map(|s| label(series.get(s).map(String::as_str).unwrap_or_default(), false)).collect();
let _ = writeln!(xml, "\t\t\t\t\t\t<propertyRow key=\"name\"><value></value>{names}</propertyRow>");
}
xml.push_str("\t\t\t\t\t\t<values>\n");
for (i, row) in rows.iter().enumerate() {
let name = label(categories.get(i).map(String::as_str).unwrap_or_default(), true);
let values: String = (0..width)
.map(|s| match row.get(s).copied().flatten() {
Some(v) => format!("<value>{v}</value>"),
None => "<value></value>".to_string(),
})
.collect();
let _ = writeln!(xml, "\t\t\t\t\t\t\t<row>{name}{values}</row>");
if xml.len() > room {
return Err(GraphRefusal::TooLarge);
}
}
let _ = writeln!(xml, "\t\t\t\t\t\t</values>\n\t\t\t\t\t</data>\n\t\t\t\t</{var}>");
Ok(())
}
/// What a graph holds at most, for the errors about graph data past it.
fn graph_limits() -> String {
format!("more than {MAX_GRAPH_CATEGORIES} rows or {MAX_GRAPH_SERIES} series, which a graph doesn't hold")
}
/// Why [`push_graph`] refused a graph value.
enum GraphRefusal {
/// A label holds a character XML can't hold.
Control,
/// The data has more rows or series than a graph holds.
TooMany,
/// The data has neither rows nor series.
Empty,
/// The library grew past the room it has.
TooLarge,
}
/// Save Variable Library: the document's variables and its data sets as a variable library in the
/// layout [`parse_library`] reads, so Load Variable Library reads back the same variables with their
/// kinds, data set names and values. Each variable is declared with the `trait` and `category` of
/// its kind ([`kind_trait`]), and a variable of unknown kind with neither. A text value is written
/// as one `p` element per line, a visibility value as `true` or `false`, an image value as
/// [`library_file`] writes its path, and a graph value as a `data` element ([`push_graph`]). A
/// variable whose name can't name an element ([`element_name`]; a variable of unknown kind has no
/// values, so no element is named after it), a name or value that holds a character XML can't
/// hold, a name that Load Variable Library would read differently or refuse (white space at either
/// end, a name longer than `MAX_NAME` characters, a name used twice), an image value that isn't a
/// file's absolute path, and a library past the caps Load Variable Library reads are refused. With
/// `path` the library is written to the file; without it the reply carries it as `xml`.
pub(super) fn save_library(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "variable.saveLibrary";
let vars = &s.doc()?.doc.variables;
if vars.variables.is_empty() {
return Err(bad(C, "define a variable first"));
}
let all: Vec<&Variable> = vars.variables.iter().collect();
if let Some(name) = all.iter().filter(|v| v.kind != VariableKind::Unknown).map(|v| &v.name).find(|n| !element_name(n)) {
return Err(bad(
C,
format!(
"variable `{name}` can't be saved in a variable library: rename it to start with a letter or `_`, without spaces or symbols other than `-`, `_` and `.`"
),
));
}
// Load Variable Library reads a name trimmed and refuses one longer than `MAX_NAME` characters
// or declared twice.
let mut declared = BTreeSet::new();
for v in &all {
if named(Some(&v.name), "varName", C)? != v.name || !v.name.chars().all(xml_char) {
return Err(bad(
C,
format!("variable `{}` starts or ends with white space or holds a control character, which a variable library can't hold", v.name),
));
}
if !declared.insert(v.name.as_str()) {
return Err(bad(C, format!("variable `{}` is already defined", v.name)));
}
}
if all.len() > MAX_LIBRARY_VARIABLES {
return Err(bad(C, format!("the variable library declares more than {MAX_LIBRARY_VARIABLES} variables")));
}
if vars.datasets.len() > MAX_LIBRARY_DATASETS {
return Err(bad(C, format!("the variable library declares more than {MAX_LIBRARY_DATASETS} data sets")));
}
let mut xml = format!(
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\" [\n\
\t<!ENTITY ns_vars \"{NS_VARIABLES}\">\n\
\t<!ENTITY ns_custom \"{NS_CUSTOM}\">\n\
\t<!ENTITY ns_flows \"{NS_FLOWS}\">\n\
\t<!ENTITY ns_graphs \"{NS_GRAPHS}\">\n\
]>\n\
<svg>\n\
<variableSets xmlns=\"&ns_vars;\">\n\
\t<variableSet varSetName=\"binding1\" locked=\"none\">\n\
\t\t<variables>\n"
);
for v in &all {
let name = escaped(&v.name, true);
match kind_trait(v.kind) {
Some((t, category)) => xml += &format!("\t\t\t<variable varName=\"{name}\" trait=\"{t}\" category=\"{category}\"></variable>\n"),
None => xml += &format!("\t\t\t<variable varName=\"{name}\"></variable>\n"),
}
}
xml += "\t\t</variables>\n\t\t<v:sampleDataSets xmlns:v=\"&ns_vars;\" xmlns=\"&ns_custom;\">\n";
// Load Variable Library caps the file and the text its entity references expand to: each
// variable's `category`, two `&ns_vars;` and one `&ns_custom;`. The library stays within the
// cap less what the references add.
let grows = |value: &str, reference: &str| value.len().saturating_sub(reference.len());
let growth = all
.iter()
.filter_map(|v| kind_trait(v.kind))
.map(|(_, category)| match category {
"&ns_flows;" => grows(NS_FLOWS, category),
"&ns_graphs;" => grows(NS_GRAPHS, category),
_ => grows(NS_VARIABLES, category),
})
.sum::<usize>()
+ 2 * grows(NS_VARIABLES, "&ns_vars;")
+ grows(NS_CUSTOM, "&ns_custom;");
let room = MAX_LIBRARY_BYTES.saturating_sub(growth);
let too_large = || bad(C, format!("the variable library is larger than {MAX_LIBRARY_BYTES} bytes"));
let mut seen = BTreeSet::new();
for ds in &vars.datasets {
let name = &ds.name;
// Load Variable Library reads a data set's name trimmed and at most `MAX_NAME` characters
// long ([`named`]), and refuses a name declared twice.
if named(Some(name), "dataSetName", C)? != *name {
return Err(bad(C, format!("data set `{name}` starts or ends with white space, which a variable library can't hold")));
}
if !seen.insert(name.as_str()) {
return Err(bad(C, format!("dataset `{name}` already exists")));
}
let control = || bad(C, format!("data set `{name}` holds a control character, which a variable library can't hold"));
let mut text_values = all.iter().filter_map(|v| match ds.values.get(&v.name) {
Some(DataValue::Text(t)) if v.kind == VariableKind::Text => Some(t),
_ => None,
});
if !name.chars().all(xml_char) || text_values.any(|t| !t.chars().all(xml_char)) {
return Err(control());
}
xml += &format!("\t\t\t<v:sampleDataSet dataSetName=\"{}\">\n", escaped(name, true));
for v in &all {
let Some(value) = ds.values.get(&v.name).filter(|value| value.fits(v.kind)) else { continue };
let var = &v.name;
match value {
DataValue::Text(t) => {
xml += &format!("\t\t\t\t<{var}>\n");
for line in t.split('\n') {
xml += "\t\t\t\t\t<p>";
// A value can be larger than the cap, so the text stops growing once it passes it.
for c in line.chars() {
push_escaped(&mut xml, c, false);
if xml.len() > room {
return Err(too_large());
}
}
xml += "</p>\n";
}
xml += &format!("\t\t\t\t</{var}>\n");
}
DataValue::Visible(shown) => xml += &format!("\t\t\t\t<{var}>{shown}</{var}>\n"),
DataValue::Image(path) => {
// Load Variable Library reads back only a file's absolute path.
let file = library_file(path);
if library_path(file.trim_matches(XML_SPACE)).as_deref() != Some(path.as_str()) {
return Err(bad(C, format!("data set `{name}` holds an image value for `{var}` that isn't a file's absolute path")));
}
if !file.chars().all(xml_char) {
return Err(control());
}
xml += &format!("\t\t\t\t<{var}>{}</{var}>\n", escaped(&file, false));
}
DataValue::Graph(csv) => match push_graph(&mut xml, var, csv, room) {
Ok(()) => {}
Err(GraphRefusal::Control) => return Err(control()),
Err(GraphRefusal::TooMany) => {
return Err(bad(C, format!("data set `{name}` holds a graph value for `{var}` with {}", graph_limits())));
}
Err(GraphRefusal::Empty) => {
return Err(bad(C, format!("data set `{name}` holds a graph value for `{var}` without rows or series")));
}
Err(GraphRefusal::TooLarge) => return Err(too_large()),
},
}
if xml.len() > room {
return Err(too_large());
}
}
xml += "\t\t\t</v:sampleDataSet>\n";
if xml.len() > room {
return Err(too_large());
}
}
xml += "\t\t</v:sampleDataSets>\n\t</variableSet>\n</variableSets>\n</svg>\n";
if xml.len() > room {
return Err(too_large());
}
let mut out = json!({"variables": all.iter().map(|v| v.name.as_str()).collect::<Vec<_>>(), "datasets": vars.datasets.len()});
match str_param(p, "path") {
Some(path) => {
let path = absolute_path(path);
write_file(&path, xml.as_bytes())?;
out["path"] = json!(path);
}
None => out["xml"] = json!(xml),
}
Ok(out)
}