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> { 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 { 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, "").ok_or_else(refused)?; } else if at(i, "").ok_or_else(refused)?; } else { break; } } if !at(i, " 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)?)) }; // `' i = spaces(i + "')).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, "").ok_or_else(refused)?; } else if at(i, "").ok_or_else(refused)?; } else if at(i, "')).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 = [(""), (""), ("")].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, } /// 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, datasets: Vec, 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 { 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 { 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 = 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::()); 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> { 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 = 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> { 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 { 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> { 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 = elements(data).find(named("propertyRow")).map(|r| elements(r).filter(named("value")).skip(1).map(deep_text).collect()).unwrap_or_default(); let rows: Vec = 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, Vec>)> = 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::().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> { 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("(); 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!("{element}"), 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)> { 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("") } else if rest.starts_with("") } else if rest.starts_with("") } else if rest.starts_with("`. 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(""); 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) -> Option { let (text, other): (Vec, Vec) = 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: /// ). 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 { 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 = vars.variables.iter().filter(|v| !kept(v)).map(|v| v.name.clone()).collect(); let deleted_sets: Vec = vars.datasets.iter().map(|d| d.name.clone()).collect(); let added: Vec = 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 = 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) -> Option { 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::>().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::().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!("{}", escaped(l, false)) }; let _ = writeln!(xml, "\t\t\t\t<{var}>\n\t\t\t\t\t", 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{names}"); } xml.push_str("\t\t\t\t\t\t\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!("{v}"), None => "".to_string(), }) .collect(); let _ = writeln!(xml, "\t\t\t\t\t\t\t{name}{values}"); if xml.len() > room { return Err(GraphRefusal::TooLarge); } } let _ = writeln!(xml, "\t\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t"); 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 { 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!( "\n\ \n\ \t\n\ \t\n\ \t\n\ ]>\n\ \n\ \n\ \t\n\ \t\t\n" ); for v in &all { let name = escaped(&v.name, true); match kind_trait(v.kind) { Some((t, category)) => xml += &format!("\t\t\t\n"), None => xml += &format!("\t\t\t\n"), } } xml += "\t\t\n\t\t\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::() + 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\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

"; // 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 += "

\n"; } xml += &format!("\t\t\t\t\n"); } DataValue::Visible(shown) => xml += &format!("\t\t\t\t<{var}>{shown}\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}>{}\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\n"; if xml.len() > room { return Err(too_large()); } } xml += "\t\t\n\t\n\n\n"; if xml.len() > room { return Err(too_large()); } let mut out = json!({"variables": all.iter().map(|v| v.name.as_str()).collect::>(), "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) }