fix: exclude MoveFrom ghost text from paragraph.raw_text() (#879)

Add first-class MoveFrom/MoveTo tracked-change support following the
existing Insert/Delete pattern. When text is cut-and-pasted in Word
with Track Changes, both moveFrom (ghost) and moveTo (live) contain
the same text. raw_text() now skips MoveFrom and includes MoveTo,
preventing moved text from appearing twice in output.

Also prevent nested MoveFrom subtrees from flattening into parent
containers (Insert, Delete, Hyperlink, MoveTo) via ignore_element().

Fixes #794

Author: stevenobiajulu

docx-core/src/documents/elements/fit_text.rs

@@ -27,7 +27,9 @@ impl BuildXML for FitText {
         &self,
         stream: crate::xml::writer::EventWriter<W>,
     ) -> crate::xml::writer::Result<crate::xml::writer::EventWriter<W>> {
-        XMLBuilder::from(stream).fit_text(self.val, self.id)?.into_inner()
+        XMLBuilder::from(stream)
+            .fit_text(self.val, self.id)?
+            .into_inner()
     }
 }
 

docx-core/src/documents/elements/mod.rs

@@ -30,8 +30,8 @@ mod doc_id;
 mod doc_var;
 mod drawing;
 mod dstrike;
-mod fld_char;
 mod fit_text;
+mod fld_char;
 mod font;
 mod font_scheme;
 mod footer_reference;
@@ -64,6 +64,8 @@ mod level_text;
 mod line_spacing;
 mod link;
 mod mc_fallback;
+mod move_from;
+mod move_to;
 mod name;
 mod next;
 mod num_pages;
@@ -172,8 +174,8 @@ pub use doc_id::*;
 pub use doc_var::*;
 pub use drawing::*;
 pub use dstrike::*;
-pub use fld_char::*;
 pub use fit_text::*;
+pub use fld_char::*;
 pub use font::*;
 pub use font_scheme::*;
 pub use footer_reference::*;
@@ -206,6 +208,8 @@ pub use level_text::*;
 pub use line_spacing::*;
 pub use link::*;
 pub use mc_fallback::*;
+pub use move_from::*;
+pub use move_to::*;
 pub use name::*;
 pub use next::*;
 pub use num_pages::*;

docx-core/src/documents/elements/move_from.rs

@@ -0,0 +1,133 @@
+use serde::ser::{SerializeStruct, Serializer};
+use serde::Serialize;
+use std::io::Write;
+
+use crate::xml_builder::*;
+use crate::{documents::*, escape};
+
+#[derive(Serialize, Debug, Clone, PartialEq)]
+pub struct MoveFrom {
+    pub author: String,
+    pub date: String,
+    pub children: Vec<MoveFromChild>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum MoveFromChild {
+    Run(Box<Run>),
+    CommentStart(Box<CommentRangeStart>),
+    CommentEnd(CommentRangeEnd),
+}
+
+impl Serialize for MoveFromChild {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            MoveFromChild::Run(ref r) => {
+                let mut t = serializer.serialize_struct("Run", 2)?;
+                t.serialize_field("type", "run")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            MoveFromChild::CommentStart(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeStart", 2)?;
+                t.serialize_field("type", "commentRangeStart")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            MoveFromChild::CommentEnd(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeEnd", 2)?;
+                t.serialize_field("type", "commentRangeEnd")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+        }
+    }
+}
+
+impl Default for MoveFrom {
+    fn default() -> MoveFrom {
+        MoveFrom {
+            author: "unnamed".to_owned(),
+            date: "1970-01-01T00:00:00Z".to_owned(),
+            children: vec![],
+        }
+    }
+}
+
+impl MoveFrom {
+    pub fn new() -> MoveFrom {
+        Self {
+            children: vec![],
+            ..Default::default()
+        }
+    }
+
+    pub fn add_run(mut self, run: Run) -> MoveFrom {
+        self.children.push(MoveFromChild::Run(Box::new(run)));
+        self
+    }
+
+    pub fn add_comment_start(mut self, comment: Comment) -> MoveFrom {
+        self.children.push(MoveFromChild::CommentStart(Box::new(
+            CommentRangeStart::new(comment),
+        )));
+        self
+    }
+
+    pub fn add_comment_end(mut self, id: usize) -> MoveFrom {
+        self.children
+            .push(MoveFromChild::CommentEnd(CommentRangeEnd::new(id)));
+        self
+    }
+
+    pub fn author(mut self, author: impl Into<String>) -> MoveFrom {
+        self.author = escape::escape(&author.into());
+        self
+    }
+
+    pub fn date(mut self, date: impl Into<String>) -> MoveFrom {
+        self.date = date.into();
+        self
+    }
+}
+
+impl HistoryId for MoveFrom {}
+
+impl BuildXML for MoveFrom {
+    fn build_to<W: Write>(
+        &self,
+        stream: crate::xml::writer::EventWriter<W>,
+    ) -> crate::xml::writer::Result<crate::xml::writer::EventWriter<W>> {
+        let id = self.generate();
+        XMLBuilder::from(stream)
+            .open_move_from(&id, &self.author, &self.date)?
+            .apply_each(&self.children, |ch, b| match ch {
+                MoveFromChild::Run(t) => b.add_child(&**t),
+                MoveFromChild::CommentStart(c) => b.add_child(&**c),
+                MoveFromChild::CommentEnd(c) => b.add_child(c),
+            })?
+            .close()?
+            .into_inner()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    #[cfg(test)]
+    use pretty_assertions::assert_eq;
+    use std::str;
+
+    #[test]
+    fn test_move_from_default() {
+        let b = MoveFrom::new().add_run(Run::new()).build();
+        assert_eq!(
+            str::from_utf8(&b).unwrap(),
+            r#"<w:moveFrom w:id="123" w:author="unnamed" w:date="1970-01-01T00:00:00Z"><w:r><w:rPr /></w:r></w:moveFrom>"#
+        );
+    }
+}

docx-core/src/documents/elements/move_to.rs

@@ -0,0 +1,168 @@
+use serde::ser::{SerializeStruct, Serializer};
+use serde::Serialize;
+use std::io::Write;
+
+use super::*;
+
+use crate::documents::{BuildXML, HistoryId, Run};
+use crate::{escape, xml_builder::*};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum MoveToChild {
+    Run(Box<Run>),
+    Delete(Delete),
+    CommentStart(Box<CommentRangeStart>),
+    CommentEnd(CommentRangeEnd),
+}
+
+impl BuildXML for MoveToChild {
+    fn build_to<W: Write>(
+        &self,
+        stream: crate::xml::writer::EventWriter<W>,
+    ) -> crate::xml::writer::Result<crate::xml::writer::EventWriter<W>> {
+        match self {
+            MoveToChild::Run(v) => v.build_to(stream),
+            MoveToChild::Delete(v) => v.build_to(stream),
+            MoveToChild::CommentStart(v) => v.build_to(stream),
+            MoveToChild::CommentEnd(v) => v.build_to(stream),
+        }
+    }
+}
+
+impl Serialize for MoveToChild {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            MoveToChild::Run(ref r) => {
+                let mut t = serializer.serialize_struct("Run", 2)?;
+                t.serialize_field("type", "run")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            MoveToChild::Delete(ref r) => {
+                let mut t = serializer.serialize_struct("Delete", 2)?;
+                t.serialize_field("type", "delete")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            MoveToChild::CommentStart(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeStart", 2)?;
+                t.serialize_field("type", "commentRangeStart")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            MoveToChild::CommentEnd(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeEnd", 2)?;
+                t.serialize_field("type", "commentRangeEnd")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+        }
+    }
+}
+
+#[derive(Serialize, Debug, Clone, PartialEq)]
+pub struct MoveTo {
+    pub children: Vec<MoveToChild>,
+    pub author: String,
+    pub date: String,
+}
+
+impl Default for MoveTo {
+    fn default() -> MoveTo {
+        MoveTo {
+            author: "unnamed".to_owned(),
+            date: "1970-01-01T00:00:00Z".to_owned(),
+            children: vec![],
+        }
+    }
+}
+
+impl MoveTo {
+    pub fn new(run: Run) -> MoveTo {
+        Self {
+            children: vec![MoveToChild::Run(Box::new(run))],
+            ..Default::default()
+        }
+    }
+
+    pub fn new_with_empty() -> MoveTo {
+        Self {
+            ..Default::default()
+        }
+    }
+
+    pub fn add_run(mut self, run: Run) -> MoveTo {
+        self.children.push(MoveToChild::Run(Box::new(run)));
+        self
+    }
+
+    pub fn add_delete(mut self, del: Delete) -> MoveTo {
+        self.children.push(MoveToChild::Delete(del));
+        self
+    }
+
+    pub fn add_child(mut self, c: MoveToChild) -> MoveTo {
+        self.children.push(c);
+        self
+    }
+
+    pub fn add_comment_start(mut self, comment: Comment) -> Self {
+        self.children
+            .push(MoveToChild::CommentStart(Box::new(CommentRangeStart::new(
+                comment,
+            ))));
+        self
+    }
+
+    pub fn add_comment_end(mut self, id: usize) -> Self {
+        self.children
+            .push(MoveToChild::CommentEnd(CommentRangeEnd::new(id)));
+        self
+    }
+
+    pub fn author(mut self, author: impl Into<String>) -> MoveTo {
+        self.author = escape::escape(&author.into());
+        self
+    }
+
+    pub fn date(mut self, date: impl Into<String>) -> MoveTo {
+        self.date = date.into();
+        self
+    }
+}
+
+impl HistoryId for MoveTo {}
+
+impl BuildXML for MoveTo {
+    fn build_to<W: Write>(
+        &self,
+        stream: crate::xml::writer::EventWriter<W>,
+    ) -> crate::xml::writer::Result<crate::xml::writer::EventWriter<W>> {
+        XMLBuilder::from(stream)
+            .open_move_to(&self.generate(), &self.author, &self.date)?
+            .add_children(&self.children)?
+            .close()?
+            .into_inner()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    #[cfg(test)]
+    use pretty_assertions::assert_eq;
+    use std::str;
+
+    #[test]
+    fn test_move_to_default() {
+        let b = MoveTo::new(Run::new()).build();
+        assert_eq!(
+            str::from_utf8(&b).unwrap(),
+            r#"<w:moveTo w:id="123" w:author="unnamed" w:date="1970-01-01T00:00:00Z"><w:r><w:rPr /></w:r></w:moveTo>"#
+        );
+    }
+}