From 9e81e17a235fe1cf7b975f80bde8e516c01adaf5 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Tue, 17 Mar 2026 10:49:49 -0400 Subject: [PATCH] Can now add translatiions to universal strings. --- src/document/field.rs | 107 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 92 insertions(+), 15 deletions(-) diff --git a/src/document/field.rs b/src/document/field.rs index 77f0203..864ee9d 100644 --- a/src/document/field.rs +++ b/src/document/field.rs @@ -431,19 +431,19 @@ impl Paragraph { Self { data: data } } - fn add_translation(&mut self, string: String, lang: Language) { + fn add_translation(&mut self, lang: Language, text: String) { match self.data.get(&lang) { Some(_) => {} None => { self.data - .insert(lang, ParagraphData::new(string, DataOrigin::Computer)); + .insert(lang, ParagraphData::new(text, DataOrigin::Computer)); } }; } - fn improve_translation(&mut self, string: String, lang: Language) { + fn improve_translation(&mut self, lang: Language, text: String) { self.data - .insert(lang, ParagraphData::new(string, DataOrigin::Human)); + .insert(lang, ParagraphData::new(text, DataOrigin::Human)); } fn get(&self, lang: &Language) -> Option<&String> { @@ -498,7 +498,7 @@ mod paragraphs { Language::from_639_1("ja").unwrap(), ]; let mut paragraph = Paragraph::new(languages[0].clone(), text[0].clone().to_string()); - paragraph.add_translation(text[1].clone().to_string(), languages[1].clone()); + paragraph.add_translation(languages[1].clone(), text[1].clone().to_string()); for i in 0..text.len() { assert_eq!(paragraph.get(&languages[i]).unwrap(), text[i]); } @@ -509,7 +509,7 @@ mod paragraphs { let text = "something"; let lang = Language::from_639_1("en").unwrap(); let mut paragraph = Paragraph::new(lang.clone(), text.to_string()); - paragraph.add_translation("other".to_string(), lang); + paragraph.add_translation(lang, "other".to_string()); assert_eq!(paragraph.get(&lang).unwrap(), text); } @@ -518,7 +518,7 @@ mod paragraphs { let text = "new"; let lang = Language::from_639_1("en").unwrap(); let mut paragraph = Paragraph::new(lang.clone(), "old".to_string()); - paragraph.improve_translation(text.to_string(), lang.clone()); + paragraph.improve_translation(lang.clone(), text.to_string()); assert_eq!(paragraph.get(&lang).unwrap(), text); } @@ -537,7 +537,7 @@ mod paragraphs { let text = "test"; let lang = Language::from_639_1("en").unwrap(); let mut paragraph = Paragraph::new(lang.clone(), text.to_string()); - paragraph.add_translation("テスト".to_string(), Language::from_639_1("ja").unwrap()); + paragraph.add_translation(Language::from_639_1("ja").unwrap(), "テスト".to_string()); let result = paragraph.by_humans(); assert_eq!(result.len(), 1, "got wrong numnber of texts"); assert_eq!(result.get(&lang).unwrap(), text); @@ -551,7 +551,7 @@ mod paragraphs { Language::from_639_1("ja").unwrap(), ]; let mut paragraph = Paragraph::new(languages[0].clone(), text[0].clone().to_string()); - paragraph.improve_translation(text[1].clone().to_string(), languages[1].clone()); + paragraph.improve_translation(languages[1].clone(), text[1].clone().to_string()); let result = paragraph.by_humans(); assert_eq!(result.len(), 2, "got wrong numnber of texts"); for i in 0..text.len() { @@ -565,12 +565,12 @@ mod paragraphs { let lang = Language::from_639_1("en").unwrap(); let mut paragraph = Paragraph::new(lang.clone(), text.clone()); paragraph.add_translation( - Uuid::new_v4().to_string(), Language::from_639_1("ja").unwrap(), + Uuid::new_v4().to_string(), ); paragraph.improve_translation( - Uuid::new_v4().to_string(), Language::from_639_1("de").unwrap(), + Uuid::new_v4().to_string(), ); let (rlang, rtext) = paragraph.get_initial(); assert_eq!(rlang, &lang); @@ -615,20 +615,26 @@ mod paragraphids { #[derive(Clone, Debug)] pub struct MissingTranslation { + id: ParagraphID, needs: Language, has: Language, text: String, } impl MissingTranslation { - fn new(needs: Language, has: Language, text: String) -> Self { + fn new(id: ParagraphID, needs: Language, has: Language, text: String) -> Self { Self { + id: id, needs: needs, has: has, text: text, } } + fn paragraph_id(&self) -> ParagraphID { + self.id.clone() + } + fn needs(&self) -> Language { self.needs.clone() } @@ -648,16 +654,21 @@ mod missing_translations { #[test] fn can_get_mising_translation_information() { + let id = ParagraphID::new(); let langs = [ Language::from_639_1("en").unwrap(), Language::from_639_1("ja").unwrap(), ]; let text = Uuid::new_v4().to_string(); - let missing = MissingTranslation::new(langs[0].clone(), langs[1].clone(), text.clone()); + let missing = + MissingTranslation::new(id.clone(), langs[0].clone(), langs[1].clone(), text.clone()); + assert_eq!(missing.paragraph_id(), id); assert_eq!(missing.needs(), langs[0]); assert_eq!(missing.has(), langs[1]); assert_eq!(missing.text(), text); - let missing2 = MissingTranslation::new(langs[1].clone(), langs[0].clone(), text.clone()); + let missing2 = + MissingTranslation::new(id.clone(), langs[1].clone(), langs[0].clone(), text.clone()); + assert_eq!(missing.paragraph_id(), id); assert_eq!(missing2.needs(), langs[1]); assert_eq!(missing2.has(), langs[0]); assert_eq!(missing2.text(), text); @@ -695,6 +706,7 @@ impl UniversalString { None => { let (ori_lang, text) = paragraph.get_initial(); missing.push(MissingTranslation::new( + id.clone(), lang.clone(), ori_lang.clone(), text.clone(), @@ -742,6 +754,30 @@ impl UniversalString { } self.revisions.push(version); } + + fn add_translation(&mut self, id: ParagraphID, lang: Language, text: String) { + self.paragraphs + .get_mut(&id) + .unwrap() + .add_translation(lang, text); + } + + fn improve_translation(&mut self, id: ParagraphID, lang: Language, text: String) { + self.paragraphs + .get_mut(&id) + .unwrap() + .improve_translation(lang, text); + } + + fn by_humans(&self) -> Vec<(ParagraphID, HashMap)> { + let mut output = Vec::new(); + let latest = self.revisions.iter().last().unwrap(); + for id in latest.iter() { + let para = self.paragraphs.get(id).unwrap(); + output.push((id.clone(), para.by_humans())); + } + output + } } #[cfg(test)] @@ -874,6 +910,7 @@ mod universal_strings { let (elang, edata) = TestData::english(); let (jlang, jdata) = TestData::japanese(); let initial = TestData::to_input(jdata.clone()); + let expected = TestData::to_input(edata.clone()); let mut ustr = UniversalString::new(jlang.clone(), initial.clone()); assert_eq!(ustr.get(&jlang).unwrap(), initial); let err = ustr.get(&elang).unwrap_err(); @@ -889,11 +926,51 @@ mod universal_strings { assert_eq!(data.needs(), elang, "needed language is incorrect"); assert_eq!(data.has(), jlang, "original language is incorrect"); assert!(holder.contains(&data.text())); - holder.remove(&data.text()); + let text = data.text(); + holder.remove(&text); + let index = jdata.iter().position(|x| x == &text).unwrap(); + ustr.add_translation(data.paragraph_id(), elang.clone(), edata[index].clone()); } assert!(holder.is_empty(), "still had {:?}", holder); } _ => unreachable!("got {:?}, should have been needs translation", err), } + assert_eq!(ustr.revision_count(), 0); + assert_eq!(ustr.get(&elang).unwrap(), expected); + let result = ustr.by_humans(); + assert_eq!( + result.len(), + jdata.len(), + "incorrect number of original values" + ); + let mut count = 0; + for (_, lang_result) in result { + assert_eq!(lang_result.len(), 1, "wrong number of returned languages"); + assert_eq!(lang_result.get(&jlang).unwrap(), &jdata[count]); + count += 1; + } + } + + #[test] + fn can_translations_be_improved() { + let (elang, edata) = TestData::english(); + let (jlang, jdata) = TestData::japanese(); + let initial = TestData::to_input(edata.clone()); + let expected = TestData::to_input(jdata.clone()); + let mut ustr = UniversalString::new(elang.clone(), initial.clone()); + for (id, lang_text) in ustr.by_humans().iter() { + let text = lang_text.get(&elang).unwrap(); + let index = edata.iter().position(|x| x == text).unwrap(); + ustr.improve_translation(id.clone(), jlang, jdata[index].clone()); + } + assert_eq!(ustr.revision_count(), 0); + assert_eq!(ustr.get(&jlang).unwrap(), expected); + let mut count = 0; + for (_, lang_result) in ustr.by_humans().iter() { + assert_eq!(lang_result.len(), 2, "wrong number of returned languages"); + assert_eq!(lang_result.get(&elang).unwrap(), &edata[count]); + assert_eq!(lang_result.get(&jlang).unwrap(), &jdata[count]); + count += 1; + } } }