feat: Add docsDefault

docx-core/fixtures/hello/word/settings.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:settings xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-    <w:zoom w:percent="100"/>
-    <w:defaultTabStop w:val="709"/>
-    <w:compat>
-        <w:doNotExpandShiftReturn/>
-    </w:compat>
-</w:settings>

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

@@ -0,0 +1,45 @@
+use crate::documents::BuildXML;
+use crate::xml_builder::*;
+
+use super::run_property_default::*;
+
+pub struct DocDefaults {
+    run_property_default: RunPropertyDefault,
+}
+
+impl DocDefaults {
+    pub fn new() -> DocDefaults {
+        let run_property_default = RunPropertyDefault::new();
+        DocDefaults {
+            run_property_default,
+        }
+    }
+}
+
+impl BuildXML for DocDefaults {
+    fn build(&self) -> Vec<u8> {
+        let b = XMLBuilder::new();
+        let run_property_default = self.run_property_default.build();
+        b.open_doc_defaults()
+            .add_child_buffer(&run_property_default)
+            .close()
+            .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use std::str;
+
+    #[test]
+    fn test_build() {
+        let c = DocDefaults::new();
+        let b = c.build();
+        assert_eq!(
+            str::from_utf8(&b).unwrap(),
+            r#"<w:docDefaults><w:rPrDefault /></w:docDefaults>"#
+        );
+    }
+}

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

@@ -0,0 +1,5 @@
+mod doc_defaults;
+mod run_property_default;
+
+pub use doc_defaults::*;
+pub use run_property_default::*;

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

@@ -0,0 +1,31 @@
+use crate::documents::BuildXML;
+use crate::xml_builder::*;
+
+pub struct RunPropertyDefault {}
+
+impl RunPropertyDefault {
+    pub fn new() -> RunPropertyDefault {
+        RunPropertyDefault {}
+    }
+}
+
+impl BuildXML for RunPropertyDefault {
+    fn build(&self) -> Vec<u8> {
+        let b = XMLBuilder::new();
+        b.open_run_property_default().close().build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use std::str;
+
+    #[test]
+    fn test_build() {
+        let c = RunPropertyDefault::new();
+        let b = c.build();
+        assert_eq!(str::from_utf8(&b).unwrap(), r#"<w:rPrDefault />"#);
+    }
+}

docx-core/src/documents/mod.rs

@@ -1,12 +1,15 @@
 mod build_xml;
 mod content_types;
 mod doc_props;
+mod elements;
 mod rels;
 mod xml_document;
 
-use build_xml::*;
+pub(crate) use build_xml::*;
+
 use content_types::*;
 use doc_props::*;
+use elements::*;
 use rels::*;
 
 pub(crate) struct Document {

docx-core/src/xml_builder/core_properties.rs

@@ -1,4 +1,5 @@
 use super::XMLBuilder;
+use super::XmlEvent;
 
 impl XMLBuilder {
     // i.e. <cp:properties xmlns:vt="http://schemas.openxmlformats.org/package/2006/relationships">

docx-core/src/xml_builder/elements/doc_defaults.rs

@@ -0,0 +1,6 @@
+use super::super::XmlEvent;
+use crate::xml_builder::*;
+
+impl XMLBuilder {
+    opened_el!(open_doc_defaults, "w:docDefaults");
+}

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

@@ -0,0 +1,5 @@
+mod doc_defaults;
+mod run_property_default;
+
+pub use doc_defaults::*;
+pub use run_property_default::*;

docx-core/src/xml_builder/elements/run_property_default.rs

@@ -0,0 +1,6 @@
+use super::super::XmlEvent;
+use crate::xml_builder::*;
+
+impl XMLBuilder {
+    opened_el!(open_run_property_default, "w:rPrDefault");
+}

docx-core/src/xml_builder/macros.rs

@@ -1,8 +1,16 @@
 macro_rules! opened_el {
+    ($name: ident, $el_name: expr) => {
+        pub(crate) fn $name(mut self) -> Self {
+            self.writer
+                .write(XmlEvent::start_element($el_name))
+                .expect("should write to buf");
+            self
+        }
+    };
     ($name: ident, $el_name: expr, $attr0: expr) => {
         pub(crate) fn $name(mut self, arg0: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
                 .expect("should write to buf");
             self
         }
@@ -10,7 +18,7 @@ macro_rules! opened_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
                 .expect("should write to buf");
             self
         }
@@ -18,7 +26,7 @@ macro_rules! opened_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
                 .expect("should write to buf");
             self
         }
@@ -26,7 +34,7 @@ macro_rules! opened_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, arg3: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2).attr($attr3, arg3))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2).attr($attr3, arg3))
                 .expect("should write to buf");
             self
         }
@@ -34,7 +42,7 @@ macro_rules! opened_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, arg3: &str, arg4: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2).attr($attr3, arg3).attr($attr4, arg4))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2).attr($attr3, arg3).attr($attr4, arg4))
                 .expect("should write to buf");
             self
         }
@@ -45,7 +53,7 @@ macro_rules! closed_el_with_child {
     ($name: ident, $el_name: expr) => {
         pub(crate) fn $name(mut self, child: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name))
+                .write(XmlEvent::start_element($el_name))
                 .expect("should write to buf");
             self.writer
                 .write(child)
@@ -56,7 +64,7 @@ macro_rules! closed_el_with_child {
     ($name: ident, $el_name: expr, $attr0: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, child: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
                 .expect("should write to buf");
             self.writer
                 .write(child)
@@ -67,7 +75,7 @@ macro_rules! closed_el_with_child {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, child: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
                 .expect("should write to buf");
             self.writer
                 .write(child)
@@ -78,7 +86,7 @@ macro_rules! closed_el_with_child {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, child: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
                 .expect("should write to buf");
             self.writer
                 .write(child)
@@ -92,7 +100,7 @@ macro_rules! closed_el {
     ($name: ident, $el_name: expr, $attr0: expr) => {
         pub(crate) fn $name(mut self, arg0: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
                 .expect("should write to buf");
             self.close()
         }
@@ -100,7 +108,7 @@ macro_rules! closed_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1))
                 .expect("should write to buf");
             self.close()
         }
@@ -108,7 +116,7 @@ macro_rules! closed_el {
     ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
         pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str) -> Self {
             self.writer
-                .write(super::XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
+                .write(XmlEvent::start_element($el_name).attr($attr0, arg0).attr($attr1, arg1).attr($attr2, arg2))
                 .expect("should write to buf");
             self.close()
         }

docx-core/src/xml_builder/mod.rs

@@ -2,12 +2,17 @@
 mod macros;
 mod core_properties;
 mod declaration;
+mod elements;
 mod properties;
 mod relationship;
 
+use std::io::BufReader;
+use std::str;
 use xml::common::XmlVersion;
 use xml::writer::{EmitterConfig, EventWriter, XmlEvent};
 
+use xml::reader::EventReader;
+
 pub struct XMLBuilder {
     writer: EventWriter<Vec<u8>>,
 }
@@ -15,10 +20,11 @@ pub struct XMLBuilder {
 impl XMLBuilder {
     pub(crate) fn new() -> XMLBuilder {
         let buf = Vec::new();
-        let writer = EmitterConfig::new()
+        let mut config = EmitterConfig::new()
             .write_document_declaration(false)
-            .perform_indent(true)
+            .perform_indent(true);
-            .create_writer(buf);
+        config.perform_escaping = false;
+        let writer = config.create_writer(buf);
         XMLBuilder { writer }
     }
 
@@ -44,6 +50,12 @@ impl XMLBuilder {
         self.close()
     }
 
+    pub(crate) fn add_child_buffer(mut self, buf: &[u8]) -> Self {
+        let text = str::from_utf8(buf).unwrap();
+        self.writer.write(text).expect("should write to buf");
+        self
+    }
+
     // Close tag
     pub(crate) fn close(mut self) -> Self {
         self.writer
@@ -67,7 +79,6 @@ impl XMLBuilder {
 mod tests {
 
     use super::*;
-    use std::str;
 
     #[test]
     fn test_open_types() {

docx-core/src/xml_builder/properties.rs

@@ -1,4 +1,5 @@
 use super::XMLBuilder;
+use super::XmlEvent;
 
 impl XMLBuilder {
     // Build Properties element
@@ -45,7 +46,7 @@ mod tests {
     #[test]
     fn test_application() {
         let b = XMLBuilder::new();
-        let r = b.template("Lawgue").build();
+        let r = b.application("Lawgue").build();
         assert_eq!(
             str::from_utf8(&r).unwrap(),
             r#"<Application>Lawgue</Application>"#

docx-core/src/xml_builder/relationship.rs

@@ -1,4 +1,5 @@
 use super::XMLBuilder;
+use super::XmlEvent;
 
 impl XMLBuilder {
     // Build RelationShips element