ironcalc 0.8.2

The democratization of spreadsheets
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

#![allow(clippy::unwrap_used)]
//! <sheet name="Sheet1" sheetId="1" r:id="rId1"/>

//! A workbook is composed of workbook-level properties and a collection of 1 or more sheets.
//! The workbook part and corresponding properties comprise data
//! used to set application and workbook-level operational state. The workbook also serves to bind all the sheets
//! and child elements into an organized single file. The workbook XML attributes and elements include information
//! about what application last saved the file, where and how the windows of the workbook were positioned, and
//! an enumeration of the worksheets in the workbook.
//! This is the XML for the smallest possible (blank) workbook:
//!
//! <workbook>
//!   <sheets>
//!     <sheet name="Sheet1" sheetId="1" r:id="rId1"/>
//!   </sheets>
//! </workbook>
//!
//! Note that this workbook has a single sheet, named Sheet1. An Id for the sheet is required, and a relationship Id
//! pointing to the location of the sheet definition is also required.
//!
//!
//!
//! The most important objet of this part is a collection of all the sheets and all the defined names
//! of the workbook.
//!
//! It also may hold state properties like the selected tab

//! # bookViews
//!

use std::collections::HashMap;

use ironcalc_base::expressions::parser::{new_parser_english, stringify::to_excel_string};
use ironcalc_base::expressions::types::CellReferenceRC;
use ironcalc_base::types::{SheetState, Workbook};

use super::escape::escape_xml;
use super::xml_constants::XML_DECLARATION;

pub(crate) fn get_workbook_xml(workbook: &Workbook, selected_sheet: u32) -> String {
    // sheets
    // <sheet name="Sheet1" sheetId="1" r:id="rId1"/>
    let mut sheets_str: Vec<String> = vec![];
    let mut sheet_id_to_sheet_index: HashMap<u32, u32> = HashMap::new();
    for (sheet_index, worksheet) in workbook.worksheets.iter().enumerate() {
        let name = &worksheet.name;
        let name = escape_xml(name);
        let sheet_id = worksheet.sheet_id;
        let state_str = match &worksheet.state {
            SheetState::Visible => "",
            SheetState::Hidden => " state=\"hidden\"",
            SheetState::VeryHidden => " state=\"veryHidden\"",
        };

        sheets_str.push(format!(
            "<sheet name=\"{name}\" sheetId=\"{sheet_id}\" r:id=\"rId{}\"{state_str}/>",
            sheet_index + 1
        ));
        sheet_id_to_sheet_index.insert(sheet_id, sheet_index as u32);
    }

    // defined names
    // <definedName localSheetId="4" name="answer">shared!$G$5</definedName>
    // <definedName name="numbers">Sheet1!$A$16:$A$18</definedName>
    // Formulas are stored in IronCalc's internal English form (`LAMBDA(x,x+1)`);
    // Excel expects future-function and lambda-parameter prefixes
    // (`_xlfn.LAMBDA(_xlpm.x,_xlpm.x+1)`), so they are parsed and re-stringified.
    let worksheet_names: Vec<String> = workbook.worksheets.iter().map(|s| s.name.clone()).collect();
    let mut parser = new_parser_english(
        worksheet_names,
        workbook.get_defined_names_with_scope(),
        workbook.tables.clone(),
    );
    let parse_context = CellReferenceRC {
        sheet: workbook
            .worksheets
            .first()
            .map(|ws| ws.name.clone())
            .unwrap_or_else(|| "Sheet1".to_string()),
        row: 1,
        column: 1,
    };
    let mut defined_names_str: Vec<String> = vec![];
    for defined_name in &workbook.defined_names {
        let name = &defined_name.name;
        let name = escape_xml(name);
        let local_sheet_id = if let Some(sheet_id) = defined_name.sheet_id {
            // In Excel the localSheetId is actually the index of the sheet.
            let excel_local_sheet_id = sheet_id_to_sheet_index.get(&sheet_id).unwrap();
            format!(" localSheetId=\"{excel_local_sheet_id}\"")
        } else {
            "".to_string()
        };
        // A formula that fails to parse stringifies back to itself unchanged.
        let formula_body = defined_name
            .formula
            .strip_prefix('=')
            .unwrap_or(&defined_name.formula);
        let node = parser.parse(formula_body, &parse_context);
        let formula = to_excel_string(&node, &parse_context);
        let formula = escape_xml(&formula);
        defined_names_str.push(format!(
            "<definedName name=\"{name}\"{local_sheet_id}>{formula}</definedName>"
        ))
    }

    let sheets = sheets_str.join("");
    let defined_names = defined_names_str.join("");
    format!("{XML_DECLARATION}\n\
    <workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\
    <bookViews>
    <workbookView activeTab=\"{selected_sheet}\"/>\
    </bookViews>
      <sheets>\
        {sheets}\
      </sheets>\
      <definedNames>\
        {defined_names}\
      </definedNames>\
      <calcPr/>\
    </workbook>")
}