mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-16 02:36:49 +00:00
Variables: Load and Save Variable Library hold visibility, image and graph variables
Load Variable Library defines each variable with the kind of its trait (textcontent, visibility, fileref, graphdata; any other or none is the unknown kind) and reads visibility values from true or false, image values from a file's absolute path or file: URL, and graph values from a data element of series names and rows. A document variable declared with the same name and kind keeps its bindings. Save Variable Library writes every kind in the same forms and is enabled with any variable. Image values that aren't absolute paths and graph data past what a graph holds are refused, so every saved file loads back.
This commit is contained in:
@@ -1,18 +1,29 @@
|
||||
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_NAME, NodeId, NodeKind, Result, Session, Value, Variable, VariableKind,
|
||||
Variables, absolute_path, bad, json, named, read_file_head, str_param, variables_unlocked, write_file,
|
||||
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 text variables.
|
||||
/// 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;
|
||||
@@ -170,16 +181,47 @@ fn without_doctype(xml: &str, cmd: &str) -> Result<String> {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// A variable library as Load Variable Library reads it: the names of its text variables in the
|
||||
/// order it declares them, the name and `trait` of each variable of another kind, its data sets
|
||||
/// with their text values, and the element id each text variable's `docRef` names.
|
||||
/// 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 {
|
||||
text: Vec<String>,
|
||||
other: Vec<(String, String)>,
|
||||
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> {
|
||||
@@ -190,12 +232,11 @@ impl Library {
|
||||
/// 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 whose `trait` is `textcontent` is a text variable. In a data set, an element named
|
||||
/// after a text variable gives its value: the text of its `p` elements, one paragraph each, and
|
||||
/// none when it has no `p` element. Values for variables of other kinds are left out. A variable
|
||||
/// or data set declared twice, a value for a variable the library doesn't declare, and a library
|
||||
/// past the caps are refused. Entities that its document type declaration defines are read as
|
||||
/// [`without_doctype`] says.
|
||||
/// 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. Entities that its document type
|
||||
/// declaration defines are read as [`without_doctype`] says.
|
||||
fn parse_library(xml: &str, cmd: &str) -> Result<Library> {
|
||||
let xml = without_doctype(xml, cmd)?;
|
||||
// roxmltree parses nested elements recursively.
|
||||
@@ -210,32 +251,29 @@ fn parse_library(xml: &str, cmd: &str) -> Result<Library> {
|
||||
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 text, mut other, mut declared, mut refs) = (Vec::new(), Vec::new(), BTreeSet::new(), Vec::new());
|
||||
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)?;
|
||||
if !declared.insert(name.clone()) {
|
||||
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 declared.len() > MAX_LIBRARY_VARIABLES {
|
||||
if kinds.len() > MAX_LIBRARY_VARIABLES {
|
||||
return Err(bad(cmd, format!("the variable library declares more than {MAX_LIBRARY_VARIABLES} variables")));
|
||||
}
|
||||
match var.attribute("trait") {
|
||||
Some("textcontent") => {
|
||||
// `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()));
|
||||
}
|
||||
text.push(name);
|
||||
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()));
|
||||
}
|
||||
Some(t) => other.push((name, t.chars().take(MAX_NAME).collect())),
|
||||
None => return Err(bad(cmd, format!("variable `{name}` has no `trait`"))),
|
||||
}
|
||||
variables.push(LibraryVariable { name, kind, trait_name });
|
||||
}
|
||||
if declared.is_empty() {
|
||||
if variables.is_empty() {
|
||||
return Err(bad(cmd, "the variable library declares no variables"));
|
||||
}
|
||||
let text_names: BTreeSet<&str> = text.iter().map(String::as_str).collect();
|
||||
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"))
|
||||
@@ -250,27 +288,194 @@ fn parse_library(xml: &str, cmd: &str) -> Result<Library> {
|
||||
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();
|
||||
if !declared.contains(var) {
|
||||
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_names.contains(var) {
|
||||
continue;
|
||||
}
|
||||
let paras: Vec<String> = el
|
||||
.children()
|
||||
.filter(|n| is(n, "p"))
|
||||
.map(|p| p.descendants().filter(roxmltree::Node::is_text).filter_map(|t| t.text()).collect())
|
||||
.collect();
|
||||
if !paras.is_empty() {
|
||||
values.insert(var.to_string(), DataValue::Text(paras.join("\n")));
|
||||
if let Some(value) = library_value(el, *kind, &name, cmd)? {
|
||||
values.insert(var.to_string(), value);
|
||||
}
|
||||
}
|
||||
datasets.push(DataSet { name, values });
|
||||
}
|
||||
Ok(Library { text, other, datasets, refs })
|
||||
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
|
||||
@@ -389,12 +594,16 @@ fn variable_sets_range(svg: &str) -> Option<(usize, Option<usize>)> {
|
||||
/// 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. The warning about the variables of other kinds that were left out,
|
||||
/// if any.
|
||||
/// 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: lib.text.iter().map(|n| Variable { name: n.clone(), kind: VariableKind::Text }).collect(), ..Variables::default() };
|
||||
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) {
|
||||
@@ -415,32 +624,32 @@ pub(crate) fn give_svg_library(doc: &mut Document, lib: Library, found: &HashMap
|
||||
}
|
||||
}
|
||||
doc.variables = vars.into();
|
||||
left_out_warning(lib.other.iter().map(|(_, t)| t.as_str()))
|
||||
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 text variable the library also declares: 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:
|
||||
/// 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 text variables are then defined, unbound, and its data sets are added. The
|
||||
/// library's variables of other kinds are left out, named in `skipped` and in a warning.
|
||||
/// 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)?;
|
||||
let vars = &s.doc()?.doc.variables;
|
||||
let kept = |v: &Variable| v.kind == VariableKind::Text && lib.text.contains(&v.name);
|
||||
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
|
||||
.text
|
||||
.variables
|
||||
.iter()
|
||||
.filter(|n| !vars.variables.iter().any(|v| kept(v) && &v.name == *n))
|
||||
.map(|n| Variable { name: n.clone(), kind: VariableKind::Text })
|
||||
.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.
|
||||
@@ -460,14 +669,8 @@ pub(super) fn load_library(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let st = s.doc_mut()?;
|
||||
st.drop_stale_variables_highlight();
|
||||
st.revision += 1;
|
||||
let skipped: Vec<Value> = lib.other.iter().map(|(name, t)| json!({"name": name, "trait": t})).collect();
|
||||
let mut out = json!({
|
||||
"variables": lib.text, "deleted": deleted, "deletedDataSets": deleted_sets, "names": names, "skipped": skipped,
|
||||
});
|
||||
if let Some(warning) = left_out_warning(lib.other.iter().map(|(_, t)| t.as_str())) {
|
||||
out["warning"] = json!(warning);
|
||||
}
|
||||
Ok(out)
|
||||
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
|
||||
@@ -533,26 +736,95 @@ fn push_escaped(out: &mut String, c: char, attribute: bool) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Save Variable Library: the document's text variables and its data sets as a variable library in
|
||||
/// the layout [`parse_library`] reads, so Load Variable Library reads back the same text variables,
|
||||
/// data set names and text values. A text value is written as one `p` element per line. Variables
|
||||
/// of other kinds are left out with their values, named in `skipped` and in a warning. A text
|
||||
/// variable whose name can't name an element ([`element_name`]), a data set name or text 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 of a data set name, a name longer than `MAX_NAME` characters,
|
||||
/// a name used twice), 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`.
|
||||
/// 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 (text, other): (Vec<&Variable>, Vec<&Variable>) = vars.variables.iter().partition(|v| v.kind == VariableKind::Text);
|
||||
if text.is_empty() {
|
||||
return Err(bad(C, "a variable library holds text variables, and the document has none"));
|
||||
}
|
||||
if let Some(name) = text.iter().map(|v| &v.name).find(|n| !element_name(n)) {
|
||||
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!(
|
||||
@@ -560,48 +832,62 @@ pub(super) fn save_library(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
),
|
||||
));
|
||||
}
|
||||
// Load Variable Library refuses a name longer than `MAX_NAME` characters and a name declared
|
||||
// twice.
|
||||
// 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 &text {
|
||||
named(Some(&v.name), "varName", C)?;
|
||||
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 text.len() > MAX_LIBRARY_VARIABLES {
|
||||
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")));
|
||||
}
|
||||
fn text_value<'a>(ds: &'a DataSet, var: &str) -> Option<&'a str> {
|
||||
match ds.values.get(var) {
|
||||
Some(DataValue::Text(t)) => Some(t.as_str()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
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 &text {
|
||||
xml += &format!("\t\t\t<variable varName=\"{}\" trait=\"textcontent\" category=\"&ns_flows;\"></variable>\n", v.name);
|
||||
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: one
|
||||
// `&ns_flows;` per variable, two `&ns_vars;` and one `&ns_custom;`. The library stays within
|
||||
// the cap less what the references add.
|
||||
// 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 = text.len() * grows(NS_FLOWS, "&ns_flows;") + 2 * grows(NS_VARIABLES, "&ns_vars;") + grows(NS_CUSTOM, "&ns_custom;");
|
||||
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();
|
||||
@@ -615,25 +901,61 @@ pub(super) fn save_library(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if !seen.insert(name.as_str()) {
|
||||
return Err(bad(C, format!("dataset `{name}` already exists")));
|
||||
}
|
||||
if !name.chars().all(xml_char) || text.iter().filter_map(|v| text_value(ds, &v.name)).any(|t| !t.chars().all(xml_char)) {
|
||||
return Err(bad(C, format!("data set `{name}` holds a control character, which a variable library can't hold")));
|
||||
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 &text {
|
||||
let Some(t) = text_value(ds, &v.name) else { continue };
|
||||
xml += &format!("\t\t\t\t<{}>\n", v.name);
|
||||
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());
|
||||
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");
|
||||
}
|
||||
xml += "</p>\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 += &format!("\t\t\t\t</{}>\n", v.name);
|
||||
}
|
||||
xml += "\t\t\t</v:sampleDataSet>\n";
|
||||
if xml.len() > room {
|
||||
@@ -644,13 +966,7 @@ pub(super) fn save_library(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if xml.len() > room {
|
||||
return Err(too_large());
|
||||
}
|
||||
let skipped: Vec<Value> = other.iter().map(|v| json!({"name": v.name, "kind": v.kind.label()})).collect();
|
||||
let mut out = json!({
|
||||
"variables": text.iter().map(|v| v.name.as_str()).collect::<Vec<_>>(), "datasets": vars.datasets.len(), "skipped": skipped,
|
||||
});
|
||||
if let Some(warning) = left_out_warning(other.iter().map(|v| v.kind.label())) {
|
||||
out["warning"] = json!(warning);
|
||||
}
|
||||
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);
|
||||
|
||||
Reference in New Issue
Block a user