feat: Support pprchange (#402)

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

@@ -59,7 +59,7 @@ mod tests {
             );
         assert_eq!(
             serde_json::to_string(&graphic).unwrap(),
-            r#"{"children":[{"dataType":"wpShape","children":[{"type":"shape","data":{"children":[{"type":"textbox","data":{"children":[{"children":[{"type":"paragraph","data":{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"pattern1"}}]}}],"property":{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":null,"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null},"hasNumbering":false}}],"has_numbering":false}],"hasNumbering":false}}]}}]}]}"#,
+            r#"{"children":[{"dataType":"wpShape","children":[{"type":"shape","data":{"children":[{"type":"textbox","data":{"children":[{"children":[{"type":"paragraph","data":{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"pattern1"}}]}}],"property":{"runProperty":{},"tabs":[]},"hasNumbering":false}}],"has_numbering":false}],"hasNumbering":false}}]}}]}]}"#,
         );
     }
 }

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

@@ -90,7 +90,7 @@ mod tests {
             .num_style_link("style1");
         assert_eq!(
             serde_json::to_string(&c).unwrap(),
-            r#"{"id":0,"styleLink":null,"numStyleLink":"style1","levels":[{"level":1,"start":1,"format":"decimal","text":"%4.","jc":"left","paragraphProperty":{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":null,"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null},"runProperty":{},"suffix":"tab","pstyle":null,"levelRestart":null}]}"#,
+            r#"{"id":0,"styleLink":null,"numStyleLink":"style1","levels":[{"level":1,"start":1,"format":"decimal","text":"%4.","jc":"left","paragraphProperty":{"runProperty":{},"tabs":[]},"runProperty":{},"suffix":"tab","pstyle":null,"levelRestart":null}]}"#,
         );
     }
 }

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

@@ -58,6 +58,7 @@ mod page_margin;
 mod page_size;
 mod paragraph;
 mod paragraph_property;
+mod paragraph_property_change;
 mod paragraph_style;
 mod pic;
 mod q_format;
@@ -167,6 +168,7 @@ pub use page_margin::*;
 pub use page_size::*;
 pub use paragraph::*;
 pub use paragraph_property::*;
+pub use paragraph_property_change::*;
 pub use paragraph_style::*;
 pub use pic::*;
 pub use q_format::*;

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

@@ -424,7 +424,7 @@ mod tests {
         let p = Paragraph::new().add_run(run);
         assert_eq!(
             serde_json::to_string(&p).unwrap(),
-            r#"{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"property":{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":null,"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null},"hasNumbering":false}"#,
+            r#"{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"property":{"runProperty":{},"tabs":[]},"hasNumbering":false}"#,
         );
     }
 
@@ -435,7 +435,7 @@ mod tests {
         let p = Paragraph::new().add_insert(ins);
         assert_eq!(
             serde_json::to_string(&p).unwrap(),
-            r#"{"id":"12345678","children":[{"type":"insert","data":{"children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"author":"unnamed","date":"1970-01-01T00:00:00Z"}}],"property":{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":null,"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null},"hasNumbering":false}"#
+            r#"{"id":"12345678","children":[{"type":"insert","data":{"children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"author":"unnamed","date":"1970-01-01T00:00:00Z"}}],"property":{"runProperty":{},"tabs":[]},"hasNumbering":false}"#
         );
     }
 

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

@@ -9,19 +9,32 @@ use crate::xml_builder::*;
 #[serde(rename_all = "camelCase")]
 pub struct ParagraphProperty {
     pub run_property: RunProperty,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub style: Option<ParagraphStyle>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub numbering_property: Option<NumberingProperty>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub alignment: Option<Justification>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub indent: Option<Indent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub line_spacing: Option<LineSpacing>,
-    pub keep_next: bool,
-    pub keep_lines: bool,
-    pub page_break_before: bool,
-    pub window_control: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keep_next: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keep_lines: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page_break_before: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_control: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub outline_lvl: Option<OutlineLvl>,
     pub tabs: Vec<Tab>,
     // read only
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) div_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub paragraph_property_change: Option<ParagraphPropertyChange>,
 }
 
 // 17.3.1.26
@@ -66,12 +79,12 @@ impl ParagraphProperty {
     }
 
     pub fn keep_next(mut self, v: bool) -> Self {
-        self.keep_next = v;
+        self.keep_next = Some(v);
         self
     }
 
     pub fn keep_lines(mut self, v: bool) -> Self {
-        self.keep_lines = v;
+        self.keep_lines = Some(v);
         self
     }
 
@@ -84,12 +97,12 @@ impl ParagraphProperty {
     }
 
     pub fn page_break_before(mut self, v: bool) -> Self {
-        self.page_break_before = v;
+        self.page_break_before = Some(v);
         self
     }
 
     pub fn window_control(mut self, v: bool) -> Self {
-        self.window_control = v;
+        self.window_control = Some(v);
         self
     }
 
@@ -98,6 +111,11 @@ impl ParagraphProperty {
         self
     }
 
+    pub fn paragraph_property_change(mut self, p: ParagraphPropertyChange) -> Self {
+        self.paragraph_property_change = Some(p);
+        self
+    }
+
     pub(crate) fn hanging_chars(mut self, chars: i32) -> Self {
         if let Some(indent) = self.indent {
             self.indent = Some(indent.hanging_chars(chars));
@@ -113,43 +131,62 @@ impl ParagraphProperty {
     }
 }
 
-impl BuildXML for ParagraphProperty {
-    fn build(&self) -> Vec<u8> {
+fn inner_build(p: &ParagraphProperty) -> Vec<u8> {
     let mut b = XMLBuilder::new()
         .open_paragraph_property()
-            .add_child(&self.run_property)
-            .add_optional_child(&self.style)
-            .add_optional_child(&self.numbering_property)
-            .add_optional_child(&self.alignment)
-            .add_optional_child(&self.indent)
-            .add_optional_child(&self.line_spacing)
-            .add_optional_child(&self.outline_lvl);
+        .add_child(&p.run_property)
+        .add_optional_child(&p.style)
+        .add_optional_child(&p.numbering_property)
+        .add_optional_child(&p.alignment)
+        .add_optional_child(&p.indent)
+        .add_optional_child(&p.line_spacing)
+        .add_optional_child(&p.outline_lvl)
+        .add_optional_child(&p.paragraph_property_change);
 
-        if self.keep_next {
+    if let Some(v) = p.keep_next {
+        if v {
             b = b.keep_next()
         }
+    }
 
-        if self.keep_lines {
+    if let Some(v) = p.keep_lines {
+        if v {
             b = b.keep_lines()
         }
+    }
 
-        if self.page_break_before {
+    if let Some(v) = p.page_break_before {
+        if v {
             b = b.page_break_before()
         }
-
-        if self.window_control {
-            b = b.window_control()
     }
 
-        if !self.tabs.is_empty() {
+    if let Some(v) = p.window_control {
+        if v {
+            b = b.window_control()
+        }
+    }
+
+    if !p.tabs.is_empty() {
         b = b.open_tabs();
-            for t in self.tabs.iter() {
+        for t in p.tabs.iter() {
             b = b.tab(t.val, t.leader, t.pos);
         }
         b = b.close();
     }
 
     b.close().build()
+}
+
+impl BuildXML for ParagraphProperty {
+    fn build(&self) -> Vec<u8> {
+        inner_build(self)
+    }
+}
+
+impl BuildXML for Box<ParagraphProperty> {
+    fn build(&self) -> Vec<u8> {
+        inner_build(self)
     }
 }
 
@@ -216,7 +253,7 @@ mod tests {
         let b = c.indent(Some(20), Some(SpecialIndentType::FirstLine(10)), None, None);
         assert_eq!(
             serde_json::to_string(&b).unwrap(),
-            r#"{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":{"start":20,"startChars":null,"end":null,"specialIndent":{"type":"firstLine","val":10},"hangingChars":null,"firstLineChars":null},"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null}"#
+            r#"{"runProperty":{},"indent":{"start":20,"startChars":null,"end":null,"specialIndent":{"type":"firstLine","val":10},"hangingChars":null,"firstLineChars":null},"tabs":[]}"#
         );
     }
 

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

@@ -0,0 +1,78 @@
+use serde::Serialize;
+
+use crate::documents::*;
+use crate::xml_builder::*;
+
+#[derive(Serialize, Debug, Clone, PartialEq)]
+pub struct ParagraphPropertyChange {
+    pub author: String,
+    pub date: String,
+    pub property: Box<ParagraphProperty>,
+}
+
+impl Default for ParagraphPropertyChange {
+    fn default() -> ParagraphPropertyChange {
+        Self {
+            author: "unnamed".to_owned(),
+            date: "1970-01-01T00:00:00Z".to_owned(),
+            property: Box::new(ParagraphProperty::default()),
+        }
+    }
+}
+
+impl ParagraphPropertyChange {
+    pub fn new() -> ParagraphPropertyChange {
+        Self {
+            ..Default::default()
+        }
+    }
+
+    pub fn property(mut self, p: ParagraphProperty) -> ParagraphPropertyChange {
+        self.property = Box::new(p);
+        self
+    }
+
+    pub fn author(mut self, author: impl Into<String>) -> ParagraphPropertyChange {
+        self.author = author.into();
+        self
+    }
+
+    pub fn date(mut self, date: impl Into<String>) -> ParagraphPropertyChange {
+        self.date = date.into();
+        self
+    }
+}
+
+impl ParagraphPropertyChangeId for ParagraphPropertyChange {}
+
+impl BuildXML for ParagraphPropertyChange {
+    #[allow(clippy::needless_borrow)]
+    fn build(&self) -> Vec<u8> {
+        let id = self.generate();
+        XMLBuilder::new()
+            .open_paragraph_property_change(&id, &self.author, &self.date)
+            .add_child(&self.property)
+            .close()
+            .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    #[cfg(test)]
+    use pretty_assertions::assert_eq;
+    use std::str;
+
+    #[test]
+    fn test_ppr_change_default() {
+        let b = ParagraphPropertyChange::new()
+            .property(ParagraphProperty::new())
+            .build();
+        assert_eq!(
+            str::from_utf8(&b).unwrap(),
+            r#"<w:pPrChange w:id="123" w:author="unnamed" w:date="1970-01-01T00:00:00Z"><w:pPr><w:rPr /></w:pPr></w:pPrChange>"#
+        );
+    }
+}

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

@@ -185,7 +185,7 @@ mod tests {
             .grid_span(2);
         assert_eq!(
             serde_json::to_string(&c).unwrap(),
-            r#"{"children":[{"type":"paragraph","data":{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"property":{"runProperty":{},"style":null,"numberingProperty":null,"alignment":null,"indent":null,"lineSpacing":null,"keepNext":false,"keepLines":false,"pageBreakBefore":false,"windowControl":false,"outlineLvl":null,"tabs":[],"divId":null},"hasNumbering":false}}],"property":{"width":null,"borders":null,"gridSpan":2,"verticalMerge":null,"verticalAlign":null,"textDirection":null,"shading":null},"hasNumbering":false}"#,
+            r#"{"children":[{"type":"paragraph","data":{"id":"12345678","children":[{"type":"run","data":{"runProperty":{},"children":[{"type":"text","data":{"preserveSpace":true,"text":"Hello"}}]}}],"property":{"runProperty":{},"tabs":[]},"hasNumbering":false}}],"property":{"width":null,"borders":null,"gridSpan":2,"verticalMerge":null,"verticalAlign":null,"textDirection":null,"shading":null},"hasNumbering":false}"#,
         );
     }
 }

docx-core/src/documents/mod.rs

@@ -20,6 +20,7 @@ mod header_id;
 mod history_id;
 mod numberings;
 mod paragraph_id;
+mod paragraph_property_change_id;
 mod pic_id;
 mod preset_styles;
 mod rels;
@@ -35,6 +36,7 @@ mod xml_docx;
 pub(crate) use build_xml::BuildXML;
 pub(crate) use history_id::HistoryId;
 pub(crate) use paragraph_id::*;
+pub(crate) use paragraph_property_change_id::ParagraphPropertyChangeId;
 pub(crate) use pic_id::*;
 
 pub use bookmark_id::*;

docx-core/src/documents/paragraph_property_change_id.rs

@@ -0,0 +1,22 @@
+#[cfg(not(test))]
+use std::sync::atomic::AtomicUsize;
+#[cfg(not(test))]
+static HISTORY_ID: AtomicUsize = AtomicUsize::new(0);
+
+#[cfg(not(test))]
+pub trait ParagraphPropertyChangeId {
+    fn generate(&self) -> String {
+        use std::sync::atomic::Ordering;
+
+        let id = HISTORY_ID.load(Ordering::Relaxed);
+        HISTORY_ID.store(id + 1, Ordering::Relaxed);
+        format!("{}", id)
+    }
+}
+
+#[cfg(test)]
+pub trait ParagraphPropertyChangeId {
+    fn generate(&self) -> &str {
+        "123"
+    }
+}

docx-core/src/reader/mod.rs

@@ -29,6 +29,7 @@ mod numbering_property;
 mod numberings;
 mod paragraph;
 mod paragraph_property;
+mod paragraph_property_change;
 mod read_zip;
 mod rels;
 mod run;

docx-core/src/reader/paragraph.rs

@@ -25,8 +25,6 @@ impl ElementReader for Paragraph {
                 }) => {
                     let e = XMLElement::from_str(&name.local_name).unwrap();
 
-                    ignore::ignore_element(e.clone(), XMLElement::ParagraphPropertyChange, r);
-
                     match e {
                         XMLElement::Run => {
                             let run = Run::read(r, attrs)?;

docx-core/src/reader/paragraph_property.rs

@@ -23,8 +23,6 @@ impl ElementReader for ParagraphProperty {
                 }) => {
                     let e = XMLElement::from_str(&name.local_name).unwrap();
 
-                    ignore::ignore_element(e.clone(), XMLElement::ParagraphPropertyChange, r);
-
                     match e {
                         XMLElement::Indent => {
                             let (start, end, special, start_chars, hanging_chars, first_line_chars) =
@@ -85,16 +83,21 @@ impl ElementReader for ParagraphProperty {
                             continue;
                         }
                         XMLElement::KeepNext => {
-                            p.keep_next = true;
+                            p.keep_next = Some(true);
                         }
                         XMLElement::KeepLines => {
-                            p.keep_lines = true;
+                            p.keep_lines = Some(true);
                         }
                         XMLElement::PageBreakBefore => {
-                            p.page_break_before = true;
+                            p.page_break_before = Some(true);
                         }
                         XMLElement::WindowControl => {
-                            p.window_control = true;
+                            p.window_control = Some(true);
+                        }
+                        XMLElement::ParagraphPropertyChange => {
+                            if let Ok(ppr_change) = ParagraphPropertyChange::read(r, attrs) {
+                                p.paragraph_property_change = Some(ppr_change);
+                            }
                         }
                         _ => {}
                     }

docx-core/src/reader/paragraph_property_change.rs

@@ -0,0 +1,46 @@
+use std::io::Read;
+use std::str::FromStr;
+
+use xml::attribute::OwnedAttribute;
+use xml::reader::{EventReader, XmlEvent};
+
+use super::*;
+
+impl ElementReader for ParagraphPropertyChange {
+    fn read<R: Read>(
+        r: &mut EventReader<R>,
+        attrs: &[OwnedAttribute],
+    ) -> Result<Self, ReaderError> {
+        let mut pc = ParagraphPropertyChange::new();
+        for attr in attrs {
+            let local_name = &attr.name.local_name;
+            if local_name == "author" {
+                pc = pc.author(&attr.value);
+            } else if local_name == "date" {
+                pc = pc.date(&attr.value);
+            }
+        }
+        loop {
+            let e = r.next();
+            match e {
+                Ok(XmlEvent::StartElement { name, .. }) => {
+                    let e = XMLElement::from_str(&name.local_name)
+                        .expect("should convert to XMLElement");
+                    if let XMLElement::ParagraphProperty = e {
+                        if let Ok(p) = ParagraphProperty::read(r, attrs) {
+                            pc = pc.property(p);
+                        }
+                    }
+                }
+                Ok(XmlEvent::EndElement { name, .. }) => {
+                    let e = XMLElement::from_str(&name.local_name).unwrap();
+                    if e == XMLElement::ParagraphPropertyChange {
+                        return Ok(pc);
+                    }
+                }
+                Err(_) => return Err(ReaderError::XMLReadError),
+                _ => {}
+            }
+        }
+    }
+}

docx-core/src/reader/structured_data_tag.rs

@@ -22,8 +22,6 @@ impl ElementReader for StructuredDataTag {
                 }) => {
                     let e = XMLElement::from_str(&name.local_name).unwrap();
 
-                    ignore::ignore_element(e.clone(), XMLElement::ParagraphPropertyChange, r);
-
                     match e {
                         XMLElement::Paragraph => {
                             if let Ok(p) = Paragraph::read(r, &attributes) {

docx-core/src/xml_builder/elements.rs

@@ -366,6 +366,7 @@ impl XMLBuilder {
 
     open!(open_insert, "w:ins", "w:id", "w:author", "w:date");
     open!(open_delete, "w:del", "w:id", "w:author", "w:date");
+    open!(open_paragraph_property_change, "w:pPrChange", "w:id", "w:author", "w:date");
 
     closed!(bookmark_start, "w:bookmarkStart", "w:id", "w:name");
     closed!(bookmark_end, "w:bookmarkEnd", "w:id");