LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-LIB-KEYWORDS: the keywords an exported file carries
Nathaniel Ledford7029c8fbbdee
diff --git a/crates/catalog/src/keywords.rs b/crates/catalog/src/keywords.rsindex 9bd67700d..d351941d6 100644--- a/crates/catalog/src/keywords.rs+++ b/crates/catalog/src/keywords.rs@@ -83,6 +83,16 @@ pub struct ListedKeyword {pub info: KeywordInfo,}+/// A photo's keywords as an exported file carries them.+#[derive(Clone, Debug, Default, PartialEq, Eq)]+pub struct ExportKeywords {+ /// Names, flat (`dc:subject`): each keyword's own, the keywords containing it and synonyms, as+ /// their options say.+ pub flat: Vec<String>,+ /// Full paths (`lr:hierarchicalSubject`).+ pub hierarchical: Vec<String>,+}+/// One node of the keyword tree.#[derive(Clone, Debug, PartialEq, Serialize)]pub struct KeywordNode {@@ -250,6 +260,52 @@ impl Catalog {Ok(Op::Batch { ops })}+ /// What exported files carry for a photo with these keywords (Lightroom Classic's keyword tag+ /// options, [`KeywordInfo`]): a keyword left out of export goes nowhere; otherwise its name+ /// and full path, the keywords containing it that are exported themselves (unless "export+ /// containing keywords" is off) and synonyms (unless "export synonyms" is off). Each name once,+ /// whatever its case.+ pub fn export_keywords(&self, keywords: &[String]) -> ExportKeywords {+ let defaults = KeywordInfo::default();+ let info = |path: &str| self.keyword_info(path).unwrap_or(&defaults);+ let mut out = ExportKeywords::default();+ let push = |v: &mut Vec<String>, s: &str| {+ if !s.is_empty() && !v.iter().any(|x| x.eq_ignore_ascii_case(s)) {+ v.push(s.to_string());+ }+ };+ for k in keywords {+ let path = clean(k);+ let me = info(&path);+ if path.is_empty() || !me.include_on_export {+ continue;+ }+ let levels: Vec<&str> = path.split(SEP).collect();+ let mut names = |at: usize, i: &KeywordInfo| {+ if let Some(name) = levels.get(at) {+ push(&mut out.flat, name);+ }+ if i.export_synonyms {+ for s in &i.synonyms {+ push(&mut out.flat, s.trim());+ }+ }+ };+ names(levels.len().saturating_sub(1), me);+ if me.export_containing {+ for at in (0..levels.len().saturating_sub(1)).rev() {+ let parent = levels.get(..=at).map(|l| l.join("|")).unwrap_or_default();+ let pi = info(&parent);+ if pi.include_on_export {+ names(at, pi);+ }+ }+ }+ push(&mut out.hierarchical, &path);+ }+ out+ }+/// The keyword is in the tree: listed, or on a photo (itself or one below it).pub fn has_keyword(&self, path: &str) -> bool {let k = clean(path);@@ -682,6 +738,47 @@ mod tests {assert_eq!(kws(&c, ids[1]), ["Weg|ü"]);}+ fn exported(c: &Catalog, keywords: &[&str]) -> (Vec<String>, Vec<String>) {+ let e = c.export_keywords(&keywords.iter().map(|k| k.to_string()).collect::<Vec<_>>());+ (e.flat, e.hierarchical)+ }++ /// By default a keyword is exported as its name together with the keywords containing it (flat,+ /// `dc:subject`), and as its full path (`lr:hierarchicalSubject`); each name once.+ #[test]+ fn a_keyword_exports_its_name_its_parents_and_its_path() {+ let c = Catalog::new();+ let (flat, paths) = exported(&c, &["travel|Italy|Rome", "Travel|Spain", "beach"]);+ assert_eq!(flat, ["Rome", "Italy", "travel", "Spain", "beach"]);+ assert_eq!(paths, ["travel|Italy|Rome", "Travel|Spain", "beach"]);+ }++ /// A keyword not included on export is left out, path and all; a parent left out (a keyword that+ /// only organizes others) isn't exported as a containing keyword, but its children are.+ #[test]+ fn keywords_left_out_of_export_stay_out() {+ let mut c = Catalog::new();+ let out = KeywordInfo { include_on_export: false, ..KeywordInfo::default() };+ c.apply(Op::SetKeyword { path: "Places".into(), info: Some(out.clone()) }).unwrap();+ c.apply(Op::SetKeyword { path: "draft".into(), info: Some(out) }).unwrap();+ let (flat, paths) = exported(&c, &["Places|Lisbon", "draft"]);+ assert_eq!(flat, ["Lisbon"]);+ assert_eq!(paths, ["Places|Lisbon"]);+ }++ /// Without "export containing keywords" only the keyword's own name goes out flat; synonyms go+ /// out with it unless "export synonyms" is off.+ #[test]+ fn containing_keywords_and_synonyms_follow_their_options() {+ let mut c = Catalog::new();+ let alone = KeywordInfo { export_containing: false, ..with_synonyms(&["Lisboa"]) };+ c.apply(Op::SetKeyword { path: "Places|Lisbon".into(), info: Some(alone) }).unwrap();+ let quiet = KeywordInfo { export_synonyms: false, ..with_synonyms(&["marriage"]) };+ c.apply(Op::SetKeyword { path: "Events|Weddings".into(), info: Some(quiet) }).unwrap();+ let (flat, _) = exported(&c, &["Places|Lisbon", "Events|Weddings"]);+ assert_eq!(flat, ["Lisbon", "Lisboa", "Weddings", "Events"]);+ }+#[test]fn suggestions_rank_co_occurrence_and_prefixes() {let (c, _) = lib(&[&["dog", "park"], &["dog", "park", "ball"], &["dog", "beach"], &["cat"], &["cat"], &["cat"], &["parade"], &["eagle"]]);