Completed basic functions of universal string.

src/document/field.rs

@@ -584,39 +584,23 @@ struct UniversalString {
 }
 
 impl UniversalString {
-    fn split_string(text: String) -> Vec<String> {
+    fn new(lang: Language, text: String) -> Self {
-        let holder = text.as_str();
+        let mut output = Self {
-        let mut output = Vec::new();
+            paragraphs: HashMap::new(),
-        for item in holder.split("\u{2029}") {
+            revisions: Vec::new(),
-            output.push(item.to_string());
+        };
-        }
+        output.update(lang, text);
         output
     }
 
-    fn new(lang: Language, text: String) -> Self {
+    fn get(&self, lang: &Language) -> Option<String> {
-        let input = Self::split_string(text);
+        let latest = self.revisions.len() - 1;
-        let mut paragraphs = HashMap::new();
+        self.get_revision(latest, lang)
-        let mut revision = Vec::new();
-        for paragraph in input {
-            let mut id = Uuid::new_v4();
-            while paragraphs.contains_key(&id) {
-                id = Uuid::new_v4();
-            }
-            if paragraph != "" {
-                revision.push(id.clone());
-                paragraphs.insert(id, Paragraph::new(lang.clone(), paragraph.to_string()));
-            }
-        }
-        Self {
-            paragraphs: paragraphs,
-            revisions: vec![revision],
-        }
     }
 
-    fn get(&self, lang: &Language) -> Option<String> {
+    fn get_revision(&self, rev_num: usize, lang: &Language) -> Option<String> {
-        let latest = self.revisions.iter().last().unwrap();
         let mut output = "".to_string();
-        for id in latest.iter() {
+        for id in self.revisions[rev_num].iter() {
             let paragraph = self.paragraphs.get(id).unwrap();
             let text = paragraph.get(lang).unwrap();
             output += text;
@@ -630,14 +614,12 @@ impl UniversalString {
     }
 
     fn update(&mut self, lang: Language, text: String) {
-        let input = Self::split_string(text);
         let mut version = Vec::new();
-        for paragraph in input {
+        for paragraph in text.as_str().split("\u{2029}") {
             if paragraph != "" {
                 let mut id = Uuid::nil();
                 for (key, value) in self.paragraphs.iter() {
                     if &paragraph == value.get(&lang).unwrap() {
-                        println!("--- Got here ---");
                         id = key.clone();
                         break;
                     }
@@ -736,5 +718,50 @@ mod universal_strings {
         assert_eq!(ustr.get(&lang).unwrap(), expected);
         assert_eq!(ustr.revision_count(), 1);
         assert_eq!(ustr.paragraphs.len(), data.len(), "{:?}", ustr);
+        assert_eq!(ustr.get_revision(0, &lang).unwrap(), initial);
+    }
+
+    #[test]
+    fn can_a_paragraph_be_replaced() {
+        let (lang, mut data) = TestData::english();
+        let initial = TestData::to_input(data.clone());
+        let mut ustr = UniversalString::new(lang.clone(), initial.clone());
+        let position = random_range(..data.len());
+        data[position] = "replaced".to_string();
+        let expected = TestData::to_input(data.clone());
+        ustr.update(lang.clone(), expected.clone());
+        assert_eq!(ustr.get(&lang).unwrap(), expected);
+        assert_eq!(ustr.revision_count(), 1);
+        assert_eq!(ustr.paragraphs.len(), (data.len() + 1), "{:?}", ustr);
+        assert_eq!(ustr.get_revision(0, &lang).unwrap(), initial);
+    }
+
+    #[test]
+    fn does_not_store_duplicate_data() {
+        let lang = Language::from_639_1("en").unwrap();
+        let mut data = Vec::new();
+        for _ in 0..3 {
+            data.push("same".to_string());
+        }
+        let initial = TestData::to_input(data.clone());
+        let mut ustr = UniversalString::new(lang.clone(), initial.clone());
+        assert_eq!(ustr.get(&lang).unwrap(), initial);
+        assert_eq!(ustr.paragraphs.len(), 1, "{:?}", ustr);
+    }
+
+    #[test]
+    fn can_text_be_removed() {
+        let (lang, mut data) = TestData::english();
+        let expected_paragraphs = data.len();
+        let initial = TestData::to_input(data.clone());
+        let mut ustr = UniversalString::new(lang.clone(), initial.clone());
+        let position = random_range(..data.len());
+        data.remove(position);
+        let expected = TestData::to_input(data.clone());
+        ustr.update(lang.clone(), expected.clone());
+        assert_eq!(ustr.get(&lang).unwrap(), expected);
+        assert_eq!(ustr.revision_count(), 1);
+        assert_eq!(ustr.paragraphs.len(), expected_paragraphs, "{:?}", ustr);
+        assert_eq!(ustr.get_revision(0, &lang).unwrap(), initial);
     }
 }