2bc41aeb8602
library.rs
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 its depth and node limits count the elements it
/// 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('"', """).replace('\'', "'").replace('>', ">")));
} 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)?;
let opts = craft_xml::Options {
names: craft_xml::Names::AsWritten,
limits: craft_xml::Limits { max_depth: MAX_LIBRARY_NESTING, max_nodes: MAX_LIBRARY_NODES as usize, ..craft_xml::Limits::DEFAULT },
..craft_xml::Options::default()
}
.strict();
let doc = opts.parse(xml.as_bytes()).map_err(|e| match e {
craft_xml::Error::TooDeep(_) => bad(cmd, format!("the variable library nests elements more than {MAX_LIBRARY_NESTING} deep")),
_ => bad(cmd, format!("the variable library is not well-formed XML: {e}")),
})?;
let Some(root) = std::iter::once(&doc).chain(doc.descendants()).find(|n| n.is(craft_xml::Local("variableSets"))) else {
return Err(bad(cmd, "the file holds no `variableSets` element"));
};
let sets: Vec<&craft_xml::El> = root.children(craft_xml::Local("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(craft_xml::Local("variables"))).flat_map(|v| v.children(craft_xml::Local("variable"))) {
let name = named(var.attr("varName"), "varName", cmd)?;
let trait_name = var.attr("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.attr("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(craft_xml::Local("sampleDataSets"))).flat_map(|d| d.children(craft_xml::Local("sampleDataSet"))) {
let name = named(row.attr("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.elements() {
let var = el.local();
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: &craft_xml::El, 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.local()));
let text = || if el.elements().next().is_some() { None } else { Some(el.deep_text()) };
match kind {
VariableKind::Text => {
let paras: Vec<String> = el.children(craft_xml::Local("p")).map(craft_xml::El::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 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: &craft_xml::El, set: &str, cmd: &str) -> Result<Option<DataValue>> {
let var = el.local();
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| craft_xml::Local(name);
let mut children = el.elements();
let data = match (children.next(), children.next()) {
(None, _) if el.deep_text().trim_matches(XML_SPACE).is_empty() => return Ok(None),
(Some(data), None) if data.local() == "data" => data,
_ => return Err(refused()),
};
// Labels keep their white space; numbers are read without it.
let series: Vec<String> =
data.child(named("propertyRow")).map(|r| r.children(named("value")).skip(1).map(craft_xml::El::deep_text).collect()).unwrap_or_default();
let rows: Vec<&craft_xml::El> = data.children(named("values")).flat_map(|v| v.children(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: &&craft_xml::El| {
let mut values = row.children(named("value")).peekable();
let _name = values.next_if(|v| v.attr("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 = row.children(named("value")).peekable();
let name = values.next_if(|v| v.attr("key") == Some("name"));
labelled |= name.is_some_and(|v| v.attr("type") == Some("string") || !v.deep_text().is_empty());
let name = name.map(craft_xml::El::deep_text);
let number = |v: &craft_xml::El| v.deep_text().trim_matches(XML_SPACE).parse::<f64>().ok().filter(|n| n.is_finite());
let numbers = values.map(|v| if v.attr("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| left_out_kind(v.kind, v.trait_name.as_deref())))
}
/// How the warning about variables that aren't text names the kind of one: Visibility, Linked File
/// or Graph Data for a `trait` VectorCraft reads, Unknown for a variable without a `trait`, and any
/// other `trait` as the file writes it, in backticks, each backtick in it doubled, so that a `trait`
/// such as `Unknown` or `a (1), b` reads as one kind the file names.
fn left_out_kind(kind: VariableKind, trait_name: Option<&str>) -> String {
match (kind, trait_name) {
(VariableKind::Visibility, _) => "Visibility".into(),
(VariableKind::Image, _) => "Linked File".into(),
(VariableKind::Graph, _) => "Graph Data".into(),
(_, None) => "Unknown".into(),
(_, Some(t)) => format!("`{}`", t.replace('`', "``")),
}
}
/// 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
/// ([`left_out_kind`]): every kind once, in the order it first comes, with how many variables have
/// it. `None` without any.
fn left_out_warning(kinds: impl Iterator<Item = String>) -> Option<String> {
let mut counted: Vec<(String, 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("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'\r' => out.push_str(" "),
'"' if attribute => out.push_str("""),
'\'' if attribute => out.push_str("'"),
'\t' if attribute => out.push_str("	"),
'\n' if attribute => out.push_str(" "),
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)
}
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.