from appearing non-empty
@@ -44,6 +86,23 @@ def field_is_not_empty(field_text: str) -> bool:
return field_text.strip() != ""
+def nonempty_fields(fields: Dict[str, str]) -> List[str]:
+ res = []
+ for field, text in fields.items():
+ if field_is_not_empty(text):
+ res.append(field)
+ return res
+
+
+def unknown_field_message(node: TemplateReplacement) -> str:
+ # mirror the pystache message for now
+ field = node.field_name
+ if node.filters:
+ field_and_filters = list(reversed(node.filters)) + [field]
+ field = ":".join(field_and_filters)
+ return "{unknown field %s}" % field
+
+
# Filters
##########################################################################
#
diff --git a/rslib/src/backend.rs b/rslib/src/backend.rs
index 7f13d3ad0..35d20fd26 100644
--- a/rslib/src/backend.rs
+++ b/rslib/src/backend.rs
@@ -1,9 +1,10 @@
use crate::backend_proto as pt;
use crate::backend_proto::backend_input::Value;
+use crate::backend_proto::FlattenedTemplateReplacement;
use crate::err::{AnkiError, Result};
use crate::sched::sched_timing_today;
use crate::template::{
- without_legacy_template_directives, FieldMap, FieldRequirements, ParsedTemplate,
+ without_legacy_template_directives, FieldMap, FieldRequirements, FlattenedNode, ParsedTemplate,
};
use prost::Message;
use std::collections::HashSet;
@@ -92,6 +93,7 @@ impl Backend {
Value::DeckTree(_) => todo!(),
Value::FindCards(_) => todo!(),
Value::BrowserRows(_) => todo!(),
+ Value::FlattenTemplate(input) => OValue::FlattenTemplate(self.flatten_template(input)?),
})
}
@@ -153,8 +155,43 @@ impl Backend {
next_day_at: today.next_day_at,
}
}
+
+ fn flatten_template(&self, input: pt::FlattenTemplateIn) -> Result
{
+ let field_refs: HashSet<_> = input
+ .nonempty_field_names
+ .iter()
+ .map(AsRef::as_ref)
+ .collect();
+
+ let normalized = without_legacy_template_directives(&input.template_text);
+ match ParsedTemplate::from_text(normalized.as_ref()) {
+ Ok(tmpl) => {
+ let nodes = tmpl.flatten(&field_refs);
+ let out_nodes = nodes
+ .into_iter()
+ .map(|n| pt::FlattenedTemplateNode {
+ value: Some(flattened_node_to_proto(n)),
+ })
+ .collect();
+ Ok(pt::FlattenTemplateOut { nodes: out_nodes })
+ }
+ Err(e) => Err(e),
+ }
+ }
}
fn ords_hash_to_set(ords: HashSet) -> Vec {
ords.iter().map(|ord| *ord as u32).collect()
}
+
+fn flattened_node_to_proto(node: FlattenedNode) -> pt::flattened_template_node::Value {
+ match node {
+ FlattenedNode::Text { text } => pt::flattened_template_node::Value::Text(text),
+ FlattenedNode::Replacement { field, filters } => {
+ pt::flattened_template_node::Value::Replacement(FlattenedTemplateReplacement {
+ field_name: field,
+ filters,
+ })
+ }
+ }
+}
diff --git a/rslib/src/template.rs b/rslib/src/template.rs
index 3e1d66961..9376234dc 100644
--- a/rslib/src/template.rs
+++ b/rslib/src/template.rs
@@ -226,7 +226,71 @@ fn template_is_empty<'a>(nonempty_fields: &HashSet<&str>, nodes: &[ParsedNode<'a
true
}
-// Compatibility with old Anki versions
+// Flattening
+//----------------------------------------
+
+#[derive(Debug, PartialEq)]
+pub enum FlattenedNode {
+ Text {
+ text: String,
+ },
+ /// Filters are in the order they should be applied.
+ Replacement {
+ field: String,
+ filters: Vec,
+ },
+}
+
+impl ParsedTemplate<'_> {
+ /// Resolve conditional replacements, returning a list of nodes.
+ ///
+ /// This leaves the field replacement (with any filters that were provided)
+ /// up to the calling code to handle.
+ pub fn flatten(&self, nonempty_fields: &HashSet<&str>) -> Vec {
+ let mut flattened = vec![];
+
+ flatten_into(&mut flattened, self.0.as_ref(), nonempty_fields);
+
+ flattened
+ }
+}
+
+fn flatten_into(
+ rendered_nodes: &mut Vec,
+ nodes: &[ParsedNode],
+ fields: &HashSet<&str>,
+) {
+ use ParsedNode::*;
+ for node in nodes {
+ match node {
+ Text(t) => {
+ if let Some(FlattenedNode::Text { ref mut text }) = rendered_nodes.last_mut() {
+ text.push_str(t)
+ } else {
+ rendered_nodes.push(FlattenedNode::Text {
+ text: (*t).to_string(),
+ })
+ }
+ }
+ Replacement { key, filters } => rendered_nodes.push(FlattenedNode::Replacement {
+ field: (*key).to_string(),
+ filters: filters.iter().map(|&e| e.to_string()).collect(),
+ }),
+ Conditional { key, children } => {
+ if fields.contains(key) {
+ flatten_into(rendered_nodes, children.as_ref(), fields);
+ }
+ }
+ NegatedConditional { key, children } => {
+ if !fields.contains(key) {
+ flatten_into(rendered_nodes, children.as_ref(), fields);
+ }
+ }
+ };
+ }
+}
+
+// Field requirements
//----------------------------------------
#[derive(Debug, Clone, PartialEq)]
@@ -240,8 +304,13 @@ impl ParsedTemplate<'_> {
/// Return fields required by template.
///
/// This is not able to represent negated expressions or combinations of
- /// Any and All, and is provided only for the sake of backwards
- /// compatibility.
+ /// Any and All, but is compatible with older Anki clients.
+ ///
+ /// In the future, it may be feasible to calculate the requirements
+ /// when adding cards, instead of caching them up front, which would mean
+ /// the above restrictions could be lifted. We would probably
+ /// want to add a cache of non-zero fields -> available cards to avoid
+ /// slowing down bulk operations like importing too much.
pub fn requirements(&self, field_map: &FieldMap) -> FieldRequirements {
let mut nonempty: HashSet<_> = Default::default();
let mut ords = HashSet::new();
@@ -392,4 +461,72 @@ mod test {
assert_eq!(without_legacy_template_directives(input), output);
}
+
+ #[test]
+ fn test_render() {
+ let map: HashSet<_> = vec!["F", "B"].into_iter().collect();
+
+ use crate::template::FlattenedNode as FN;
+ let mut tmpl = PT::from_text("{{B}}A{{F}}").unwrap();
+ assert_eq!(
+ tmpl.flatten(&map),
+ vec![
+ FN::Replacement {
+ field: "B".to_owned(),
+ filters: vec![]
+ },
+ FN::Text {
+ text: "A".to_owned()
+ },
+ FN::Replacement {
+ field: "F".to_owned(),
+ filters: vec![]
+ },
+ ]
+ );
+
+ // empty
+ tmpl = PT::from_text("{{#E}}A{{/E}}").unwrap();
+ assert_eq!(tmpl.flatten(&map), vec![]);
+
+ // missing
+ tmpl = PT::from_text("{{^M}}A{{/M}}").unwrap();
+ assert_eq!(
+ tmpl.flatten(&map),
+ vec![FN::Text {
+ text: "A".to_owned()
+ },]
+ );
+
+ // nested
+ tmpl = PT::from_text("{{^E}}1{{#F}}2{{#B}}{{F}}{{/B}}{{/F}}{{/E}}").unwrap();
+ assert_eq!(
+ tmpl.flatten(&map),
+ vec![
+ FN::Text {
+ text: "12".to_owned()
+ },
+ FN::Replacement {
+ field: "F".to_owned(),
+ filters: vec![]
+ },
+ ]
+ );
+
+ // filters
+ tmpl = PT::from_text("{{one:two:B}}{{three:X}}").unwrap();
+ assert_eq!(
+ tmpl.flatten(&map),
+ vec![
+ FN::Replacement {
+ field: "B".to_owned(),
+ filters: vec!["two".to_string(), "one".to_string()]
+ },
+ FN::Replacement {
+ field: "X".to_owned(),
+ filters: vec!["three".to_string()]
+ },
+ ]
+ );
+ }
}