for now support section (#850)

* impl: section

* fix: section interface

* fix: doc error

Author: bokuweb

docx-core/examples/section.rs

@@ -0,0 +1,17 @@
+use docx_rs::*;
+
+pub fn main() -> Result<(), DocxError> {
+    let path = std::path::Path::new("./output/examples/section.docx");
+    let file = std::fs::File::create(path).unwrap();
+    let section = Section::new()
+        .add_paragraph(Paragraph::new().add_run(Run::new().add_text("Hello")))
+        .page_size(PageSize::new().size(10000, 10000))
+        .page_orient(PageOrientationType::Landscape);
+
+    Docx::new()
+        .add_section(section)
+        .add_paragraph(Paragraph::new().add_run(Run::new().add_text("World")))
+        .build()
+        .pack(file)?;
+    Ok(())
+}

docx-core/src/documents/document.rs

@@ -24,6 +24,7 @@ pub enum DocumentChild {
     CommentEnd(CommentRangeEnd),
     StructuredDataTag(Box<StructuredDataTag>),
     TableOfContents(Box<TableOfContents>),
+    Section(Box<Section>),
 }
 
 impl Serialize for DocumentChild {
@@ -80,6 +81,12 @@ impl Serialize for DocumentChild {
                 t.serialize_field("data", r)?;
                 t.end()
             }
+            DocumentChild::Section(ref r) => {
+                let mut t = serializer.serialize_struct("Section", 2)?;
+                t.serialize_field("type", "section")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
         }
     }
 }
@@ -140,6 +147,11 @@ impl Document {
         self
     }
 
+    pub fn add_section(mut self, sec: Section) -> Self {
+        self.children.push(DocumentChild::Section(Box::new(sec)));
+        self
+    }
+
     pub fn title_pg(mut self) -> Self {
         self.section_property = self.section_property.title_pg();
         self
@@ -255,6 +267,7 @@ impl BuildXML for DocumentChild {
             DocumentChild::CommentEnd(v) => v.build_to(stream),
             DocumentChild::StructuredDataTag(v) => v.build_to(stream),
             DocumentChild::TableOfContents(v) => v.build_to(stream),
+            DocumentChild::Section(v) => v.build_to(stream),
         }
     }
 }

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

@@ -1,26 +1,193 @@
 use super::*;
+// use crate::create_header_rid;
 use crate::documents::BuildXML;
+use crate::types::*;
 use crate::xml_builder::*;
+use crate::{delegate_getters_to_field, delegate_to_field, Footer, Header};
+use serde::ser::{SerializeStruct, Serializer};
+use serde::Serialize;
 use std::io::Write;
 
-use serde::Serialize;
+#[derive(Debug, Clone, PartialEq)]
+pub enum SectionChild {
+    Paragraph(Box<Paragraph>),
+    Table(Box<Table>),
+    BookmarkStart(BookmarkStart),
+    BookmarkEnd(BookmarkEnd),
+    CommentStart(Box<CommentRangeStart>),
+    CommentEnd(CommentRangeEnd),
+    StructuredDataTag(Box<StructuredDataTag>),
+    TableOfContents(Box<TableOfContents>),
+}
+
+impl Serialize for SectionChild {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            SectionChild::Paragraph(ref p) => {
+                let mut t = serializer.serialize_struct("Paragraph", 2)?;
+                t.serialize_field("type", "paragraph")?;
+                t.serialize_field("data", p)?;
+                t.end()
+            }
+            SectionChild::Table(ref c) => {
+                let mut t = serializer.serialize_struct("Table", 2)?;
+                t.serialize_field("type", "table")?;
+                t.serialize_field("data", c)?;
+                t.end()
+            }
+            SectionChild::BookmarkStart(ref c) => {
+                let mut t = serializer.serialize_struct("BookmarkStart", 2)?;
+                t.serialize_field("type", "bookmarkStart")?;
+                t.serialize_field("data", c)?;
+                t.end()
+            }
+            SectionChild::BookmarkEnd(ref c) => {
+                let mut t = serializer.serialize_struct("BookmarkEnd", 2)?;
+                t.serialize_field("type", "bookmarkEnd")?;
+                t.serialize_field("data", c)?;
+                t.end()
+            }
+            SectionChild::CommentStart(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeStart", 2)?;
+                t.serialize_field("type", "commentRangeStart")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            SectionChild::CommentEnd(ref r) => {
+                let mut t = serializer.serialize_struct("CommentRangeEnd", 2)?;
+                t.serialize_field("type", "commentRangeEnd")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            SectionChild::StructuredDataTag(ref r) => {
+                let mut t = serializer.serialize_struct("StructuredDataTag", 2)?;
+                t.serialize_field("type", "structuredDataTag")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+            SectionChild::TableOfContents(ref r) => {
+                let mut t = serializer.serialize_struct("TableOfContents", 2)?;
+                t.serialize_field("type", "tableOfContents")?;
+                t.serialize_field("data", r)?;
+                t.end()
+            }
+        }
+    }
+}
+
+impl BuildXML for SectionChild {
+    fn build_to<W: Write>(
+        &self,
+        stream: xml::writer::EventWriter<W>,
+    ) -> xml::writer::Result<xml::writer::EventWriter<W>> {
+        match self {
+            SectionChild::Paragraph(v) => v.build_to(stream),
+            SectionChild::Table(v) => v.build_to(stream),
+            SectionChild::BookmarkStart(v) => v.build_to(stream),
+            SectionChild::BookmarkEnd(v) => v.build_to(stream),
+            SectionChild::CommentStart(v) => v.build_to(stream),
+            SectionChild::CommentEnd(v) => v.build_to(stream),
+            SectionChild::StructuredDataTag(v) => v.build_to(stream),
+            SectionChild::TableOfContents(v) => v.build_to(stream),
+        }
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Section {
     property: SectionProperty,
+    children: Vec<SectionChild>,
+    pub(crate) has_numbering: bool,
 }
 
 impl Section {
     pub fn new() -> Section {
         Default::default()
     }
+
+    delegate_to_field! {
+        property =>
+        page_size(size: PageSize) -> Self,
+        page_margin(margin: PageMargin) -> Self,
+        page_orient(o: PageOrientationType) -> Self,
+        doc_grid(doc_grid: DocGrid) -> Self,
+        text_direction(direction: String) -> Self,
+        title_pg() -> Self,
+        // header(h: Header, rid: &str) -> Self,
+        // first_header(h: Header, rid: &str) -> Self,
+        // first_header_without_title_pg(h: Header, rid: &str) -> Self,
+        // even_header(h: Header, rid: &str) -> Self,
+        // footer(h: Footer, rid: &str) -> Self,
+        // first_footer(h: Footer, rid: &str) -> Self,
+        // first_footer_without_title_pg(h: Footer, rid: &str) -> Self,
+        // even_footer(h: Footer, rid: &str) -> Self,
+        page_num_type(h: PageNumType) -> Self,
+    }
+
+    delegate_getters_to_field! {
+        property =>
+        get_headers() -> Vec<&Header>,
+        get_footers() -> Vec<&Footer>,
+    }
+
+    pub fn add_paragraph(mut self, p: Paragraph) -> Self {
+        if p.has_numbering {
+            self.has_numbering = true
+        }
+        self.children.push(SectionChild::Paragraph(Box::new(p)));
+        self
+    }
+
+    pub fn add_table(mut self, t: Table) -> Self {
+        if t.has_numbering {
+            self.has_numbering = true
+        }
+        self.children.push(SectionChild::Table(Box::new(t)));
+        self
+    }
+
+    pub fn add_bookmark_start(mut self, id: usize, name: impl Into<String>) -> Self {
+        self.children
+            .push(SectionChild::BookmarkStart(BookmarkStart::new(id, name)));
+        self
+    }
+
+    pub fn add_bookmark_end(mut self, id: usize) -> Self {
+        self.children
+            .push(SectionChild::BookmarkEnd(BookmarkEnd::new(id)));
+        self
+    }
+
+    pub fn add_comment_start(mut self, comment: Comment) -> Self {
+        self.children.push(SectionChild::CommentStart(Box::new(
+            CommentRangeStart::new(comment),
+        )));
+        self
+    }
+
+    pub fn add_comment_end(mut self, id: usize) -> Self {
+        self.children
+            .push(SectionChild::CommentEnd(CommentRangeEnd::new(id)));
+        self
+    }
+
+    // TODO: inject count or create temp header
+    // pub fn header(mut self, header: Header) -> Self {
+    //     self.property = self.property.header(header, &create_header_rid(count));
+    //     self
+    // }
 }
 
 impl Default for Section {
     fn default() -> Self {
         Self {
             property: SectionProperty::new(),
+            children: vec![],
+            has_numbering: false,
         }
     }
 }
@@ -32,6 +199,7 @@ impl BuildXML for Section {
     ) -> xml::writer::Result<xml::writer::EventWriter<W>> {
         let id = crate::generate_para_id();
         XMLBuilder::from(stream)
+            .add_children(&self.children)?
             .open_paragraph(&id)?
             .open_paragraph_property()?
             .add_child(&self.property)?
@@ -58,4 +226,15 @@ mod tests {
             r#"<w:p w14:paraId="12345678"><w:pPr><w:sectPr><w:pgSz w:w="11906" w:h="16838" /><w:pgMar w:top="1985" w:right="1701" w:bottom="1701" w:left="1701" w:header="851" w:footer="992" w:gutter="0" /><w:cols w:space="425" w:num="1" /></w:sectPr></w:pPr></w:p>"#
         );
     }
+
+    #[test]
+    fn test_section_with_paragraph() {
+        let c =
+            Section::new().add_paragraph(Paragraph::new().add_run(Run::new().add_text("Hello")));
+        let b = c.build();
+        assert_eq!(
+            str::from_utf8(&b).unwrap(),
+            r#"<w:p w14:paraId="12345678"><w:pPr><w:rPr /></w:pPr><w:r><w:rPr /><w:t xml:space="preserve">Hello</w:t></w:r></w:p><w:p w14:paraId="12345678"><w:pPr><w:sectPr><w:pgSz w:w="11906" w:h="16838" /><w:pgMar w:top="1985" w:right="1701" w:bottom="1701" w:left="1701" w:header="851" w:footer="992" w:gutter="0" /><w:cols w:space="425" w:num="1" /></w:sectPr></w:pPr></w:p>"#
+        );
+    }
 }

docx-core/src/documents/mod.rs

@@ -297,6 +297,25 @@ impl Docx {
         self
     }
 
+    pub fn add_section(mut self, s: Section) -> Docx {
+        if s.has_numbering {
+            // If this document has numbering, set numberings.xml to document_rels.
+            // This is because numberings.xml without numbering cause an error on word online.
+            self.document_rels.has_numberings = true;
+        }
+        let headers = s.get_headers();
+        for header in headers {
+            if header.has_numbering {
+                self.document_rels.has_numberings = true;
+            }
+            let count = self.document_rels.header_count + 1;
+            self.document_rels.header_count = count;
+            self.content_type = self.content_type.add_header();
+        }
+        self.document = self.document.add_section(s);
+        self
+    }
+
     pub fn add_structured_data_tag(mut self, t: StructuredDataTag) -> Docx {
         if t.has_numbering {
             // If this document has numbering, set numberings.xml to document_rels.

docx-core/src/lib.rs

@@ -2,6 +2,7 @@ mod documents;
 #[allow(hidden_glob_reexports)] // should rename?
 mod errors;
 mod escape;
+mod macros;
 mod reader;
 mod types;
 mod xml_builder;

docx-core/src/macros.rs

@@ -0,0 +1,70 @@
+/// Macro to delegate methods to a specified field
+/// 
+/// This macro generates methods that delegate to methods on a field of the struct.
+/// Each delegated method will call the corresponding method on the specified field
+/// and return `self` for method chaining.
+/// 
+/// # Example
+/// 
+/// ```rust,ignore
+/// use docx_rs::delegate_to_field;
+/// 
+/// struct Wrapper {
+///     inner: SomeType,
+/// }
+/// 
+/// impl Wrapper {
+///     delegate_to_field! {
+///         inner =>
+///         method1(param: i32) -> Self,
+///         method2(a: String, b: bool) -> Self,
+///         method3() -> Self,
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! delegate_to_field {
+    ($field:ident => $($method:ident($($param:ident: $param_type:ty),*) -> Self),* $(,)?) => {
+        $(
+            pub fn $method(mut self, $($param: $param_type),*) -> Self {
+                self.$field = self.$field.$method($($param),*);
+                self
+            }
+        )*
+    };
+}
+
+/// Macro to delegate getter methods to a specified field
+/// 
+/// This macro generates getter methods that delegate to methods on a field of the struct.
+/// Each delegated method will call the corresponding method on the specified field
+/// and return the result directly.
+/// 
+/// # Example
+/// 
+/// ```rust,ignore
+/// use docx_rs::delegate_getters_to_field;
+/// 
+/// struct Wrapper {
+///     inner: SomeType,
+/// }
+/// 
+/// impl Wrapper {
+///     delegate_getters_to_field! {
+///         inner =>
+///         get_value() -> i32,
+///         get_name() -> String,
+///         is_active() -> bool,
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! delegate_getters_to_field {
+    ($field:ident => $($method:ident() -> $return_type:ty),* $(,)?) => {
+        $(
+            pub fn $method(&self) -> $return_type {
+                self.$field.$method()
+            }
+        )*
+    };
+}