#![forbid(unsafe_code)]
pub mod calc_chain;
pub mod error;
pub mod reader;
pub mod shared_strings;
pub mod styles;
pub mod writer;
pub use calc_chain::{CalcChain, CalcEntry};
pub use error::XlsxError;
pub use reader::read_xlsx;
pub use shared_strings::SharedStrings;
pub use styles::Styles;
pub use writer::write_xlsx;
use std::collections::BTreeMap;
#[derive(Debug, Clone, Default, PartialEq)]
pub struct XlsxWorkbook {
pub sheets: Vec<SheetData>,
pub shared_strings: SharedStrings,
pub styles: Styles,
}
impl XlsxWorkbook {
#[must_use]
pub fn single_sheet() -> Self {
XlsxWorkbook {
sheets: vec![SheetData::new("Sheet1")],
shared_strings: SharedStrings::default(),
styles: Styles::default(),
}
}
#[must_use]
pub fn shared_text(&self, index: u32) -> Option<&str> {
self.shared_strings.get(index)
}
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct SheetData {
pub name: String,
pub cells: BTreeMap<(u32, u32), XlsxCell>,
}
impl SheetData {
#[must_use]
pub fn new(name: impl Into<String>) -> Self {
SheetData {
name: name.into(),
cells: BTreeMap::new(),
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct XlsxCell {
pub value: XlsxValue,
pub style_index: Option<u32>,
pub formula: Option<String>,
}
impl XlsxCell {
#[must_use]
pub const fn new(value: XlsxValue) -> Self {
XlsxCell {
value,
style_index: None,
formula: None,
}
}
#[must_use]
pub fn formula(formula: impl Into<String>, cached: XlsxValue) -> Self {
XlsxCell {
value: cached,
style_index: None,
formula: Some(formula.into()),
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum XlsxValue {
Number(f64),
SharedString(u32),
InlineString(String),
Boolean(bool),
Error(String),
FormulaString(String),
}
impl XlsxValue {
#[must_use]
pub fn text(&self, shared: &SharedStrings) -> Option<String> {
match self {
XlsxValue::SharedString(i) => shared.get(*i).map(String::from),
XlsxValue::InlineString(s) | XlsxValue::FormulaString(s) => Some(s.clone()),
XlsxValue::Number(_) | XlsxValue::Boolean(_) | XlsxValue::Error(_) => None,
}
}
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing
)]
use super::{SharedStrings, SheetData, Styles, XlsxValue, XlsxWorkbook};
#[test]
fn single_sheet_and_defaults() {
let wb = XlsxWorkbook::single_sheet();
assert_eq!(wb.sheets.len(), 1);
assert_eq!(wb.sheets[0].name, "Sheet1");
assert!(wb.sheets[0].cells.is_empty());
assert!(wb.shared_strings.is_empty());
assert_eq!(wb.styles.cell_xfs, 0);
let empty = XlsxWorkbook::default();
assert_eq!(empty.sheets.len(), 0);
assert_eq!(SheetData::new("N").name, "N");
}
#[test]
fn text_resolution_through_the_shared_table() {
let mut shared = SharedStrings::default();
let idx = shared.insert("hello");
assert_eq!(idx, 0);
let wb_idx = XlsxValue::SharedString(idx);
assert_eq!(wb_idx.text(&shared), Some(String::from("hello")));
assert_eq!(XlsxValue::SharedString(9).text(&shared), None);
assert_eq!(
XlsxValue::InlineString("s".to_string()).text(&shared),
Some(String::from("s"))
);
assert_eq!(
XlsxValue::FormulaString("f".to_string()).text(&shared),
Some(String::from("f"))
);
assert_eq!(XlsxValue::Number(1.0).text(&shared), None);
assert_eq!(XlsxValue::Boolean(true).text(&shared), None);
assert_eq!(XlsxValue::Error("#REF!".to_string()).text(&shared), None);
}
#[test]
fn shared_string_table_semantics() {
let mut t = SharedStrings::default();
assert!(t.is_empty());
let a = t.insert("dup");
let b = t.insert("dup");
let c = t.insert("other");
assert_eq!(a, b, "dedup");
assert_eq!(c, 1);
assert_eq!(t.len(), 2);
assert_eq!(t.get(0), Some("dup"));
assert_eq!(t.get(1), Some("other"));
assert_eq!(t.get(2), None);
let round = XlsxWorkbook::default();
let _ = round; let _ = Styles::default();
}
}