1use serde::{Deserialize, Serialize};
7
8use crate::namespaces;
9
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
12#[serde(rename = "styleSheet")]
13pub struct StyleSheet {
14 #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
15 pub xmlns: String,
16
17 #[serde(rename = "numFmts", skip_serializing_if = "Option::is_none")]
18 pub num_fmts: Option<NumFmts>,
19
20 #[serde(rename = "fonts")]
21 pub fonts: Fonts,
22
23 #[serde(rename = "fills")]
24 pub fills: Fills,
25
26 #[serde(rename = "borders")]
27 pub borders: Borders,
28
29 #[serde(rename = "cellStyleXfs", skip_serializing_if = "Option::is_none")]
30 pub cell_style_xfs: Option<CellStyleXfs>,
31
32 #[serde(rename = "cellXfs")]
33 pub cell_xfs: CellXfs,
34
35 #[serde(rename = "cellStyles", skip_serializing_if = "Option::is_none")]
36 pub cell_styles: Option<CellStyles>,
37
38 #[serde(rename = "dxfs", skip_serializing_if = "Option::is_none")]
39 pub dxfs: Option<Dxfs>,
40
41 #[serde(rename = "tableStyles", skip_serializing_if = "Option::is_none")]
42 pub table_styles: Option<TableStyles>,
43}
44
45#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
47pub struct NumFmts {
48 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
49 pub count: Option<u32>,
50
51 #[serde(rename = "numFmt", default)]
52 pub num_fmts: Vec<NumFmt>,
53}
54
55#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
57pub struct NumFmt {
58 #[serde(rename = "@numFmtId")]
59 pub num_fmt_id: u32,
60
61 #[serde(rename = "@formatCode")]
62 pub format_code: String,
63}
64
65#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
67pub struct Fonts {
68 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
69 pub count: Option<u32>,
70
71 #[serde(rename = "font", default)]
72 pub fonts: Vec<Font>,
73}
74
75#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
77pub struct Font {
78 #[serde(rename = "b", skip_serializing_if = "Option::is_none")]
79 pub b: Option<BoolVal>,
80
81 #[serde(rename = "i", skip_serializing_if = "Option::is_none")]
82 pub i: Option<BoolVal>,
83
84 #[serde(rename = "strike", skip_serializing_if = "Option::is_none")]
85 pub strike: Option<BoolVal>,
86
87 #[serde(rename = "u", skip_serializing_if = "Option::is_none")]
88 pub u: Option<Underline>,
89
90 #[serde(rename = "sz", skip_serializing_if = "Option::is_none")]
91 pub sz: Option<FontSize>,
92
93 #[serde(rename = "color", skip_serializing_if = "Option::is_none")]
94 pub color: Option<Color>,
95
96 #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
97 pub name: Option<FontName>,
98
99 #[serde(rename = "family", skip_serializing_if = "Option::is_none")]
100 pub family: Option<FontFamily>,
101
102 #[serde(rename = "scheme", skip_serializing_if = "Option::is_none")]
103 pub scheme: Option<FontScheme>,
104}
105
106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
108pub struct Fills {
109 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
110 pub count: Option<u32>,
111
112 #[serde(rename = "fill", default)]
113 pub fills: Vec<Fill>,
114}
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
118pub struct Fill {
119 #[serde(rename = "patternFill", skip_serializing_if = "Option::is_none")]
120 pub pattern_fill: Option<PatternFill>,
121
122 #[serde(rename = "gradientFill", skip_serializing_if = "Option::is_none")]
123 pub gradient_fill: Option<GradientFill>,
124}
125
126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
128pub struct PatternFill {
129 #[serde(rename = "@patternType", skip_serializing_if = "Option::is_none")]
130 pub pattern_type: Option<String>,
131
132 #[serde(rename = "fgColor", skip_serializing_if = "Option::is_none")]
133 pub fg_color: Option<Color>,
134
135 #[serde(rename = "bgColor", skip_serializing_if = "Option::is_none")]
136 pub bg_color: Option<Color>,
137}
138
139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
141pub struct GradientFill {
142 #[serde(rename = "@type", skip_serializing_if = "Option::is_none")]
144 pub gradient_type: Option<String>,
145
146 #[serde(rename = "@degree", skip_serializing_if = "Option::is_none")]
148 pub degree: Option<f64>,
149
150 #[serde(rename = "@left", skip_serializing_if = "Option::is_none")]
152 pub left: Option<f64>,
153
154 #[serde(rename = "@right", skip_serializing_if = "Option::is_none")]
156 pub right: Option<f64>,
157
158 #[serde(rename = "@top", skip_serializing_if = "Option::is_none")]
160 pub top: Option<f64>,
161
162 #[serde(rename = "@bottom", skip_serializing_if = "Option::is_none")]
164 pub bottom: Option<f64>,
165
166 #[serde(rename = "stop", default)]
168 pub stops: Vec<GradientStop>,
169}
170
171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
173pub struct GradientStop {
174 #[serde(rename = "@position")]
176 pub position: f64,
177
178 pub color: Color,
180}
181
182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
184pub struct Borders {
185 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
186 pub count: Option<u32>,
187
188 #[serde(rename = "border", default)]
189 pub borders: Vec<Border>,
190}
191
192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
194pub struct Border {
195 #[serde(rename = "@diagonalUp", skip_serializing_if = "Option::is_none")]
196 pub diagonal_up: Option<bool>,
197
198 #[serde(rename = "@diagonalDown", skip_serializing_if = "Option::is_none")]
199 pub diagonal_down: Option<bool>,
200
201 #[serde(rename = "left", skip_serializing_if = "Option::is_none")]
202 pub left: Option<BorderSide>,
203
204 #[serde(rename = "right", skip_serializing_if = "Option::is_none")]
205 pub right: Option<BorderSide>,
206
207 #[serde(rename = "top", skip_serializing_if = "Option::is_none")]
208 pub top: Option<BorderSide>,
209
210 #[serde(rename = "bottom", skip_serializing_if = "Option::is_none")]
211 pub bottom: Option<BorderSide>,
212
213 #[serde(rename = "diagonal", skip_serializing_if = "Option::is_none")]
214 pub diagonal: Option<BorderSide>,
215}
216
217#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
219pub struct BorderSide {
220 #[serde(rename = "@style", skip_serializing_if = "Option::is_none")]
221 pub style: Option<String>,
222
223 #[serde(rename = "color", skip_serializing_if = "Option::is_none")]
224 pub color: Option<Color>,
225}
226
227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
229pub struct CellStyleXfs {
230 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
231 pub count: Option<u32>,
232
233 #[serde(rename = "xf", default)]
234 pub xfs: Vec<Xf>,
235}
236
237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
239pub struct CellXfs {
240 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
241 pub count: Option<u32>,
242
243 #[serde(rename = "xf", default)]
244 pub xfs: Vec<Xf>,
245}
246
247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
249pub struct Xf {
250 #[serde(rename = "@numFmtId", skip_serializing_if = "Option::is_none")]
251 pub num_fmt_id: Option<u32>,
252
253 #[serde(rename = "@fontId", skip_serializing_if = "Option::is_none")]
254 pub font_id: Option<u32>,
255
256 #[serde(rename = "@fillId", skip_serializing_if = "Option::is_none")]
257 pub fill_id: Option<u32>,
258
259 #[serde(rename = "@borderId", skip_serializing_if = "Option::is_none")]
260 pub border_id: Option<u32>,
261
262 #[serde(rename = "@xfId", skip_serializing_if = "Option::is_none")]
263 pub xf_id: Option<u32>,
264
265 #[serde(rename = "@applyNumberFormat", skip_serializing_if = "Option::is_none")]
266 pub apply_number_format: Option<bool>,
267
268 #[serde(rename = "@applyFont", skip_serializing_if = "Option::is_none")]
269 pub apply_font: Option<bool>,
270
271 #[serde(rename = "@applyFill", skip_serializing_if = "Option::is_none")]
272 pub apply_fill: Option<bool>,
273
274 #[serde(rename = "@applyBorder", skip_serializing_if = "Option::is_none")]
275 pub apply_border: Option<bool>,
276
277 #[serde(rename = "@applyAlignment", skip_serializing_if = "Option::is_none")]
278 pub apply_alignment: Option<bool>,
279
280 #[serde(rename = "@applyProtection", skip_serializing_if = "Option::is_none")]
281 pub apply_protection: Option<bool>,
282
283 #[serde(rename = "@quotePrefix", skip_serializing_if = "Option::is_none")]
284 pub quote_prefix: Option<bool>,
285
286 #[serde(rename = "alignment", skip_serializing_if = "Option::is_none")]
287 pub alignment: Option<Alignment>,
288
289 #[serde(rename = "protection", skip_serializing_if = "Option::is_none")]
290 pub protection: Option<Protection>,
291}
292
293#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
295pub struct Alignment {
296 #[serde(rename = "@horizontal", skip_serializing_if = "Option::is_none")]
297 pub horizontal: Option<String>,
298
299 #[serde(rename = "@vertical", skip_serializing_if = "Option::is_none")]
300 pub vertical: Option<String>,
301
302 #[serde(rename = "@wrapText", skip_serializing_if = "Option::is_none")]
303 pub wrap_text: Option<bool>,
304
305 #[serde(rename = "@textRotation", skip_serializing_if = "Option::is_none")]
306 pub text_rotation: Option<u32>,
307
308 #[serde(rename = "@indent", skip_serializing_if = "Option::is_none")]
309 pub indent: Option<u32>,
310
311 #[serde(rename = "@shrinkToFit", skip_serializing_if = "Option::is_none")]
312 pub shrink_to_fit: Option<bool>,
313}
314
315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
317pub struct Protection {
318 #[serde(rename = "@locked", skip_serializing_if = "Option::is_none")]
319 pub locked: Option<bool>,
320
321 #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
322 pub hidden: Option<bool>,
323}
324
325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
327pub struct CellStyles {
328 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
329 pub count: Option<u32>,
330
331 #[serde(rename = "cellStyle", default)]
332 pub cell_styles: Vec<CellStyle>,
333}
334
335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
337pub struct CellStyle {
338 #[serde(rename = "@name")]
339 pub name: String,
340
341 #[serde(rename = "@xfId")]
342 pub xf_id: u32,
343
344 #[serde(rename = "@builtinId", skip_serializing_if = "Option::is_none")]
345 pub builtin_id: Option<u32>,
346}
347
348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
350pub struct Dxfs {
351 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
352 pub count: Option<u32>,
353
354 #[serde(rename = "dxf", default)]
355 pub dxfs: Vec<Dxf>,
356}
357
358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
360pub struct Dxf {
361 #[serde(rename = "font", skip_serializing_if = "Option::is_none")]
362 pub font: Option<Font>,
363
364 #[serde(rename = "numFmt", skip_serializing_if = "Option::is_none")]
365 pub num_fmt: Option<NumFmt>,
366
367 #[serde(rename = "fill", skip_serializing_if = "Option::is_none")]
368 pub fill: Option<Fill>,
369
370 #[serde(rename = "border", skip_serializing_if = "Option::is_none")]
371 pub border: Option<Border>,
372}
373
374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
376pub struct TableStyles {
377 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
378 pub count: Option<u32>,
379
380 #[serde(rename = "@defaultTableStyle", skip_serializing_if = "Option::is_none")]
381 pub default_table_style: Option<String>,
382
383 #[serde(rename = "@defaultPivotStyle", skip_serializing_if = "Option::is_none")]
384 pub default_pivot_style: Option<String>,
385}
386
387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
389pub struct Color {
390 #[serde(rename = "@auto", skip_serializing_if = "Option::is_none")]
391 pub auto: Option<bool>,
392
393 #[serde(rename = "@indexed", skip_serializing_if = "Option::is_none")]
394 pub indexed: Option<u32>,
395
396 #[serde(rename = "@rgb", skip_serializing_if = "Option::is_none")]
397 pub rgb: Option<String>,
398
399 #[serde(rename = "@theme", skip_serializing_if = "Option::is_none")]
400 pub theme: Option<u32>,
401
402 #[serde(rename = "@tint", skip_serializing_if = "Option::is_none")]
403 pub tint: Option<f64>,
404}
405
406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
408pub struct BoolVal {
409 #[serde(rename = "@val", skip_serializing_if = "Option::is_none")]
410 pub val: Option<bool>,
411}
412
413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
415pub struct Underline {
416 #[serde(rename = "@val", skip_serializing_if = "Option::is_none")]
417 pub val: Option<String>,
418}
419
420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
422pub struct FontSize {
423 #[serde(rename = "@val")]
424 pub val: f64,
425}
426
427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
429pub struct FontName {
430 #[serde(rename = "@val")]
431 pub val: String,
432}
433
434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
436pub struct FontFamily {
437 #[serde(rename = "@val")]
438 pub val: u32,
439}
440
441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
443pub struct FontScheme {
444 #[serde(rename = "@val")]
445 pub val: String,
446}
447
448impl Default for StyleSheet {
449 fn default() -> Self {
459 Self {
460 xmlns: namespaces::SPREADSHEET_ML.to_string(),
461 num_fmts: None,
462 fonts: Fonts {
463 count: Some(1),
464 fonts: vec![Font {
465 b: None,
466 i: None,
467 strike: None,
468 u: None,
469 sz: Some(FontSize { val: 11.0 }),
470 color: Some(Color {
471 auto: None,
472 indexed: None,
473 rgb: None,
474 theme: Some(1),
475 tint: None,
476 }),
477 name: Some(FontName {
478 val: "Calibri".to_string(),
479 }),
480 family: Some(FontFamily { val: 2 }),
481 scheme: Some(FontScheme {
482 val: "minor".to_string(),
483 }),
484 }],
485 },
486 fills: Fills {
487 count: Some(2),
488 fills: vec![
489 Fill {
490 pattern_fill: Some(PatternFill {
491 pattern_type: Some("none".to_string()),
492 fg_color: None,
493 bg_color: None,
494 }),
495 gradient_fill: None,
496 },
497 Fill {
498 pattern_fill: Some(PatternFill {
499 pattern_type: Some("gray125".to_string()),
500 fg_color: None,
501 bg_color: None,
502 }),
503 gradient_fill: None,
504 },
505 ],
506 },
507 borders: Borders {
508 count: Some(1),
509 borders: vec![Border {
510 diagonal_up: None,
511 diagonal_down: None,
512 left: Some(BorderSide {
513 style: None,
514 color: None,
515 }),
516 right: Some(BorderSide {
517 style: None,
518 color: None,
519 }),
520 top: Some(BorderSide {
521 style: None,
522 color: None,
523 }),
524 bottom: Some(BorderSide {
525 style: None,
526 color: None,
527 }),
528 diagonal: Some(BorderSide {
529 style: None,
530 color: None,
531 }),
532 }],
533 },
534 cell_style_xfs: Some(CellStyleXfs {
535 count: Some(1),
536 xfs: vec![Xf {
537 num_fmt_id: Some(0),
538 font_id: Some(0),
539 fill_id: Some(0),
540 border_id: Some(0),
541 xf_id: None,
542 apply_number_format: None,
543 apply_font: None,
544 apply_fill: None,
545 apply_border: None,
546 apply_alignment: None,
547 apply_protection: None,
548 quote_prefix: None,
549 alignment: None,
550 protection: None,
551 }],
552 }),
553 cell_xfs: CellXfs {
554 count: Some(1),
555 xfs: vec![Xf {
556 num_fmt_id: Some(0),
557 font_id: Some(0),
558 fill_id: Some(0),
559 border_id: Some(0),
560 xf_id: Some(0),
561 apply_number_format: None,
562 apply_font: None,
563 apply_fill: None,
564 apply_border: None,
565 apply_alignment: None,
566 apply_protection: None,
567 quote_prefix: None,
568 alignment: None,
569 protection: None,
570 }],
571 },
572 cell_styles: Some(CellStyles {
573 count: Some(1),
574 cell_styles: vec![CellStyle {
575 name: "Normal".to_string(),
576 xf_id: 0,
577 builtin_id: Some(0),
578 }],
579 }),
580 dxfs: None,
581 table_styles: None,
582 }
583 }
584}
585
586#[cfg(test)]
587mod tests {
588 use super::*;
589
590 #[test]
591 fn test_xf_apply_protection_and_quote_prefix_roundtrip() {
592 let xml = r#"<xf numFmtId="0" applyProtection="true" quotePrefix="true"><protection locked="false"/></xf>"#;
593
594 let xf: Xf = quick_xml::de::from_str(xml).unwrap();
595 assert_eq!(xf.apply_protection, Some(true));
596 assert_eq!(xf.quote_prefix, Some(true));
597
598 let serialized = quick_xml::se::to_string(&xf).unwrap();
599 assert!(serialized.contains("applyProtection=\"true\""));
600 assert!(serialized.contains("quotePrefix=\"true\""));
601 let reparsed: Xf = quick_xml::de::from_str(&serialized).unwrap();
602 assert_eq!(xf, reparsed);
603 }
604
605 #[test]
606 fn test_stylesheet_default() {
607 let ss = StyleSheet::default();
608 assert_eq!(ss.xmlns, namespaces::SPREADSHEET_ML);
609
610 assert_eq!(ss.fonts.fonts.len(), 1);
612 assert_eq!(ss.fonts.count, Some(1));
613 let font = &ss.fonts.fonts[0];
614 assert_eq!(font.sz.as_ref().unwrap().val, 11.0);
615 assert_eq!(font.name.as_ref().unwrap().val, "Calibri");
616 assert_eq!(font.family.as_ref().unwrap().val, 2);
617 assert_eq!(font.scheme.as_ref().unwrap().val, "minor");
618
619 assert_eq!(ss.fills.fills.len(), 2);
621 assert_eq!(ss.fills.count, Some(2));
622 assert_eq!(
623 ss.fills.fills[0]
624 .pattern_fill
625 .as_ref()
626 .unwrap()
627 .pattern_type,
628 Some("none".to_string())
629 );
630 assert_eq!(
631 ss.fills.fills[1]
632 .pattern_fill
633 .as_ref()
634 .unwrap()
635 .pattern_type,
636 Some("gray125".to_string())
637 );
638
639 assert_eq!(ss.borders.borders.len(), 1);
641 assert_eq!(ss.borders.count, Some(1));
642
643 assert!(ss.cell_style_xfs.is_some());
645 assert_eq!(ss.cell_style_xfs.as_ref().unwrap().xfs.len(), 1);
646
647 assert_eq!(ss.cell_xfs.xfs.len(), 1);
649 assert_eq!(ss.cell_xfs.count, Some(1));
650 let xf = &ss.cell_xfs.xfs[0];
651 assert_eq!(xf.num_fmt_id, Some(0));
652 assert_eq!(xf.font_id, Some(0));
653 assert_eq!(xf.fill_id, Some(0));
654 assert_eq!(xf.border_id, Some(0));
655
656 assert!(ss.cell_styles.is_some());
658 let styles = ss.cell_styles.as_ref().unwrap();
659 assert_eq!(styles.cell_styles.len(), 1);
660 assert_eq!(styles.cell_styles[0].name, "Normal");
661 assert_eq!(styles.cell_styles[0].xf_id, 0);
662 assert_eq!(styles.cell_styles[0].builtin_id, Some(0));
663 }
664
665 #[test]
666 fn test_stylesheet_roundtrip() {
667 let ss = StyleSheet::default();
668 let xml = quick_xml::se::to_string(&ss).unwrap();
669 let parsed: StyleSheet = quick_xml::de::from_str(&xml).unwrap();
670
671 assert_eq!(ss.xmlns, parsed.xmlns);
672 assert_eq!(ss.fonts.fonts.len(), parsed.fonts.fonts.len());
673 assert_eq!(ss.fills.fills.len(), parsed.fills.fills.len());
674 assert_eq!(ss.borders.borders.len(), parsed.borders.borders.len());
675 assert_eq!(ss.cell_xfs.xfs.len(), parsed.cell_xfs.xfs.len());
676 }
677
678 #[test]
679 fn test_stylesheet_serialize_structure() {
680 let ss = StyleSheet::default();
681 let xml = quick_xml::se::to_string(&ss).unwrap();
682 assert!(xml.contains("<styleSheet"));
683 assert!(xml.contains("<fonts"));
684 assert!(xml.contains("<font>"));
685 assert!(xml.contains("<fills"));
686 assert!(xml.contains("<fill>"));
687 assert!(xml.contains("<borders"));
688 assert!(xml.contains("<border>"));
689 assert!(xml.contains("<cellXfs"));
690 assert!(xml.contains("<xf "));
691 }
692
693 #[test]
694 fn test_parse_real_excel_styles_minimal() {
695 let xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
696<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
697 <fonts count="1">
698 <font>
699 <sz val="11"/>
700 <color theme="1"/>
701 <name val="Calibri"/>
702 <family val="2"/>
703 <scheme val="minor"/>
704 </font>
705 </fonts>
706 <fills count="2">
707 <fill><patternFill patternType="none"/></fill>
708 <fill><patternFill patternType="gray125"/></fill>
709 </fills>
710 <borders count="1">
711 <border>
712 <left/>
713 <right/>
714 <top/>
715 <bottom/>
716 <diagonal/>
717 </border>
718 </borders>
719 <cellStyleXfs count="1">
720 <xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
721 </cellStyleXfs>
722 <cellXfs count="1">
723 <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
724 </cellXfs>
725 <cellStyles count="1">
726 <cellStyle name="Normal" xfId="0" builtinId="0"/>
727 </cellStyles>
728</styleSheet>"#;
729
730 let parsed: StyleSheet = quick_xml::de::from_str(xml).unwrap();
731 assert_eq!(parsed.fonts.fonts.len(), 1);
732 assert_eq!(parsed.fonts.fonts[0].sz.as_ref().unwrap().val, 11.0);
733 assert_eq!(parsed.fonts.fonts[0].name.as_ref().unwrap().val, "Calibri");
734 assert_eq!(parsed.fills.fills.len(), 2);
735 assert_eq!(parsed.borders.borders.len(), 1);
736 assert_eq!(parsed.cell_xfs.xfs.len(), 1);
737 assert_eq!(parsed.cell_xfs.xfs[0].num_fmt_id, Some(0));
738 }
739
740 #[test]
741 fn test_font_with_bold_italic() {
742 let font = Font {
743 b: Some(BoolVal { val: None }),
744 i: Some(BoolVal { val: None }),
745 strike: None,
746 u: None,
747 sz: Some(FontSize { val: 12.0 }),
748 color: None,
749 name: Some(FontName {
750 val: "Arial".to_string(),
751 }),
752 family: None,
753 scheme: None,
754 };
755 let xml = quick_xml::se::to_string(&font).unwrap();
756 assert!(xml.contains("<b"));
757 assert!(xml.contains("<i"));
758 let parsed: Font = quick_xml::de::from_str(&xml).unwrap();
759 assert!(parsed.b.is_some());
760 assert!(parsed.i.is_some());
761 assert_eq!(parsed.sz.unwrap().val, 12.0);
762 }
763
764 #[test]
765 fn test_font_boolean_values_parse_ooxml_lexical_forms() {
766 let font: Font = quick_xml::de::from_str(
767 r#"<font><b val="0"/><i val="1"/><strike val="false"/></font>"#,
768 )
769 .unwrap();
770
771 assert_eq!(font.b.unwrap().val, Some(false));
772 assert_eq!(font.i.unwrap().val, Some(true));
773 assert_eq!(font.strike.unwrap().val, Some(false));
774 }
775
776 #[test]
777 fn test_font_boolean_value_without_val_remains_unspecified() {
778 let font: Font = quick_xml::de::from_str(r#"<font><b/></font>"#).unwrap();
779
780 assert_eq!(font.b.unwrap().val, None);
781 }
782
783 #[test]
784 fn test_color_rgb() {
785 let color = Color {
786 auto: None,
787 indexed: None,
788 rgb: Some("FF0000FF".to_string()),
789 theme: None,
790 tint: None,
791 };
792 let xml = quick_xml::se::to_string(&color).unwrap();
793 assert!(xml.contains("rgb=\"FF0000FF\""));
794 let parsed: Color = quick_xml::de::from_str(&xml).unwrap();
795 assert_eq!(parsed.rgb, Some("FF0000FF".to_string()));
796 }
797
798 #[test]
799 fn test_color_theme_with_tint() {
800 let color = Color {
801 auto: None,
802 indexed: None,
803 rgb: None,
804 theme: Some(4),
805 tint: Some(0.399_975_585_192_419_2),
806 };
807 let xml = quick_xml::se::to_string(&color).unwrap();
808 let parsed: Color = quick_xml::de::from_str(&xml).unwrap();
809 assert_eq!(parsed.theme, Some(4));
810 assert!(parsed.tint.is_some());
811 }
812
813 #[test]
814 fn test_border_with_style() {
815 let border = Border {
816 diagonal_up: None,
817 diagonal_down: None,
818 left: Some(BorderSide {
819 style: Some("thin".to_string()),
820 color: Some(Color {
821 auto: Some(true),
822 indexed: None,
823 rgb: None,
824 theme: None,
825 tint: None,
826 }),
827 }),
828 right: None,
829 top: None,
830 bottom: None,
831 diagonal: None,
832 };
833 let xml = quick_xml::se::to_string(&border).unwrap();
834 assert!(xml.contains("style=\"thin\""));
835 let parsed: Border = quick_xml::de::from_str(&xml).unwrap();
836 assert_eq!(
837 parsed.left.as_ref().unwrap().style,
838 Some("thin".to_string())
839 );
840 assert_eq!(
841 parsed.left.as_ref().unwrap().color.as_ref().unwrap().auto,
842 Some(true)
843 );
844 }
845
846 #[test]
847 fn test_xf_with_alignment() {
848 let xf = Xf {
849 num_fmt_id: Some(0),
850 font_id: Some(0),
851 fill_id: Some(0),
852 border_id: Some(0),
853 xf_id: Some(0),
854 apply_number_format: None,
855 apply_font: None,
856 apply_fill: None,
857 apply_border: None,
858 apply_alignment: Some(true),
859 apply_protection: None,
860 quote_prefix: None,
861 alignment: Some(Alignment {
862 horizontal: Some("center".to_string()),
863 vertical: Some("center".to_string()),
864 wrap_text: Some(true),
865 text_rotation: None,
866 indent: None,
867 shrink_to_fit: None,
868 }),
869 protection: None,
870 };
871 let xml = quick_xml::se::to_string(&xf).unwrap();
872 assert!(xml.contains("alignment"));
873 assert!(xml.contains("horizontal=\"center\""));
874 let parsed: Xf = quick_xml::de::from_str(&xml).unwrap();
875 assert!(parsed.alignment.is_some());
876 let align = parsed.alignment.unwrap();
877 assert_eq!(align.horizontal, Some("center".to_string()));
878 assert_eq!(align.vertical, Some("center".to_string()));
879 assert_eq!(align.wrap_text, Some(true));
880 }
881
882 #[test]
883 fn test_num_fmt() {
884 let nf = NumFmt {
885 num_fmt_id: 164,
886 format_code: "#,##0.00_ ".to_string(),
887 };
888 let xml = quick_xml::se::to_string(&nf).unwrap();
889 let parsed: NumFmt = quick_xml::de::from_str(&xml).unwrap();
890 assert_eq!(parsed.num_fmt_id, 164);
891 assert_eq!(parsed.format_code, "#,##0.00_ ");
892 }
893
894 #[test]
895 fn test_optional_fields_not_serialized() {
896 let ss = StyleSheet::default();
897 let xml = quick_xml::se::to_string(&ss).unwrap();
898 assert!(!xml.contains("numFmts"));
900 assert!(!xml.contains("dxfs"));
902 assert!(!xml.contains("tableStyles"));
904 }
905
906 #[test]
907 fn test_cell_style_roundtrip() {
908 let style = CellStyle {
909 name: "Heading 1".to_string(),
910 xf_id: 1,
911 builtin_id: Some(16),
912 };
913 let xml = quick_xml::se::to_string(&style).unwrap();
914 let parsed: CellStyle = quick_xml::de::from_str(&xml).unwrap();
915 assert_eq!(parsed.name, "Heading 1");
916 assert_eq!(parsed.xf_id, 1);
917 assert_eq!(parsed.builtin_id, Some(16));
918 }
919}