logisheets_workbook 0.7.0

Tools for LogiSheets to unarchive and write .xlsx file
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use super::{
    complex_types::PlainTextString,
    defaults::*,
    simple_types::{StCellRef, StCellType},
};
use xmlserde_derives::{XmlDeserialize, XmlSerialize};

#[derive(Debug, XmlSerialize, XmlDeserialize)]
#[xmlserde(root = b"externalLink")]
#[xmlserde(with_ns = b"http://schemas.openxmlformats.org/spreadsheetml/2006/main")]
pub struct ExternalLinkPart {
    #[xmlserde(name = b"externalBook", ty = "child")]
    pub external_book: Option<CtExternalBook>,
    // pub dde_link: Option<CtDdeLink>,
    // pub ole_link: Option<CtOleLink>,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalBook {
    #[xmlserde(name = b"sheetNames", ty = "child")]
    pub sheet_names: Option<CtExternalSheetNames>,
    #[xmlserde(name = b"definedNames", ty = "child")]
    pub defined_names: Option<CtExternalDefinedNames>,
    #[xmlserde(name = b"sheetDataSet", ty = "child")]
    pub sheet_data_set: Option<CtExternalSheetDataSet>,
    #[xmlserde(name = b"r:id", ty = "attr")]
    pub id: String,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalSheetNames {
    #[xmlserde(name = b"sheetName", ty = "child")]
    pub names: Vec<CtExternalSheetName>,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalSheetName {
    #[xmlserde(name = b"val", ty = "attr")]
    pub val: String,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalDefinedNames {
    #[xmlserde(name = b"definedName", ty = "child")]
    pub names: Vec<CtExternalDefinedName>,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalDefinedName {
    #[xmlserde(name = b"name", ty = "attr")]
    pub name: String,
    #[xmlserde(name = b"refersTo", ty = "attr")]
    pub refers_to: Option<String>,
    #[xmlserde(name = b"sheetId", ty = "attr")]
    pub sheet_id: Option<u32>,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalSheetDataSet {
    #[xmlserde(name = b"sheetData", ty = "child")]
    pub data: Vec<CtExternalSheetData>,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalSheetData {
    #[xmlserde(name = b"row", ty = "child")]
    pub rows: Vec<CtExternalRow>,
    #[xmlserde(name = b"sheetId", ty = "attr")]
    pub sheet_id: u32,
    #[xmlserde(name = b"refreshError", ty = "attr", default = "default_false")]
    pub refresh_error: bool,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalRow {
    #[xmlserde(name = b"cell", ty = "child")]
    pub cells: Vec<CtExternalCell>,
    #[xmlserde(name = b"r", ty = "attr")]
    pub r: u32,
}

#[derive(Debug, XmlSerialize, XmlDeserialize)]
pub struct CtExternalCell {
    #[xmlserde(name = b"v", ty = "child")]
    pub v: Option<PlainTextString>,
    #[xmlserde(name = b"r", ty = "attr")]
    pub r: Option<StCellRef>,
    #[xmlserde(name = b"t", ty = "attr", default = "st_cell_type_n")]
    pub t: StCellType,
    #[xmlserde(name = b"vm", ty = "attr", default = "default_zero_u32")]
    pub vm: u32,
}

#[cfg(test)]
mod tests {
    use super::ExternalLinkPart;
    use crate::xml_deserialize_from_str;
    #[test]
    fn test1() {
        let xml = include_str!("../../examples/external_link.xml");
        let r = xml_deserialize_from_str::<ExternalLinkPart>(xml);
        match r {
            Ok(external_link) => {
                let book = external_link.external_book.unwrap();
                assert_eq!(book.sheet_names.unwrap().names.len(), 12);
                // Used the site and the code below to check the diff manually.
                // Basically pass.
                // https://www.diffchecker.com/diff
                // use crate::xml_serialize_with_decl;
                // use crate::test_utils::*;
                // let expected = to_tree(&in_one_line(xml));
                // let actual = xml_serialize_with_decl(b"externalLink", external_link);
                // let r =  to_tree(&in_one_line(&actual));
                // println!("{:?}", actual);
                // use std::io::Write;
                // let mut file1 = std::fs::File::create("data1.txt").expect("create failed");
                // file1.write_all(expected.as_bytes()).expect("write failed");
                // let mut file2 = std::fs::File::create("data2.txt").expect("create failed");
                // file2.write_all(r.as_bytes()).expect("write failed");
                // assert_eq!(actual, r);
            }
            Err(e) => panic!("{:?}", e),
        }
    }
}