1use std::fmt;
6
7use serde::de::Deserializer;
8use serde::ser::Serializer;
9use serde::{Deserialize, Serialize};
10
11pub use crate::cell_ref::CompactCellRef;
12use crate::namespaces;
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
16#[serde(rename = "worksheet")]
17pub struct WorksheetXml {
18 #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
19 pub xmlns: String,
20
21 #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
22 pub xmlns_r: String,
23
24 #[serde(rename = "sheetPr", skip_serializing_if = "Option::is_none")]
25 pub sheet_pr: Option<SheetPr>,
26
27 #[serde(rename = "dimension", skip_serializing_if = "Option::is_none")]
28 pub dimension: Option<Dimension>,
29
30 #[serde(rename = "sheetViews", skip_serializing_if = "Option::is_none")]
31 pub sheet_views: Option<SheetViews>,
32
33 #[serde(rename = "sheetFormatPr", skip_serializing_if = "Option::is_none")]
34 pub sheet_format_pr: Option<SheetFormatPr>,
35
36 #[serde(rename = "cols", skip_serializing_if = "Option::is_none")]
37 pub cols: Option<Cols>,
38
39 #[serde(rename = "sheetData")]
40 pub sheet_data: SheetData,
41
42 #[serde(rename = "sheetProtection", skip_serializing_if = "Option::is_none")]
43 pub sheet_protection: Option<SheetProtection>,
44
45 #[serde(rename = "autoFilter", skip_serializing_if = "Option::is_none")]
46 pub auto_filter: Option<AutoFilter>,
47
48 #[serde(rename = "mergeCells", skip_serializing_if = "Option::is_none")]
49 pub merge_cells: Option<MergeCells>,
50
51 #[serde(
52 rename = "conditionalFormatting",
53 default,
54 skip_serializing_if = "Vec::is_empty"
55 )]
56 pub conditional_formatting: Vec<ConditionalFormatting>,
57
58 #[serde(rename = "dataValidations", skip_serializing_if = "Option::is_none")]
59 pub data_validations: Option<DataValidations>,
60
61 #[serde(rename = "hyperlinks", skip_serializing_if = "Option::is_none")]
62 pub hyperlinks: Option<Hyperlinks>,
63
64 #[serde(rename = "printOptions", skip_serializing_if = "Option::is_none")]
65 pub print_options: Option<PrintOptions>,
66
67 #[serde(rename = "pageMargins", skip_serializing_if = "Option::is_none")]
68 pub page_margins: Option<PageMargins>,
69
70 #[serde(rename = "pageSetup", skip_serializing_if = "Option::is_none")]
71 pub page_setup: Option<PageSetup>,
72
73 #[serde(rename = "headerFooter", skip_serializing_if = "Option::is_none")]
74 pub header_footer: Option<HeaderFooter>,
75
76 #[serde(rename = "rowBreaks", skip_serializing_if = "Option::is_none")]
77 pub row_breaks: Option<RowBreaks>,
78
79 #[serde(rename = "colBreaks", skip_serializing_if = "Option::is_none")]
80 pub col_breaks: Option<RowBreaks>,
81
82 #[serde(rename = "drawing", skip_serializing_if = "Option::is_none")]
83 pub drawing: Option<DrawingRef>,
84
85 #[serde(rename = "legacyDrawing", skip_serializing_if = "Option::is_none")]
86 pub legacy_drawing: Option<LegacyDrawingRef>,
87
88 #[serde(rename = "controls", skip_serializing_if = "Option::is_none")]
89 pub controls: Option<crate::control::Controls>,
90
91 #[serde(rename = "tableParts", skip_serializing_if = "Option::is_none")]
92 pub table_parts: Option<TableParts>,
93}
94
95#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
97pub struct Dimension {
98 #[serde(rename = "@ref")]
99 pub reference: String,
100}
101
102#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
104pub struct SheetViews {
105 #[serde(rename = "sheetView")]
106 pub sheet_views: Vec<SheetView>,
107}
108
109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub struct SheetView {
112 #[serde(rename = "@tabSelected", skip_serializing_if = "Option::is_none")]
113 pub tab_selected: Option<bool>,
114
115 #[serde(rename = "@showGridLines", skip_serializing_if = "Option::is_none")]
116 pub show_grid_lines: Option<bool>,
117
118 #[serde(rename = "@showFormulas", skip_serializing_if = "Option::is_none")]
119 pub show_formulas: Option<bool>,
120
121 #[serde(rename = "@showRowColHeaders", skip_serializing_if = "Option::is_none")]
122 pub show_row_col_headers: Option<bool>,
123
124 #[serde(rename = "@zoomScale", skip_serializing_if = "Option::is_none")]
125 pub zoom_scale: Option<u32>,
126
127 #[serde(rename = "@view", skip_serializing_if = "Option::is_none")]
128 pub view: Option<String>,
129
130 #[serde(rename = "@topLeftCell", skip_serializing_if = "Option::is_none")]
131 pub top_left_cell: Option<String>,
132
133 #[serde(rename = "@workbookViewId")]
134 pub workbook_view_id: u32,
135
136 #[serde(rename = "pane", skip_serializing_if = "Option::is_none")]
137 pub pane: Option<Pane>,
138
139 #[serde(rename = "selection", default)]
140 pub selection: Vec<Selection>,
141}
142
143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145pub struct Pane {
146 #[serde(rename = "@xSplit", skip_serializing_if = "Option::is_none")]
147 pub x_split: Option<u32>,
148
149 #[serde(rename = "@ySplit", skip_serializing_if = "Option::is_none")]
150 pub y_split: Option<u32>,
151
152 #[serde(rename = "@topLeftCell", skip_serializing_if = "Option::is_none")]
153 pub top_left_cell: Option<String>,
154
155 #[serde(rename = "@activePane", skip_serializing_if = "Option::is_none")]
156 pub active_pane: Option<String>,
157
158 #[serde(rename = "@state", skip_serializing_if = "Option::is_none")]
159 pub state: Option<String>,
160}
161
162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
164pub struct Selection {
165 #[serde(rename = "@pane", skip_serializing_if = "Option::is_none")]
166 pub pane: Option<String>,
167
168 #[serde(rename = "@activeCell", skip_serializing_if = "Option::is_none")]
169 pub active_cell: Option<String>,
170
171 #[serde(rename = "@sqref", skip_serializing_if = "Option::is_none")]
172 pub sqref: Option<String>,
173}
174
175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
177pub struct SheetPr {
178 #[serde(rename = "@codeName", skip_serializing_if = "Option::is_none")]
179 pub code_name: Option<String>,
180
181 #[serde(rename = "@filterMode", skip_serializing_if = "Option::is_none")]
182 pub filter_mode: Option<bool>,
183
184 #[serde(rename = "tabColor", skip_serializing_if = "Option::is_none")]
185 pub tab_color: Option<TabColor>,
186
187 #[serde(rename = "outlinePr", skip_serializing_if = "Option::is_none")]
188 pub outline_pr: Option<OutlinePr>,
189}
190
191#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
193pub struct TabColor {
194 #[serde(rename = "@rgb", skip_serializing_if = "Option::is_none")]
195 pub rgb: Option<String>,
196
197 #[serde(rename = "@theme", skip_serializing_if = "Option::is_none")]
198 pub theme: Option<u32>,
199
200 #[serde(rename = "@indexed", skip_serializing_if = "Option::is_none")]
201 pub indexed: Option<u32>,
202}
203
204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
206pub struct OutlinePr {
207 #[serde(rename = "@summaryBelow", skip_serializing_if = "Option::is_none")]
208 pub summary_below: Option<bool>,
209
210 #[serde(rename = "@summaryRight", skip_serializing_if = "Option::is_none")]
211 pub summary_right: Option<bool>,
212}
213
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
216pub struct SheetFormatPr {
217 #[serde(rename = "@defaultRowHeight")]
218 pub default_row_height: f64,
219
220 #[serde(rename = "@defaultColWidth", skip_serializing_if = "Option::is_none")]
221 pub default_col_width: Option<f64>,
222
223 #[serde(rename = "@customHeight", skip_serializing_if = "Option::is_none")]
224 pub custom_height: Option<bool>,
225
226 #[serde(rename = "@outlineLevelRow", skip_serializing_if = "Option::is_none")]
227 pub outline_level_row: Option<u8>,
228
229 #[serde(rename = "@outlineLevelCol", skip_serializing_if = "Option::is_none")]
230 pub outline_level_col: Option<u8>,
231}
232
233#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
235pub struct SheetProtection {
236 #[serde(rename = "@password", skip_serializing_if = "Option::is_none")]
237 pub password: Option<String>,
238
239 #[serde(rename = "@sheet", skip_serializing_if = "Option::is_none")]
240 pub sheet: Option<bool>,
241
242 #[serde(rename = "@objects", skip_serializing_if = "Option::is_none")]
243 pub objects: Option<bool>,
244
245 #[serde(rename = "@scenarios", skip_serializing_if = "Option::is_none")]
246 pub scenarios: Option<bool>,
247
248 #[serde(rename = "@selectLockedCells", skip_serializing_if = "Option::is_none")]
249 pub select_locked_cells: Option<bool>,
250
251 #[serde(
252 rename = "@selectUnlockedCells",
253 skip_serializing_if = "Option::is_none"
254 )]
255 pub select_unlocked_cells: Option<bool>,
256
257 #[serde(rename = "@formatCells", skip_serializing_if = "Option::is_none")]
258 pub format_cells: Option<bool>,
259
260 #[serde(rename = "@formatColumns", skip_serializing_if = "Option::is_none")]
261 pub format_columns: Option<bool>,
262
263 #[serde(rename = "@formatRows", skip_serializing_if = "Option::is_none")]
264 pub format_rows: Option<bool>,
265
266 #[serde(rename = "@insertColumns", skip_serializing_if = "Option::is_none")]
267 pub insert_columns: Option<bool>,
268
269 #[serde(rename = "@insertRows", skip_serializing_if = "Option::is_none")]
270 pub insert_rows: Option<bool>,
271
272 #[serde(rename = "@insertHyperlinks", skip_serializing_if = "Option::is_none")]
273 pub insert_hyperlinks: Option<bool>,
274
275 #[serde(rename = "@deleteColumns", skip_serializing_if = "Option::is_none")]
276 pub delete_columns: Option<bool>,
277
278 #[serde(rename = "@deleteRows", skip_serializing_if = "Option::is_none")]
279 pub delete_rows: Option<bool>,
280
281 #[serde(rename = "@sort", skip_serializing_if = "Option::is_none")]
282 pub sort: Option<bool>,
283
284 #[serde(rename = "@autoFilter", skip_serializing_if = "Option::is_none")]
285 pub auto_filter: Option<bool>,
286
287 #[serde(rename = "@pivotTables", skip_serializing_if = "Option::is_none")]
288 pub pivot_tables: Option<bool>,
289}
290
291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
293pub struct Cols {
294 #[serde(rename = "col")]
295 pub cols: Vec<Col>,
296}
297
298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
300pub struct Col {
301 #[serde(rename = "@min")]
302 pub min: u32,
303
304 #[serde(rename = "@max")]
305 pub max: u32,
306
307 #[serde(rename = "@width", skip_serializing_if = "Option::is_none")]
308 pub width: Option<f64>,
309
310 #[serde(rename = "@style", skip_serializing_if = "Option::is_none")]
311 pub style: Option<u32>,
312
313 #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
314 pub hidden: Option<bool>,
315
316 #[serde(rename = "@customWidth", skip_serializing_if = "Option::is_none")]
317 pub custom_width: Option<bool>,
318
319 #[serde(rename = "@outlineLevel", skip_serializing_if = "Option::is_none")]
320 pub outline_level: Option<u8>,
321}
322
323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
325pub struct SheetData {
326 #[serde(rename = "row", default)]
327 pub rows: Vec<Row>,
328}
329
330#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
332pub struct Row {
333 #[serde(rename = "@r")]
335 pub r: u32,
336
337 #[serde(skip)]
338 pub spans: Option<String>,
339
340 #[serde(rename = "@s", skip_serializing_if = "Option::is_none")]
341 pub s: Option<u32>,
342
343 #[serde(rename = "@customFormat", skip_serializing_if = "Option::is_none")]
344 pub custom_format: Option<bool>,
345
346 #[serde(rename = "@ht", skip_serializing_if = "Option::is_none")]
347 pub ht: Option<f64>,
348
349 #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
350 pub hidden: Option<bool>,
351
352 #[serde(rename = "@customHeight", skip_serializing_if = "Option::is_none")]
353 pub custom_height: Option<bool>,
354
355 #[serde(rename = "@outlineLevel", skip_serializing_if = "Option::is_none")]
356 pub outline_level: Option<u8>,
357
358 #[serde(rename = "c", default)]
359 pub cells: Vec<Cell>,
360}
361
362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
364pub struct Cell {
365 #[serde(rename = "@r")]
367 pub r: CompactCellRef,
368
369 #[serde(skip)]
372 pub col: u32,
373
374 #[serde(rename = "@s", skip_serializing_if = "Option::is_none")]
376 pub s: Option<u32>,
377
378 #[serde(rename = "@t", default, skip_serializing_if = "CellTypeTag::is_none")]
380 pub t: CellTypeTag,
381
382 #[serde(rename = "f", skip_serializing_if = "Option::is_none")]
385 pub f: Option<Box<CellFormula>>,
386
387 #[serde(rename = "v", skip_serializing_if = "Option::is_none")]
389 pub v: Option<String>,
390
391 #[serde(rename = "is", skip_serializing_if = "Option::is_none")]
393 pub is: Option<Box<InlineString>>,
394}
395
396#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
398pub enum CellTypeTag {
399 #[default]
401 None,
402 SharedString,
404 Number,
406 Boolean,
408 Error,
410 InlineString,
412 FormulaString,
414 Date,
416}
417
418impl CellTypeTag {
419 pub fn is_none(&self) -> bool {
421 matches!(self, CellTypeTag::None)
422 }
423
424 pub fn as_str(&self) -> Option<&'static str> {
426 match self {
427 CellTypeTag::None => Option::None,
428 CellTypeTag::SharedString => Some("s"),
429 CellTypeTag::Number => Some("n"),
430 CellTypeTag::Boolean => Some("b"),
431 CellTypeTag::Error => Some("e"),
432 CellTypeTag::InlineString => Some("inlineStr"),
433 CellTypeTag::FormulaString => Some("str"),
434 CellTypeTag::Date => Some("d"),
435 }
436 }
437}
438
439impl Serialize for CellTypeTag {
440 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
441 match self.as_str() {
442 Some(s) => serializer.serialize_str(s),
443 Option::None => serializer.serialize_none(),
444 }
445 }
446}
447
448impl<'de> Deserialize<'de> for CellTypeTag {
449 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
450 struct CellTypeTagVisitor;
451
452 impl serde::de::Visitor<'_> for CellTypeTagVisitor {
453 type Value = CellTypeTag;
454
455 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
456 formatter.write_str("a cell type string (e.g. \"s\", \"n\", \"b\")")
457 }
458
459 fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<CellTypeTag, E> {
460 Ok(match v {
461 "s" => CellTypeTag::SharedString,
462 "n" => CellTypeTag::Number,
463 "b" => CellTypeTag::Boolean,
464 "e" => CellTypeTag::Error,
465 "inlineStr" => CellTypeTag::InlineString,
466 "str" => CellTypeTag::FormulaString,
467 "d" => CellTypeTag::Date,
468 _ => CellTypeTag::None,
469 })
470 }
471
472 fn visit_string<E: serde::de::Error>(self, v: String) -> Result<CellTypeTag, E> {
473 self.visit_str(&v)
474 }
475 }
476
477 deserializer.deserialize_str(CellTypeTagVisitor)
478 }
479}
480
481#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
483pub struct CellFormula {
484 #[serde(rename = "@t", skip_serializing_if = "Option::is_none")]
485 pub t: Option<String>,
486
487 #[serde(rename = "@ref", skip_serializing_if = "Option::is_none")]
488 pub reference: Option<String>,
489
490 #[serde(rename = "@si", skip_serializing_if = "Option::is_none")]
491 pub si: Option<u32>,
492
493 #[serde(rename = "$value", skip_serializing_if = "Option::is_none")]
494 pub value: Option<String>,
495}
496
497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
499pub struct InlineString {
500 #[serde(rename = "t", skip_serializing_if = "Option::is_none")]
501 pub t: Option<String>,
502
503 #[serde(rename = "r", default)]
506 pub r: Vec<crate::shared_strings::R>,
507
508 #[serde(rename = "rPh", default)]
510 pub r_ph: Vec<PhoneticRun>,
511}
512
513#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
515pub struct PhoneticRun {
516 #[serde(rename = "@sb", skip_serializing_if = "Option::is_none")]
517 pub sb: Option<u32>,
518
519 #[serde(rename = "@eb", skip_serializing_if = "Option::is_none")]
520 pub eb: Option<u32>,
521
522 #[serde(rename = "$value", default)]
523 pub value: String,
524}
525
526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
528pub struct AutoFilter {
529 #[serde(rename = "@ref")]
530 pub reference: String,
531}
532
533#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
535pub struct DataValidations {
536 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
537 pub count: Option<u32>,
538
539 #[serde(
540 rename = "@disablePrompts",
541 skip_serializing_if = "Option::is_none",
542 default
543 )]
544 pub disable_prompts: Option<bool>,
545
546 #[serde(rename = "@xWindow", skip_serializing_if = "Option::is_none", default)]
547 pub x_window: Option<u32>,
548
549 #[serde(rename = "@yWindow", skip_serializing_if = "Option::is_none", default)]
550 pub y_window: Option<u32>,
551
552 #[serde(rename = "dataValidation", default)]
553 pub data_validations: Vec<DataValidation>,
554}
555
556#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
558pub struct DataValidation {
559 #[serde(rename = "@type", skip_serializing_if = "Option::is_none")]
560 pub validation_type: Option<String>,
561
562 #[serde(rename = "@operator", skip_serializing_if = "Option::is_none")]
563 pub operator: Option<String>,
564
565 #[serde(rename = "@allowBlank", skip_serializing_if = "Option::is_none")]
566 pub allow_blank: Option<bool>,
567
568 #[serde(
569 rename = "@showDropDown",
570 skip_serializing_if = "Option::is_none",
571 default
572 )]
573 pub show_drop_down: Option<bool>,
574
575 #[serde(rename = "@showInputMessage", skip_serializing_if = "Option::is_none")]
576 pub show_input_message: Option<bool>,
577
578 #[serde(rename = "@showErrorMessage", skip_serializing_if = "Option::is_none")]
579 pub show_error_message: Option<bool>,
580
581 #[serde(rename = "@errorStyle", skip_serializing_if = "Option::is_none")]
582 pub error_style: Option<String>,
583
584 #[serde(rename = "@imeMode", skip_serializing_if = "Option::is_none", default)]
585 pub ime_mode: Option<String>,
586
587 #[serde(rename = "@errorTitle", skip_serializing_if = "Option::is_none")]
588 pub error_title: Option<String>,
589
590 #[serde(rename = "@error", skip_serializing_if = "Option::is_none")]
591 pub error: Option<String>,
592
593 #[serde(rename = "@promptTitle", skip_serializing_if = "Option::is_none")]
594 pub prompt_title: Option<String>,
595
596 #[serde(rename = "@prompt", skip_serializing_if = "Option::is_none")]
597 pub prompt: Option<String>,
598
599 #[serde(rename = "@sqref")]
600 pub sqref: String,
601
602 #[serde(rename = "formula1", skip_serializing_if = "Option::is_none")]
603 pub formula1: Option<String>,
604
605 #[serde(rename = "formula2", skip_serializing_if = "Option::is_none")]
606 pub formula2: Option<String>,
607}
608
609#[derive(Debug, Clone, Serialize, Deserialize)]
615pub struct MergeCells {
616 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
617 pub count: Option<u32>,
618
619 #[serde(rename = "mergeCell", default)]
620 pub merge_cells: Vec<MergeCell>,
621
622 #[serde(skip)]
626 pub cached_coords: Vec<(u32, u32, u32, u32)>,
627}
628
629impl PartialEq for MergeCells {
630 fn eq(&self, other: &Self) -> bool {
631 self.count == other.count && self.merge_cells == other.merge_cells
632 }
633}
634
635#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
637pub struct MergeCell {
638 #[serde(rename = "@ref")]
639 pub reference: String,
640}
641
642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
644pub struct Hyperlinks {
645 #[serde(rename = "hyperlink", default)]
646 pub hyperlinks: Vec<Hyperlink>,
647}
648
649#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
651pub struct Hyperlink {
652 #[serde(rename = "@ref")]
653 pub reference: String,
654
655 #[serde(
656 rename = "@r:id",
657 alias = "@id",
658 skip_serializing_if = "Option::is_none"
659 )]
660 pub r_id: Option<String>,
661
662 #[serde(rename = "@location", skip_serializing_if = "Option::is_none")]
663 pub location: Option<String>,
664
665 #[serde(rename = "@display", skip_serializing_if = "Option::is_none")]
666 pub display: Option<String>,
667
668 #[serde(rename = "@tooltip", skip_serializing_if = "Option::is_none")]
669 pub tooltip: Option<String>,
670}
671
672#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
674pub struct PageMargins {
675 #[serde(rename = "@left")]
676 pub left: f64,
677
678 #[serde(rename = "@right")]
679 pub right: f64,
680
681 #[serde(rename = "@top")]
682 pub top: f64,
683
684 #[serde(rename = "@bottom")]
685 pub bottom: f64,
686
687 #[serde(rename = "@header")]
688 pub header: f64,
689
690 #[serde(rename = "@footer")]
691 pub footer: f64,
692}
693
694#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
696pub struct PageSetup {
697 #[serde(rename = "@paperSize", skip_serializing_if = "Option::is_none")]
698 pub paper_size: Option<u32>,
699
700 #[serde(rename = "@orientation", skip_serializing_if = "Option::is_none")]
701 pub orientation: Option<String>,
702
703 #[serde(rename = "@scale", skip_serializing_if = "Option::is_none")]
704 pub scale: Option<u32>,
705
706 #[serde(rename = "@fitToWidth", skip_serializing_if = "Option::is_none")]
707 pub fit_to_width: Option<u32>,
708
709 #[serde(rename = "@fitToHeight", skip_serializing_if = "Option::is_none")]
710 pub fit_to_height: Option<u32>,
711
712 #[serde(rename = "@firstPageNumber", skip_serializing_if = "Option::is_none")]
713 pub first_page_number: Option<u32>,
714
715 #[serde(rename = "@horizontalDpi", skip_serializing_if = "Option::is_none")]
716 pub horizontal_dpi: Option<u32>,
717
718 #[serde(rename = "@verticalDpi", skip_serializing_if = "Option::is_none")]
719 pub vertical_dpi: Option<u32>,
720
721 #[serde(
722 rename = "@r:id",
723 alias = "@id",
724 skip_serializing_if = "Option::is_none"
725 )]
726 pub r_id: Option<String>,
727}
728
729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
731pub struct HeaderFooter {
732 #[serde(rename = "oddHeader", skip_serializing_if = "Option::is_none")]
733 pub odd_header: Option<String>,
734
735 #[serde(rename = "oddFooter", skip_serializing_if = "Option::is_none")]
736 pub odd_footer: Option<String>,
737}
738
739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
741pub struct PrintOptions {
742 #[serde(rename = "@gridLines", skip_serializing_if = "Option::is_none")]
743 pub grid_lines: Option<bool>,
744
745 #[serde(rename = "@headings", skip_serializing_if = "Option::is_none")]
746 pub headings: Option<bool>,
747
748 #[serde(
749 rename = "@horizontalCentered",
750 skip_serializing_if = "Option::is_none"
751 )]
752 pub horizontal_centered: Option<bool>,
753
754 #[serde(rename = "@verticalCentered", skip_serializing_if = "Option::is_none")]
755 pub vertical_centered: Option<bool>,
756}
757
758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
760pub struct RowBreaks {
761 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
762 pub count: Option<u32>,
763
764 #[serde(rename = "@manualBreakCount", skip_serializing_if = "Option::is_none")]
765 pub manual_break_count: Option<u32>,
766
767 #[serde(rename = "brk", default)]
768 pub brk: Vec<Break>,
769}
770
771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
773pub struct Break {
774 #[serde(rename = "@id")]
775 pub id: u32,
776
777 #[serde(rename = "@max", skip_serializing_if = "Option::is_none")]
778 pub max: Option<u32>,
779
780 #[serde(rename = "@man", skip_serializing_if = "Option::is_none")]
781 pub man: Option<bool>,
782}
783
784#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
786pub struct DrawingRef {
787 #[serde(rename = "@r:id", alias = "@id")]
788 pub r_id: String,
789}
790
791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
793pub struct LegacyDrawingRef {
794 #[serde(rename = "@r:id", alias = "@id")]
795 pub r_id: String,
796}
797
798#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
800pub struct TableParts {
801 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
802 pub count: Option<u32>,
803
804 #[serde(rename = "tablePart", default)]
805 pub table_parts: Vec<TablePart>,
806}
807
808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
810pub struct TablePart {
811 #[serde(rename = "@r:id", alias = "@id")]
812 pub r_id: String,
813}
814
815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
817pub struct ConditionalFormatting {
818 #[serde(rename = "@sqref")]
819 pub sqref: String,
820
821 #[serde(rename = "cfRule", default)]
822 pub cf_rules: Vec<CfRule>,
823}
824
825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
827pub struct CfRule {
828 #[serde(rename = "@type")]
829 pub rule_type: String,
830
831 #[serde(rename = "@dxfId", skip_serializing_if = "Option::is_none")]
832 pub dxf_id: Option<u32>,
833
834 #[serde(rename = "@priority")]
835 pub priority: u32,
836
837 #[serde(rename = "@operator", skip_serializing_if = "Option::is_none")]
838 pub operator: Option<String>,
839
840 #[serde(rename = "@text", skip_serializing_if = "Option::is_none")]
841 pub text: Option<String>,
842
843 #[serde(rename = "@stopIfTrue", skip_serializing_if = "Option::is_none")]
844 pub stop_if_true: Option<bool>,
845
846 #[serde(rename = "@aboveAverage", skip_serializing_if = "Option::is_none")]
847 pub above_average: Option<bool>,
848
849 #[serde(rename = "@equalAverage", skip_serializing_if = "Option::is_none")]
850 pub equal_average: Option<bool>,
851
852 #[serde(rename = "@percent", skip_serializing_if = "Option::is_none")]
853 pub percent: Option<bool>,
854
855 #[serde(rename = "@rank", skip_serializing_if = "Option::is_none")]
856 pub rank: Option<u32>,
857
858 #[serde(rename = "@bottom", skip_serializing_if = "Option::is_none")]
859 pub bottom: Option<bool>,
860
861 #[serde(rename = "formula", default, skip_serializing_if = "Vec::is_empty")]
862 pub formulas: Vec<String>,
863
864 #[serde(rename = "colorScale", skip_serializing_if = "Option::is_none")]
865 pub color_scale: Option<CfColorScale>,
866
867 #[serde(rename = "dataBar", skip_serializing_if = "Option::is_none")]
868 pub data_bar: Option<CfDataBar>,
869
870 #[serde(rename = "iconSet", skip_serializing_if = "Option::is_none")]
871 pub icon_set: Option<CfIconSet>,
872}
873
874#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
876pub struct CfColorScale {
877 #[serde(rename = "cfvo", default)]
878 pub cfvos: Vec<CfVo>,
879
880 #[serde(rename = "color", default)]
881 pub colors: Vec<CfColor>,
882}
883
884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
886pub struct CfDataBar {
887 #[serde(rename = "@showValue", skip_serializing_if = "Option::is_none")]
888 pub show_value: Option<bool>,
889
890 #[serde(rename = "cfvo", default)]
891 pub cfvos: Vec<CfVo>,
892
893 #[serde(rename = "color", skip_serializing_if = "Option::is_none")]
894 pub color: Option<CfColor>,
895}
896
897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
899pub struct CfIconSet {
900 #[serde(rename = "@iconSet", skip_serializing_if = "Option::is_none")]
901 pub icon_set: Option<String>,
902
903 #[serde(rename = "cfvo", default)]
904 pub cfvos: Vec<CfVo>,
905}
906
907#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
909pub struct CfVo {
910 #[serde(rename = "@type")]
911 pub value_type: String,
912
913 #[serde(rename = "@val", skip_serializing_if = "Option::is_none")]
914 pub val: Option<String>,
915}
916
917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
919pub struct CfColor {
920 #[serde(rename = "@rgb", skip_serializing_if = "Option::is_none")]
921 pub rgb: Option<String>,
922
923 #[serde(rename = "@theme", skip_serializing_if = "Option::is_none")]
924 pub theme: Option<u32>,
925
926 #[serde(rename = "@tint", skip_serializing_if = "Option::is_none")]
927 pub tint: Option<f64>,
928}
929
930impl Default for WorksheetXml {
931 fn default() -> Self {
932 Self {
933 xmlns: namespaces::SPREADSHEET_ML.to_string(),
934 xmlns_r: namespaces::RELATIONSHIPS.to_string(),
935 sheet_pr: None,
936 dimension: None,
937 sheet_views: None,
938 sheet_format_pr: None,
939 cols: None,
940 sheet_data: SheetData { rows: vec![] },
941 sheet_protection: None,
942 auto_filter: None,
943 merge_cells: None,
944 conditional_formatting: vec![],
945 data_validations: None,
946 hyperlinks: None,
947 print_options: None,
948 page_margins: None,
949 page_setup: None,
950 header_footer: None,
951 row_breaks: None,
952 col_breaks: None,
953 drawing: None,
954 legacy_drawing: None,
955 controls: None,
956 table_parts: None,
957 }
958 }
959}
960
961#[cfg(test)]
962mod tests {
963 use super::*;
964
965 #[test]
966 fn test_column_breaks_roundtrip_after_row_breaks() {
967 let xml = r#"<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheetData/><rowBreaks count="1"><brk id="5" max="16383" man="true"/></rowBreaks><colBreaks count="1" manualBreakCount="1"><brk id="3" max="1048575" man="true"/></colBreaks></worksheet>"#;
968
969 let worksheet: WorksheetXml = quick_xml::de::from_str(xml).unwrap();
970 assert_eq!(worksheet.col_breaks.as_ref().unwrap().brk[0].id, 3);
971
972 let serialized = quick_xml::se::to_string(&worksheet).unwrap();
973 assert!(serialized.find("rowBreaks").unwrap() < serialized.find("colBreaks").unwrap());
974 let reparsed: WorksheetXml = quick_xml::de::from_str(&serialized).unwrap();
975 assert_eq!(worksheet, reparsed);
976 }
977
978 #[test]
979 fn test_worksheet_default() {
980 let ws = WorksheetXml::default();
981 assert_eq!(ws.xmlns, namespaces::SPREADSHEET_ML);
982 assert_eq!(ws.xmlns_r, namespaces::RELATIONSHIPS);
983 assert!(ws.sheet_data.rows.is_empty());
984 assert!(ws.dimension.is_none());
985 assert!(ws.sheet_views.is_none());
986 assert!(ws.cols.is_none());
987 assert!(ws.merge_cells.is_none());
988 assert!(ws.page_margins.is_none());
989 assert!(ws.sheet_pr.is_none());
990 assert!(ws.sheet_protection.is_none());
991 }
992
993 #[test]
994 fn test_worksheet_roundtrip() {
995 let ws = WorksheetXml::default();
996 let xml = quick_xml::se::to_string(&ws).unwrap();
997 let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
998 assert_eq!(ws.xmlns, parsed.xmlns);
999 assert_eq!(ws.xmlns_r, parsed.xmlns_r);
1000 assert_eq!(ws.sheet_data.rows.len(), parsed.sheet_data.rows.len());
1001 }
1002
1003 #[test]
1004 fn test_worksheet_with_data() {
1005 let ws = WorksheetXml {
1006 sheet_data: SheetData {
1007 rows: vec![Row {
1008 r: 1,
1009 spans: Some("1:3".to_string()),
1010 s: None,
1011 custom_format: None,
1012 ht: None,
1013 hidden: None,
1014 custom_height: None,
1015 outline_level: None,
1016 cells: vec![
1017 Cell {
1018 r: CompactCellRef::new("A1").unwrap(),
1019 col: 1,
1020 s: None,
1021 t: CellTypeTag::SharedString,
1022 v: Some("0".to_string()),
1023 f: None,
1024 is: None,
1025 },
1026 Cell {
1027 r: CompactCellRef::new("B1").unwrap(),
1028 col: 2,
1029 s: None,
1030 t: CellTypeTag::None,
1031 v: Some("42".to_string()),
1032 f: None,
1033 is: None,
1034 },
1035 ],
1036 }],
1037 },
1038 ..WorksheetXml::default()
1039 };
1040
1041 let xml = quick_xml::se::to_string(&ws).unwrap();
1042 let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1043 assert_eq!(parsed.sheet_data.rows.len(), 1);
1044 assert_eq!(parsed.sheet_data.rows[0].r, 1);
1045 assert_eq!(parsed.sheet_data.rows[0].cells.len(), 2);
1046 assert_eq!(parsed.sheet_data.rows[0].cells[0].r, "A1");
1047 assert_eq!(
1048 parsed.sheet_data.rows[0].cells[0].t,
1049 CellTypeTag::SharedString
1050 );
1051 assert_eq!(parsed.sheet_data.rows[0].cells[0].v, Some("0".to_string()));
1052 assert_eq!(parsed.sheet_data.rows[0].cells[1].r, "B1");
1053 assert_eq!(parsed.sheet_data.rows[0].cells[1].v, Some("42".to_string()));
1054 }
1055
1056 #[test]
1057 fn test_cell_with_formula() {
1058 let cell = Cell {
1059 r: CompactCellRef::new("C1").unwrap(),
1060 col: 3,
1061 s: None,
1062 t: CellTypeTag::None,
1063 v: Some("84".to_string()),
1064 f: Some(Box::new(CellFormula {
1065 t: None,
1066 reference: None,
1067 si: None,
1068 value: Some("A1+B1".to_string()),
1069 })),
1070 is: None,
1071 };
1072 let xml = quick_xml::se::to_string(&cell).unwrap();
1073 assert!(xml.contains("A1+B1"));
1074 let f_at = xml.find("<f>").unwrap();
1076 let v_at = xml.find("<v>").unwrap();
1077 assert!(f_at < v_at, "formula must precede cached value: {xml}");
1078 assert!(xml.contains("</f><v>84</v>"), "{xml}");
1079 let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1080 assert!(parsed.f.is_some());
1081 assert_eq!(parsed.f.unwrap().value, Some("A1+B1".to_string()));
1082 assert_eq!(parsed.v, Some("84".to_string()));
1083 }
1084
1085 #[test]
1086 fn test_cell_with_inline_string() {
1087 let cell = Cell {
1088 r: CompactCellRef::new("A1").unwrap(),
1089 col: 1,
1090 s: None,
1091 t: CellTypeTag::InlineString,
1092 v: None,
1093 f: None,
1094 is: Some(Box::new(InlineString {
1095 t: Some("Hello World".to_string()),
1096 r: vec![],
1097 r_ph: vec![],
1098 })),
1099 };
1100 let xml = quick_xml::se::to_string(&cell).unwrap();
1101 assert!(xml.contains("Hello World"));
1102 let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1103 assert_eq!(parsed.t, CellTypeTag::InlineString);
1104 assert!(parsed.is.is_some());
1105 assert_eq!(parsed.is.unwrap().t, Some("Hello World".to_string()));
1106 }
1107
1108 #[test]
1109 fn test_inline_string_rich_runs_exclude_phonetic_annotations() {
1110 let xml = r#"<c r="A1" t="inlineStr"><is><r><t>Bold</t></r><r><t xml:space="preserve"> Text</t></r><rPh sb="0" eb="4">phonetic</rPh></is></c>"#;
1111 let cell: Cell = quick_xml::de::from_str(xml).unwrap();
1112 let inline = cell.is.unwrap();
1113
1114 assert_eq!(inline.r.len(), 2);
1115 assert_eq!(inline.r[0].t.value, "Bold");
1116 assert_eq!(inline.r[1].t.value, "Text");
1117 assert_eq!(inline.r_ph.len(), 1);
1118 assert_eq!(inline.r_ph[0].value, "phonetic");
1119 }
1120
1121 #[test]
1122 fn test_parse_real_excel_worksheet() {
1123 let xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
1124<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
1125 <dimension ref="A1:B2"/>
1126 <sheetData>
1127 <row r="1" spans="1:2">
1128 <c r="A1" t="s"><v>0</v></c>
1129 <c r="B1" t="s"><v>1</v></c>
1130 </row>
1131 <row r="2" spans="1:2">
1132 <c r="A2"><v>100</v></c>
1133 <c r="B2"><v>200</v></c>
1134 </row>
1135 </sheetData>
1136</worksheet>"#;
1137
1138 let parsed: WorksheetXml = quick_xml::de::from_str(xml).unwrap();
1139 assert_eq!(parsed.dimension.as_ref().unwrap().reference, "A1:B2");
1140 assert_eq!(parsed.sheet_data.rows.len(), 2);
1141 assert_eq!(parsed.sheet_data.rows[0].cells.len(), 2);
1142 assert_eq!(parsed.sheet_data.rows[0].cells[0].r, "A1");
1143 assert_eq!(
1144 parsed.sheet_data.rows[0].cells[0].t,
1145 CellTypeTag::SharedString
1146 );
1147 assert_eq!(parsed.sheet_data.rows[0].cells[0].v, Some("0".to_string()));
1148 assert_eq!(parsed.sheet_data.rows[1].cells[0].r, "A2");
1149 assert_eq!(
1150 parsed.sheet_data.rows[1].cells[0].v,
1151 Some("100".to_string())
1152 );
1153 }
1154
1155 #[test]
1156 fn test_worksheet_with_merge_cells() {
1157 let ws = WorksheetXml {
1158 merge_cells: Some(MergeCells {
1159 count: Some(1),
1160 merge_cells: vec![MergeCell {
1161 reference: "A1:B2".to_string(),
1162 }],
1163 cached_coords: Vec::new(),
1164 }),
1165 ..WorksheetXml::default()
1166 };
1167 let xml = quick_xml::se::to_string(&ws).unwrap();
1168 assert!(xml.contains("mergeCells"));
1169 assert!(xml.contains("A1:B2"));
1170 let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1171 assert!(parsed.merge_cells.is_some());
1172 assert_eq!(parsed.merge_cells.as_ref().unwrap().merge_cells.len(), 1);
1173 }
1174
1175 #[test]
1176 fn test_empty_sheet_data_serialization() {
1177 let sd = SheetData { rows: vec![] };
1178 let xml = quick_xml::se::to_string(&sd).unwrap();
1179 let parsed: SheetData = quick_xml::de::from_str(&xml).unwrap();
1181 assert!(parsed.rows.is_empty());
1182 }
1183
1184 #[test]
1185 fn test_row_optional_fields_not_serialized() {
1186 let row = Row {
1187 r: 1,
1188 spans: None,
1189 s: None,
1190 custom_format: None,
1191 ht: None,
1192 hidden: None,
1193 custom_height: None,
1194 outline_level: None,
1195 cells: vec![],
1196 };
1197 let xml = quick_xml::se::to_string(&row).unwrap();
1198 assert!(!xml.contains("spans"));
1199 assert!(!xml.contains("ht"));
1200 assert!(!xml.contains("hidden"));
1201 }
1202
1203 #[test]
1204 fn test_cell_type_tag_as_str() {
1205 assert_eq!(CellTypeTag::Boolean.as_str(), Some("b"));
1206 assert_eq!(CellTypeTag::Date.as_str(), Some("d"));
1207 assert_eq!(CellTypeTag::Error.as_str(), Some("e"));
1208 assert_eq!(CellTypeTag::InlineString.as_str(), Some("inlineStr"));
1209 assert_eq!(CellTypeTag::Number.as_str(), Some("n"));
1210 assert_eq!(CellTypeTag::SharedString.as_str(), Some("s"));
1211 assert_eq!(CellTypeTag::FormulaString.as_str(), Some("str"));
1212 assert_eq!(CellTypeTag::None.as_str(), Option::None);
1213 }
1214
1215 #[test]
1216 fn test_cell_type_tag_default_is_none() {
1217 assert_eq!(CellTypeTag::default(), CellTypeTag::None);
1218 assert!(CellTypeTag::None.is_none());
1219 assert!(!CellTypeTag::SharedString.is_none());
1220 }
1221
1222 #[test]
1223 fn test_cell_type_tag_serde_round_trip() {
1224 let variants = [
1225 (CellTypeTag::SharedString, "s"),
1226 (CellTypeTag::Number, "n"),
1227 (CellTypeTag::Boolean, "b"),
1228 (CellTypeTag::Error, "e"),
1229 (CellTypeTag::InlineString, "inlineStr"),
1230 (CellTypeTag::FormulaString, "str"),
1231 (CellTypeTag::Date, "d"),
1232 ];
1233 for (tag, expected_str) in &variants {
1234 let cell = Cell {
1235 r: CompactCellRef::new("A1").unwrap(),
1236 col: 1,
1237 s: None,
1238 t: *tag,
1239 v: Some("0".to_string()),
1240 f: None,
1241 is: None,
1242 };
1243 let xml = quick_xml::se::to_string(&cell).unwrap();
1244 assert!(
1245 xml.contains(&format!("t=\"{expected_str}\"")),
1246 "expected t=\"{expected_str}\" in: {xml}"
1247 );
1248 let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1249 assert_eq!(parsed.t, *tag);
1250 }
1251
1252 let cell_none = Cell {
1253 r: CompactCellRef::new("A1").unwrap(),
1254 col: 1,
1255 s: None,
1256 t: CellTypeTag::None,
1257 v: Some("42".to_string()),
1258 f: None,
1259 is: None,
1260 };
1261 let xml = quick_xml::se::to_string(&cell_none).unwrap();
1262 assert!(
1263 !xml.contains("t="),
1264 "None variant should not emit t attribute: {xml}"
1265 );
1266 let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1267 assert_eq!(parsed.t, CellTypeTag::None);
1268 }
1269
1270 #[test]
1271 fn test_worksheet_with_cols() {
1272 let ws = WorksheetXml {
1273 cols: Some(Cols {
1274 cols: vec![Col {
1275 min: 1,
1276 max: 1,
1277 width: Some(15.0),
1278 style: None,
1279 hidden: None,
1280 custom_width: Some(true),
1281 outline_level: None,
1282 }],
1283 }),
1284 ..WorksheetXml::default()
1285 };
1286 let xml = quick_xml::se::to_string(&ws).unwrap();
1287 let parsed: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
1288 assert!(parsed.cols.is_some());
1289 let cols = parsed.cols.unwrap();
1290 assert_eq!(cols.cols.len(), 1);
1291 assert_eq!(cols.cols[0].min, 1);
1292 assert_eq!(cols.cols[0].width, Some(15.0));
1293 assert_eq!(cols.cols[0].custom_width, Some(true));
1294 }
1295
1296 #[test]
1297 fn test_sheet_protection_roundtrip() {
1298 let prot = SheetProtection {
1299 password: Some("ABCD".to_string()),
1300 sheet: Some(true),
1301 objects: Some(true),
1302 scenarios: Some(true),
1303 format_cells: Some(false),
1304 ..SheetProtection::default()
1305 };
1306 let xml = quick_xml::se::to_string(&prot).unwrap();
1307 let parsed: SheetProtection = quick_xml::de::from_str(&xml).unwrap();
1308 assert_eq!(parsed.password, Some("ABCD".to_string()));
1309 assert_eq!(parsed.sheet, Some(true));
1310 assert_eq!(parsed.objects, Some(true));
1311 assert_eq!(parsed.scenarios, Some(true));
1312 assert_eq!(parsed.format_cells, Some(false));
1313 assert!(parsed.sort.is_none());
1314 }
1315
1316 #[test]
1317 fn test_sheet_pr_roundtrip() {
1318 let pr = SheetPr {
1319 code_name: Some("Sheet1".to_string()),
1320 tab_color: Some(TabColor {
1321 rgb: Some("FF0000".to_string()),
1322 theme: None,
1323 indexed: None,
1324 }),
1325 ..SheetPr::default()
1326 };
1327 let xml = quick_xml::se::to_string(&pr).unwrap();
1328 let parsed: SheetPr = quick_xml::de::from_str(&xml).unwrap();
1329 assert_eq!(parsed.code_name, Some("Sheet1".to_string()));
1330 assert!(parsed.tab_color.is_some());
1331 assert_eq!(parsed.tab_color.unwrap().rgb, Some("FF0000".to_string()));
1332 }
1333
1334 #[test]
1335 fn test_sheet_format_pr_extended_fields() {
1336 let fmt = SheetFormatPr {
1337 default_row_height: 15.0,
1338 default_col_width: Some(10.0),
1339 custom_height: Some(true),
1340 outline_level_row: Some(2),
1341 outline_level_col: Some(1),
1342 };
1343 let xml = quick_xml::se::to_string(&fmt).unwrap();
1344 let parsed: SheetFormatPr = quick_xml::de::from_str(&xml).unwrap();
1345 assert_eq!(parsed.default_row_height, 15.0);
1346 assert_eq!(parsed.default_col_width, Some(10.0));
1347 assert_eq!(parsed.custom_height, Some(true));
1348 assert_eq!(parsed.outline_level_row, Some(2));
1349 assert_eq!(parsed.outline_level_col, Some(1));
1350 }
1351
1352 #[test]
1353 fn test_compact_cell_ref_basic() {
1354 let r = CompactCellRef::new("A1").unwrap();
1355 assert_eq!(r.as_str(), "A1");
1356 }
1357
1358 #[test]
1359 fn test_compact_cell_ref_max_length() {
1360 let r = CompactCellRef::new("XFD1048576").unwrap();
1361 assert_eq!(r.as_str(), "XFD1048576");
1362 }
1363
1364 #[test]
1365 fn test_compact_cell_ref_various_lengths() {
1366 for s in &["A1", "B5", "Z99", "AA100", "XFD1048576"] {
1367 let r = CompactCellRef::new(s).unwrap();
1368 assert_eq!(r.as_str(), *s);
1369 }
1370 }
1371
1372 #[test]
1373 fn test_compact_cell_ref_display() {
1374 let r = CompactCellRef::new("C3").unwrap();
1375 assert_eq!(format!("{r}"), "C3");
1376 }
1377
1378 #[test]
1379 fn test_compact_cell_ref_debug() {
1380 let r = CompactCellRef::new("C3").unwrap();
1381 let dbg = format!("{r:?}");
1382 assert!(dbg.contains("CompactCellRef"));
1383 assert!(dbg.contains("C3"));
1384 }
1385
1386 #[test]
1387 fn test_compact_cell_ref_from_str() {
1388 let r = CompactCellRef::try_from("D4").unwrap();
1389 assert_eq!(r.as_str(), "D4");
1390 }
1391
1392 #[test]
1393 fn test_compact_cell_ref_from_string() {
1394 let r = CompactCellRef::try_from(String::from("E5")).unwrap();
1395 assert_eq!(r.as_str(), "E5");
1396 }
1397
1398 #[test]
1399 fn test_compact_cell_ref_as_ref_str() {
1400 let r = CompactCellRef::new("F6").unwrap();
1401 let s: &str = r.as_ref();
1402 assert_eq!(s, "F6");
1403 }
1404
1405 #[test]
1406 fn test_compact_cell_ref_partial_eq_str() {
1407 let r = CompactCellRef::new("G7").unwrap();
1408 assert_eq!(r, "G7");
1409 assert!(r == "G7");
1410 assert!(r != "H8");
1411 }
1412
1413 #[test]
1414 fn test_compact_cell_ref_copy() {
1415 let r1 = CompactCellRef::new("A1").unwrap();
1416 let r2 = r1;
1417 assert_eq!(r1.as_str(), "A1");
1418 assert_eq!(r2.as_str(), "A1");
1419 }
1420
1421 #[test]
1422 fn test_compact_cell_ref_serde_roundtrip() {
1423 let cell = Cell {
1424 r: CompactCellRef::new("XFD1048576").unwrap(),
1425 col: 16384,
1426 s: None,
1427 t: CellTypeTag::None,
1428 v: Some("42".to_string()),
1429 f: None,
1430 is: None,
1431 };
1432 let xml = quick_xml::se::to_string(&cell).unwrap();
1433 assert!(xml.contains("XFD1048576"));
1434 let parsed: Cell = quick_xml::de::from_str(&xml).unwrap();
1435 assert_eq!(parsed.r, "XFD1048576");
1436 assert_eq!(parsed.v, Some("42".to_string()));
1437 }
1438
1439 #[test]
1440 fn test_compact_cell_ref_rejects_overflow() {
1441 assert!(CompactCellRef::new("ABCDEFGHIJK").is_err());
1442 }
1443
1444 #[test]
1445 fn test_compact_cell_ref_from_coordinates_a1() {
1446 let r = CompactCellRef::from_coordinates(1, 1).unwrap();
1447 assert_eq!(r.as_str(), "A1");
1448 }
1449
1450 #[test]
1451 fn test_compact_cell_ref_from_coordinates_z26() {
1452 let r = CompactCellRef::from_coordinates(26, 26).unwrap();
1453 assert_eq!(r.as_str(), "Z26");
1454 }
1455
1456 #[test]
1457 fn test_compact_cell_ref_from_coordinates_aa1() {
1458 let r = CompactCellRef::from_coordinates(27, 1).unwrap();
1459 assert_eq!(r.as_str(), "AA1");
1460 }
1461
1462 #[test]
1463 fn test_compact_cell_ref_from_coordinates_max() {
1464 let r = CompactCellRef::from_coordinates(16384, 1048576).unwrap();
1465 assert_eq!(r.as_str(), "XFD1048576");
1466 }
1467
1468 #[test]
1469 fn test_compact_cell_ref_from_coordinates_zz1() {
1470 let r = CompactCellRef::from_coordinates(702, 1).unwrap();
1471 assert_eq!(r.as_str(), "ZZ1");
1472 }
1473
1474 #[test]
1475 fn test_compact_cell_ref_from_coordinates_roundtrip() {
1476 fn col_to_name(mut col: u32) -> String {
1477 let mut result = String::new();
1478 while col > 0 {
1479 col -= 1;
1480 result.insert(0, (b'A' + (col % 26) as u8) as char);
1481 col /= 26;
1482 }
1483 result
1484 }
1485 for c in [1, 2, 26, 27, 52, 100, 256, 702, 703, 16384] {
1486 let r = CompactCellRef::from_coordinates(c, 1).unwrap();
1487 let expected = format!("{}1", col_to_name(c));
1488 assert_eq!(r.as_str(), expected, "mismatch for col={c}");
1489 }
1490 }
1491}