Can now add translatiions to universal strings.

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<Language, String>)> {
+        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;
+        }
     }
 }