Created the ability to store paragraph data.

src/document/field.rs

@@ -339,25 +339,98 @@ mod fieldtypes {
     }
 }
 
+#[derive(Clone, Debug)]
+enum DataOrigin {
+    Human,
+    Computer,
+}
+
+#[derive(Clone, Debug)]
+struct ParagraphData {
+    string: String,
+    origin: DataOrigin,
+}
+
+impl ParagraphData {
+    fn new(string: String, origin: DataOrigin) -> Self {
+        Self {
+            string: string,
+            origin: origin,
+        }
+    }
+
+    fn get_text(&self) -> &String {
+        &self.string
+    }
+
+    fn by_human(&self) -> bool {
+        match self.origin {
+            DataOrigin::Human => true,
+            DataOrigin::Computer => false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod paragraph_data {
+    use super::*;
+
+    #[test]
+    fn can_be_made_by_humans() {
+        let text = Uuid::new_v4().to_string();
+        let data = ParagraphData::new(text.clone(), DataOrigin::Human);
+        assert!(data.by_human(), "{:?} should have returned true", data);
+    }
+
+    #[test]
+    fn can_be_made_by_computers() {
+        let text = Uuid::new_v4().to_string();
+        let data = ParagraphData::new(text.clone(), DataOrigin::Computer);
+        assert!(!data.by_human(), "{:?} should have returned true", data);
+    }
+}
+
 struct Paragraph {
-    data: HashMap<Language, String>,
+    data: HashMap<Language, ParagraphData>,
 }
 
 impl Paragraph {
     fn new(string: String, lang: Language) -> Self {
         let mut data = HashMap::new();
-        data.insert(lang, string);
-        Self {
-            data: data,
-        }
+        data.insert(lang, ParagraphData::new(string, DataOrigin::Human));
+        Self { data: data }
     }
 
     fn add_translation(&mut self, string: String, lang: Language) {
-        self.data.insert(lang, string);
+        match self.data.get(&lang) {
+            Some(_) => {}
+            None => {
+                self.data
+                    .insert(lang, ParagraphData::new(string, DataOrigin::Computer));
+            }
+        };
+    }
+
+    fn improve_translation(&mut self, string: String, lang: Language) {
+        self.data
+            .insert(lang, ParagraphData::new(string, DataOrigin::Human));
     }
 
     fn get(&self, lang: &Language) -> Option<&String> {
-        self.data.get(lang)
+        match self.data.get(lang) {
+            Some(data) => Some(data.get_text()),
+            None => None,
+        }
+    }
+
+    fn get_original(&self) -> HashMap<Language, String> {
+        let mut output = HashMap::new();
+        for (lang, data) in self.data.iter() {
+            if data.by_human() {
+                output.insert(lang.clone(), data.get_text().clone());
+            }
+        }
+        output
     }
 }
 
@@ -367,7 +440,10 @@ mod paragraphs {
 
     #[test]
     fn does_paragraph_store_language_information() {
-        let languages = [Language::from_639_1("en").unwrap(), Language::from_639_1("ja").unwrap()];
+        let languages = [
+            Language::from_639_1("en").unwrap(),
+            Language::from_639_1("ja").unwrap(),
+        ];
         let data = Uuid::new_v4().to_string();
         for lang in languages.iter() {
             let result = Paragraph::new(data.clone(), lang.clone());
@@ -378,17 +454,74 @@ mod paragraphs {
     #[test]
     fn are_multiple_languages_stored() {
         let text = ["test", "テスト"];
-        let languages = [Language::from_639_1("en").unwrap(), Language::from_639_1("ja").unwrap()];
+        let languages = [
+            Language::from_639_1("en").unwrap(),
+            Language::from_639_1("ja").unwrap(),
+        ];
         let mut paragraph = Paragraph::new(text[0].clone().to_string(), languages[0].clone());
         paragraph.add_translation(text[1].clone().to_string(), languages[1].clone());
         for i in 0..text.len() {
             assert_eq!(paragraph.get(&languages[i]).unwrap(), text[i]);
         }
     }
+
+    #[test]
+    fn does_add_translation_get_ignored_if_it_already_exists() {
+        let text = "something";
+        let lang = Language::from_639_1("en").unwrap();
+        let mut paragraph = Paragraph::new(text.to_string(), lang.clone());
+        paragraph.add_translation("other".to_string(), lang);
+        assert_eq!(paragraph.get(&lang).unwrap(), text);
+    }
+
+    #[test]
+    fn does_improve_translation_replace_existing() {
+        let text = "new";
+        let lang = Language::from_639_1("en").unwrap();
+        let mut paragraph = Paragraph::new("old".to_string(), lang.clone());
+        paragraph.improve_translation(text.to_string(), lang.clone());
+        assert_eq!(paragraph.get(&lang).unwrap(), text);
+    }
+
+    #[test]
+    fn can_determine_original_text() {
+        let text = "something";
+        let lang = Language::from_639_1("en").unwrap();
+        let paragraph = Paragraph::new(text.to_string(), lang.clone());
+        let result = paragraph.get_original();
+        assert_eq!(result.len(), 1, "got wrong numnber of texts");
+        assert_eq!(result.get(&lang).unwrap(), text);
+    }
+
+    #[test]
+    fn add_translation_does_not_count_as_original_text() {
+        let text = "test";
+        let lang = Language::from_639_1("en").unwrap();
+        let mut paragraph = Paragraph::new(text.to_string(), lang.clone());
+        paragraph.add_translation("テスト".to_string(), Language::from_639_1("ja").unwrap());
+        let result = paragraph.get_original();
+        assert_eq!(result.len(), 1, "got wrong numnber of texts");
+        assert_eq!(result.get(&lang).unwrap(), text);
+    }
+
+    #[test]
+    fn impove_translation_does_get_added_as_original() {
+        let text = ["test", "テスト"];
+        let languages = [
+            Language::from_639_1("en").unwrap(),
+            Language::from_639_1("ja").unwrap(),
+        ];
+        let mut paragraph = Paragraph::new(text[0].clone().to_string(), languages[0].clone());
+        paragraph.improve_translation(text[1].clone().to_string(), languages[1].clone());
+        let result = paragraph.get_original();
+        assert_eq!(result.len(), 2, "got wrong numnber of texts");
+        for i in 0..text.len() {
+            assert_eq!(result.get(&languages[i]).unwrap(), text[i]);
+        }
+    }
 }
 
-struct UniversalString {
-}
+struct UniversalString {}
 
 impl UniversalString {
     fn new() -> Self {