umya-spreadsheet 3.0.0

umya-spreadsheet is a library written in pure Rust to read 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

use std::{
    fmt::Write,
    fs,
    io,
    path::Path,
};

use crate::structs::{
    CsvEncodeValues,
    CsvWriterOption,
    Workbook,
    XlsxError,
};

/// write spreadsheet file to arbitrary writer.
/// # Arguments
/// * `wb` - Workbook structs object.
/// * `writer` - writer to write to.
/// # Return value
/// * `Result` - OK is void. Err is error message.
pub fn write_writer<W: io::Seek + io::Write>(
    wb: &Workbook,
    writer: &mut W,
    option: &CsvWriterOption,
) -> Result<(), XlsxError> {
    // get worksheet.
    let worksheet = wb.active_sheet();

    // get max column and row.
    let (max_column, max_row) = worksheet.highest_column_and_row();

    let mut data = String::new();
    for row in 0u32..max_row {
        let mut row_vec: Vec<String> = Vec::new();
        for column in 0u32..max_column {
            // get value.
            let mut value = match worksheet.cell((column + 1, row + 1)) {
                Some(cell) => cell.cell_value().value().into(),
                None => String::new(),
            };
            // do trim.
            if option.do_trim() {
                value = value.trim().to_string();
            }
            // wrap_with_char.
            if option.wrap_with_char() != "" {
                value = format! {"{}{}{}", option.wrap_with_char(), value, option.wrap_with_char()};
            }
            row_vec.push(value);
        }
        write!(data, "{}", row_vec.join(",")).unwrap();
        write!(data, "\r\n").unwrap();
    }

    // encoding.
    let data_bytes = match *option.csv_encode_value() {
        CsvEncodeValues::ShiftJis => encoding_rs::SHIFT_JIS.encode(&data).0.into_owned(),
        CsvEncodeValues::Koi8u => encoding_rs::KOI8_U.encode(&data).0.into_owned(),
        CsvEncodeValues::Koi8r => encoding_rs::KOI8_R.encode(&data).0.into_owned(),
        CsvEncodeValues::Iso88598i => encoding_rs::ISO_8859_8_I.encode(&data).0.into_owned(),
        CsvEncodeValues::Gbk => encoding_rs::GBK.encode(&data).0.into_owned(),
        CsvEncodeValues::EucKr => encoding_rs::EUC_KR.encode(&data).0.into_owned(),
        CsvEncodeValues::Big5 => encoding_rs::BIG5.encode(&data).0.into_owned(),
        CsvEncodeValues::Utf16Le => encoding_rs::UTF_16LE.encode(&data).0.into_owned(),
        CsvEncodeValues::Utf16Be => encoding_rs::UTF_16BE.encode(&data).0.into_owned(),
        CsvEncodeValues::Utf8 => data.into_bytes(),
    };

    // output.
    writer.write_all(&data_bytes).unwrap();
    Ok(())
}

/// write spreadsheet file.
/// # Arguments
/// * `wb` - Workbook structs object.
/// * `path` - file path to save.
/// * `option` - options.
/// # Return value
/// * `Result` - OK is void. Err is error message.
/// # Examples
/// ```
/// use umya_spreadsheet::*;
/// let mut book = new_file();
/// let path = std::path::Path::new("./tests/result_files/zzz.xlsx");
/// let mut option = structs::CsvWriterOption::default();
/// option.set_csv_encode_value(structs::CsvEncodeValues::ShiftJis);
/// option.set_do_trim(true);
/// option.set_wrap_with_char("\"");
/// let _unused = writer::csv::write(&book, path, Some(&option));
/// ```
pub fn write<P: AsRef<Path>>(
    wb: &Workbook,
    path: P,
    option: Option<&CsvWriterOption>,
) -> Result<(), XlsxError> {
    let extension = path.as_ref().extension().unwrap().to_str().unwrap();
    let path_tmp = path
        .as_ref()
        .with_extension(format!("{}{}", extension, "tmp"));
    let def_option = CsvWriterOption::default();
    let option = match option {
        Some(v) => v,
        None => &def_option,
    };
    if let Err(v) = write_writer(
        wb,
        &mut io::BufWriter::new(fs::File::create::<&Path>(path_tmp.as_ref())?),
        option,
    ) {
        fs::remove_file(path_tmp)?;
        return Err(v);
    }
    fs::rename(path_tmp, path)?;
    Ok(())
}