Skip to main content

sheetkit_xml/
styles.rs

1//! Styles XML schema structures.
2//!
3//! Represents `xl/styles.xml` in the OOXML package.
4//! Minimal implementation for Phase 1 with Excel-compatible default styles.
5
6use serde::{Deserialize, Serialize};
7
8use crate::namespaces;
9
10/// Stylesheet root element (`xl/styles.xml`).
11#[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/// Number formats container.
46#[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/// Individual number format.
56#[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/// Fonts container.
66#[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/// Individual font definition.
76#[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/// Fills container.
107#[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/// Individual fill definition.
117#[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/// Pattern fill definition.
127#[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/// Gradient fill definition.
140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
141pub struct GradientFill {
142    /// Gradient type: "linear" or "path".
143    #[serde(rename = "@type", skip_serializing_if = "Option::is_none")]
144    pub gradient_type: Option<String>,
145
146    /// Rotation angle in degrees for linear gradients.
147    #[serde(rename = "@degree", skip_serializing_if = "Option::is_none")]
148    pub degree: Option<f64>,
149
150    /// Left coordinate for path gradients (0.0-1.0).
151    #[serde(rename = "@left", skip_serializing_if = "Option::is_none")]
152    pub left: Option<f64>,
153
154    /// Right coordinate for path gradients (0.0-1.0).
155    #[serde(rename = "@right", skip_serializing_if = "Option::is_none")]
156    pub right: Option<f64>,
157
158    /// Top coordinate for path gradients (0.0-1.0).
159    #[serde(rename = "@top", skip_serializing_if = "Option::is_none")]
160    pub top: Option<f64>,
161
162    /// Bottom coordinate for path gradients (0.0-1.0).
163    #[serde(rename = "@bottom", skip_serializing_if = "Option::is_none")]
164    pub bottom: Option<f64>,
165
166    /// Gradient stops.
167    #[serde(rename = "stop", default)]
168    pub stops: Vec<GradientStop>,
169}
170
171/// A single gradient stop with position and color.
172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
173pub struct GradientStop {
174    /// Position of this stop (0.0-1.0).
175    #[serde(rename = "@position")]
176    pub position: f64,
177
178    /// Color at this stop.
179    pub color: Color,
180}
181
182/// Borders container.
183#[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/// Individual border definition.
193#[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/// Border side definition.
218#[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/// Cell style XFs container (base style formats).
228#[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/// Cell XFs container (applied cell formats).
238#[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/// Cell format entry.
248#[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/// Cell alignment.
294#[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/// Cell protection.
316#[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/// Cell styles container.
326#[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/// Individual named cell style.
336#[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/// Differential formats container (for conditional formatting).
349#[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/// Individual differential format.
359#[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/// Table styles container.
375#[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/// Color definition (used across fonts, fills, borders).
388#[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/// Boolean value wrapper (used for bold, italic, etc.).
407#[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/// Underline.
414#[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/// Font size.
421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
422pub struct FontSize {
423    #[serde(rename = "@val")]
424    pub val: f64,
425}
426
427/// Font name.
428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
429pub struct FontName {
430    #[serde(rename = "@val")]
431    pub val: String,
432}
433
434/// Font family.
435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
436pub struct FontFamily {
437    #[serde(rename = "@val")]
438    pub val: u32,
439}
440
441/// Font scheme (theme-based).
442#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
443pub struct FontScheme {
444    #[serde(rename = "@val")]
445    pub val: String,
446}
447
448impl Default for StyleSheet {
449    /// Creates an Excel-compatible minimal default stylesheet.
450    ///
451    /// This includes:
452    /// - 1 default font (Calibri, 11pt)
453    /// - 2 required fills (none, gray125)
454    /// - 1 empty border
455    /// - 1 cellStyleXf
456    /// - 1 cellXf (Normal style)
457    /// - 1 cellStyle ("Normal")
458    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        // 1 default font
611        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        // 2 required fills (none, gray125)
620        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        // 1 border
640        assert_eq!(ss.borders.borders.len(), 1);
641        assert_eq!(ss.borders.count, Some(1));
642
643        // 1 cellStyleXf
644        assert!(ss.cell_style_xfs.is_some());
645        assert_eq!(ss.cell_style_xfs.as_ref().unwrap().xfs.len(), 1);
646
647        // 1 cellXf
648        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        // 1 cellStyle
657        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        // numFmts is None, so it should not appear
899        assert!(!xml.contains("numFmts"));
900        // dxfs is None
901        assert!(!xml.contains("dxfs"));
902        // tableStyles is None
903        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}