1use sheetkit_xml::worksheet::{CellTypeTag, Row, WorksheetXml};
8
9use crate::cell::CellValue;
10use crate::error::{Error, Result};
11use crate::raw_transfer::SharedFollowers;
12use crate::sst::SharedStringTable;
13use crate::traversal::{check_limit, TraversalLimits};
14use crate::utils::cell_ref::{cell_name_to_coordinates, compact_cell_ref};
15use crate::utils::constants::{MAX_COLUMNS, MAX_ROWS, MAX_ROW_HEIGHT};
16
17#[allow(clippy::type_complexity)]
29pub fn get_rows(
30 ws: &WorksheetXml,
31 sst: &SharedStringTable,
32 style_is_date: &[bool],
33) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
34 get_rows_with_limits(ws, sst, style_is_date, TraversalLimits::default())
35}
36
37#[allow(clippy::type_complexity)]
39pub fn get_rows_with_limits(
40 ws: &WorksheetXml,
41 sst: &SharedStringTable,
42 style_is_date: &[bool],
43 limits: TraversalLimits,
44) -> Result<Vec<(u32, Vec<(u32, CellValue)>)>> {
45 let mut row_count = 0u64;
46 let mut column_count = 0u64;
47 let mut cell_count = 0u64;
48 let mut retained_bytes = 0u64;
49 let mut occupied_columns = [false; MAX_COLUMNS as usize];
50
51 for row in &ws.sheet_data.rows {
52 if row.cells.is_empty() {
53 continue;
54 }
55 row_count = row_count.saturating_add(1);
56 check_limit(
57 crate::resource::ResourceDimension::RowCount,
58 limits.max_rows(),
59 row_count,
60 )?;
61 retained_bytes = retained_bytes.saturating_add(
62 u64::try_from(std::mem::size_of::<(u32, Vec<(u32, CellValue)>)>()).unwrap_or(u64::MAX),
63 );
64
65 for cell in &row.cells {
66 let col_num = if cell.col > 0 {
67 cell.col
68 } else {
69 cell_name_to_coordinates(cell.r.as_str())?.0
70 };
71 if col_num == 0 || col_num > MAX_COLUMNS {
72 return Err(Error::InvalidColumnNumber(col_num));
73 }
74 let column_slot = usize::try_from(col_num - 1)
75 .map_err(|_| Error::Internal("column index is not addressable".to_string()))?;
76 if !occupied_columns[column_slot] {
77 occupied_columns[column_slot] = true;
78 column_count = column_count.saturating_add(1);
79 check_limit(
80 crate::resource::ResourceDimension::ColumnCount,
81 limits.max_columns(),
82 column_count,
83 )?;
84 }
85 cell_count = cell_count.saturating_add(1);
86 check_limit(
87 crate::resource::ResourceDimension::CellCount,
88 limits.max_cells(),
89 cell_count,
90 )?;
91 retained_bytes = retained_bytes
92 .saturating_add(
93 u64::try_from(std::mem::size_of::<(u32, CellValue)>()).unwrap_or(u64::MAX),
94 )
95 .saturating_add(cell_cloned_payload_bytes(cell, sst));
96 check_limit(
97 crate::resource::ResourceDimension::RetainedBytes,
98 limits.max_output_bytes(),
99 retained_bytes,
100 )?;
101 }
102 }
103
104 let mut result = Vec::new();
105 result
106 .try_reserve_exact(
107 usize::try_from(row_count)
108 .map_err(|_| Error::Internal("row result size is not addressable".to_string()))?,
109 )
110 .map_err(|_| Error::Internal("row result allocation failed".to_string()))?;
111
112 let mut followers = SharedFollowers::new(ws, limits, retained_bytes, None)?;
113 for row in &ws.sheet_data.rows {
114 if row.cells.is_empty() {
115 continue;
116 }
117
118 let mut cells = Vec::new();
119 cells
120 .try_reserve_exact(row.cells.len())
121 .map_err(|_| Error::Internal("cell result allocation failed".to_string()))?;
122 for cell in &row.cells {
123 let col_num = if cell.col > 0 {
124 cell.col
125 } else {
126 cell_name_to_coordinates(cell.r.as_str())?.0
127 };
128 let mut value = resolve_cell_value(cell, sst, style_is_date);
129 followers.resolve(&mut value, cell)?;
130 cells.push((col_num, value));
131 }
132
133 result.push((row.r, cells));
134 }
135
136 Ok(result)
137}
138
139pub(crate) fn cell_cloned_payload_bytes(
140 cell: &sheetkit_xml::worksheet::Cell,
141 sst: &SharedStringTable,
142) -> u64 {
143 let mut bytes = cell
144 .f
145 .as_ref()
146 .and_then(|formula| formula.value.as_ref())
147 .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX));
148 if cell.f.is_some() {
149 bytes = bytes
150 .saturating_add(u64::try_from(std::mem::size_of::<CellValue>()).unwrap_or(u64::MAX));
151 }
152 let value_bytes = match (cell.t, cell.v.as_deref()) {
153 (CellTypeTag::SharedString, Some(index)) => index
154 .parse::<usize>()
155 .ok()
156 .and_then(|index| sst.get(index))
157 .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX)),
158 (CellTypeTag::FormulaString | CellTypeTag::Error, Some(value)) => {
159 u64::try_from(value.len()).unwrap_or(u64::MAX)
160 }
161 (CellTypeTag::InlineString, _) => cell
162 .is
163 .as_ref()
164 .and_then(|value| value.t.as_ref())
165 .map_or(0u64, |value| u64::try_from(value.len()).unwrap_or(u64::MAX)),
166 _ => 0,
167 };
168 bytes.saturating_add(value_bytes)
169}
170
171pub fn resolve_sst_value(sst: &SharedStringTable, index: &str) -> CellValue {
174 let idx: usize = match index.parse() {
175 Ok(i) => i,
176 Err(_) => return CellValue::Empty,
177 };
178 let s = sst.get(idx).unwrap_or("").to_string();
179 CellValue::String(s)
180}
181
182pub fn parse_cell_type_value(
194 cell_type: CellTypeTag,
195 value: Option<&str>,
196 formula: Option<&sheetkit_xml::worksheet::CellFormula>,
197 inline_str: Option<&sheetkit_xml::worksheet::InlineString>,
198 sst: &SharedStringTable,
199 promote_number_to_date: bool,
200) -> CellValue {
201 if let Some(f) = formula {
202 let expr = f.value.clone().unwrap_or_default();
203 let cached = match (cell_type, value) {
204 (CellTypeTag::Boolean, Some(v)) => Some(Box::new(CellValue::Bool(v == "1"))),
205 (CellTypeTag::Error, Some(v)) => Some(Box::new(classify_error_value(v))),
206 (CellTypeTag::FormulaString, Some(v)) => {
207 Some(Box::new(CellValue::String(v.to_string())))
208 }
209 (CellTypeTag::SharedString, Some(v)) => Some(Box::new(resolve_sst_value(sst, v))),
210 (CellTypeTag::InlineString, _) => Some(Box::new(CellValue::String(
211 inline_str
212 .and_then(|value| value.t.clone())
213 .unwrap_or_default(),
214 ))),
215 (CellTypeTag::None | CellTypeTag::Number, Some(v)) => {
216 v.parse::<f64>().ok().map(|number| {
217 Box::new(if promote_number_to_date {
218 CellValue::Date(number)
219 } else {
220 CellValue::Number(number)
221 })
222 })
223 }
224 (_, Some(v)) => v
225 .parse::<f64>()
226 .ok()
227 .map(|number| Box::new(CellValue::Number(number))),
228 _ => None,
229 };
230 return CellValue::Formula {
231 expr,
232 result: cached,
233 };
234 }
235
236 match (cell_type, value) {
237 (CellTypeTag::SharedString, Some(v)) => resolve_sst_value(sst, v),
238 (CellTypeTag::Boolean, Some(v)) => CellValue::Bool(v == "1"),
239 (CellTypeTag::Error, Some(v)) => classify_error_value(v),
240 (CellTypeTag::InlineString, _) => {
241 let s = inline_str.and_then(|is| is.t.clone()).unwrap_or_default();
242 CellValue::String(s)
243 }
244 (CellTypeTag::FormulaString, Some(v)) => CellValue::String(v.to_string()),
245 (CellTypeTag::None | CellTypeTag::Number, Some(v)) => match v.parse::<f64>() {
246 Ok(n) => {
247 if promote_number_to_date {
248 CellValue::Date(n)
249 } else {
250 CellValue::Number(n)
251 }
252 }
253 Err(_) => CellValue::Empty,
254 },
255 _ => CellValue::Empty,
256 }
257}
258
259fn classify_error_value(value: &str) -> CellValue {
260 if crate::output::is_excel_error_token(value) {
261 CellValue::Error(value.to_string())
262 } else {
263 CellValue::String(value.to_string())
264 }
265}
266
267pub fn resolve_cell_value(
276 cell: &sheetkit_xml::worksheet::Cell,
277 sst: &SharedStringTable,
278 style_is_date: &[bool],
279) -> CellValue {
280 let promote_number_to_date = cell
281 .s
282 .and_then(|idx| style_is_date.get(idx as usize).copied())
283 .unwrap_or(false);
284 parse_cell_type_value(
285 cell.t,
286 cell.v.as_deref(),
287 cell.f.as_deref(),
288 cell.is.as_deref(),
289 sst,
290 promote_number_to_date,
291 )
292}
293
294pub fn insert_rows(ws: &mut WorksheetXml, start_row: u32, count: u32) -> Result<()> {
300 if start_row == 0 {
301 return Err(Error::InvalidRowNumber(0));
302 }
303 if count == 0 {
304 return Ok(());
305 }
306 let max_existing = ws.sheet_data.rows.iter().map(|r| r.r).max().unwrap_or(0);
308 let furthest = max_existing.max(start_row);
309 if furthest.checked_add(count).is_none_or(|v| v > MAX_ROWS) {
310 return Err(Error::InvalidRowNumber(furthest.saturating_add(count)));
311 }
312
313 for row in ws.sheet_data.rows.iter_mut().rev() {
316 if row.r >= start_row {
317 let new_row_num = row.r + count;
318 shift_row_cells(row, new_row_num)?;
319 row.r = new_row_num;
320 }
321 }
322
323 Ok(())
324}
325
326pub fn remove_row(ws: &mut WorksheetXml, row: u32) -> Result<()> {
328 if row == 0 {
329 return Err(Error::InvalidRowNumber(0));
330 }
331
332 if let Ok(idx) = ws.sheet_data.rows.binary_search_by_key(&row, |r| r.r) {
334 ws.sheet_data.rows.remove(idx);
335 }
336
337 for r in ws.sheet_data.rows.iter_mut() {
339 if r.r > row {
340 let new_row_num = r.r - 1;
341 shift_row_cells(r, new_row_num)?;
342 r.r = new_row_num;
343 }
344 }
345
346 Ok(())
347}
348
349pub fn duplicate_row(ws: &mut WorksheetXml, row: u32) -> Result<()> {
351 duplicate_row_to(ws, row, row + 1)
352}
353
354pub fn duplicate_row_to(ws: &mut WorksheetXml, row: u32, target: u32) -> Result<()> {
357 if row == 0 {
358 return Err(Error::InvalidRowNumber(0));
359 }
360 if target == 0 {
361 return Err(Error::InvalidRowNumber(0));
362 }
363 if target > MAX_ROWS {
364 return Err(Error::InvalidRowNumber(target));
365 }
366
367 let source = ws
369 .sheet_data
370 .rows
371 .binary_search_by_key(&row, |r| r.r)
372 .ok()
373 .map(|idx| ws.sheet_data.rows[idx].clone())
374 .ok_or(Error::InvalidRowNumber(row))?;
375
376 insert_rows(ws, target, 1)?;
378
379 let mut new_row = source;
381 shift_row_cells(&mut new_row, target)?;
382 new_row.r = target;
383
384 match ws.sheet_data.rows.binary_search_by_key(&target, |r| r.r) {
386 Ok(idx) => ws.sheet_data.rows[idx] = new_row,
387 Err(pos) => ws.sheet_data.rows.insert(pos, new_row),
388 }
389
390 Ok(())
391}
392
393pub fn set_row_height(ws: &mut WorksheetXml, row: u32, height: f64) -> Result<()> {
397 if row == 0 || row > MAX_ROWS {
398 return Err(Error::InvalidRowNumber(row));
399 }
400 if !(0.0..=MAX_ROW_HEIGHT).contains(&height) {
401 return Err(Error::RowHeightExceeded {
402 height,
403 max: MAX_ROW_HEIGHT,
404 });
405 }
406
407 let r = find_or_create_row(ws, row);
408 r.ht = Some(height);
409 r.custom_height = Some(true);
410 Ok(())
411}
412
413pub fn get_row_height(ws: &WorksheetXml, row: u32) -> Option<f64> {
416 ws.sheet_data
417 .rows
418 .binary_search_by_key(&row, |r| r.r)
419 .ok()
420 .and_then(|idx| ws.sheet_data.rows[idx].ht)
421}
422
423pub fn set_row_visible(ws: &mut WorksheetXml, row: u32, visible: bool) -> Result<()> {
425 if row == 0 || row > MAX_ROWS {
426 return Err(Error::InvalidRowNumber(row));
427 }
428
429 let r = find_or_create_row(ws, row);
430 r.hidden = if visible { None } else { Some(true) };
431 Ok(())
432}
433
434pub fn get_row_visible(ws: &WorksheetXml, row: u32) -> bool {
439 ws.sheet_data
440 .rows
441 .binary_search_by_key(&row, |r| r.r)
442 .ok()
443 .and_then(|idx| ws.sheet_data.rows[idx].hidden)
444 .map(|h| !h)
445 .unwrap_or(true)
446}
447
448pub fn get_row_outline_level(ws: &WorksheetXml, row: u32) -> u8 {
450 ws.sheet_data
451 .rows
452 .binary_search_by_key(&row, |r| r.r)
453 .ok()
454 .and_then(|idx| ws.sheet_data.rows[idx].outline_level)
455 .unwrap_or(0)
456}
457
458pub fn set_row_outline_level(ws: &mut WorksheetXml, row: u32, level: u8) -> Result<()> {
462 if row == 0 || row > MAX_ROWS {
463 return Err(Error::InvalidRowNumber(row));
464 }
465 if level > 7 {
466 return Err(Error::OutlineLevelExceeded { level, max: 7 });
467 }
468
469 let r = find_or_create_row(ws, row);
470 r.outline_level = if level == 0 { None } else { Some(level) };
471 Ok(())
472}
473
474pub fn set_row_style(ws: &mut WorksheetXml, row: u32, style_id: u32) -> Result<()> {
479 if row == 0 || row > MAX_ROWS {
480 return Err(Error::InvalidRowNumber(row));
481 }
482
483 let r = find_or_create_row(ws, row);
484 r.s = Some(style_id);
485 r.custom_format = if style_id == 0 { None } else { Some(true) };
486
487 for cell in r.cells.iter_mut() {
489 cell.s = Some(style_id);
490 }
491 Ok(())
492}
493
494pub fn get_row_style(ws: &WorksheetXml, row: u32) -> u32 {
497 ws.sheet_data
498 .rows
499 .binary_search_by_key(&row, |r| r.r)
500 .ok()
501 .and_then(|idx| ws.sheet_data.rows[idx].s)
502 .unwrap_or(0)
503}
504
505fn shift_row_cells(row: &mut Row, new_row_num: u32) -> Result<()> {
507 for cell in row.cells.iter_mut() {
508 let (col, _) = cell_name_to_coordinates(cell.r.as_str())?;
509 cell.r = compact_cell_ref(col, new_row_num)?;
510 cell.col = col;
511 }
512 Ok(())
513}
514
515fn find_or_create_row(ws: &mut WorksheetXml, row: u32) -> &mut Row {
518 match ws.sheet_data.rows.binary_search_by_key(&row, |r| r.r) {
519 Ok(idx) => &mut ws.sheet_data.rows[idx],
520 Err(pos) => {
521 ws.sheet_data.rows.insert(
522 pos,
523 Row {
524 r: row,
525 spans: None,
526 s: None,
527 custom_format: None,
528 ht: None,
529 hidden: None,
530 custom_height: None,
531 outline_level: None,
532 cells: vec![],
533 },
534 );
535 &mut ws.sheet_data.rows[pos]
536 }
537 }
538}
539
540#[cfg(test)]
541#[allow(clippy::field_reassign_with_default)]
542mod tests {
543 use super::*;
544 use sheetkit_xml::worksheet::{Cell, CellTypeTag, SheetData};
545
546 fn sample_ws() -> WorksheetXml {
548 let mut ws = WorksheetXml::default();
549 ws.sheet_data = SheetData {
550 rows: vec![
551 Row {
552 r: 1,
553 spans: None,
554 s: None,
555 custom_format: None,
556 ht: None,
557 hidden: None,
558 custom_height: None,
559 outline_level: None,
560 cells: vec![
561 Cell {
562 r: "A1".try_into().unwrap(),
563 col: 1,
564 s: None,
565 t: CellTypeTag::None,
566 v: Some("10".to_string()),
567 f: None,
568 is: None,
569 },
570 Cell {
571 r: "B1".try_into().unwrap(),
572 col: 2,
573 s: None,
574 t: CellTypeTag::None,
575 v: Some("20".to_string()),
576 f: None,
577 is: None,
578 },
579 ],
580 },
581 Row {
582 r: 2,
583 spans: None,
584 s: None,
585 custom_format: None,
586 ht: None,
587 hidden: None,
588 custom_height: None,
589 outline_level: None,
590 cells: vec![Cell {
591 r: "A2".try_into().unwrap(),
592 col: 1,
593 s: None,
594 t: CellTypeTag::None,
595 v: Some("30".to_string()),
596 f: None,
597 is: None,
598 }],
599 },
600 Row {
601 r: 5,
602 spans: None,
603 s: None,
604 custom_format: None,
605 ht: None,
606 hidden: None,
607 custom_height: None,
608 outline_level: None,
609 cells: vec![Cell {
610 r: "C5".try_into().unwrap(),
611 col: 3,
612 s: None,
613 t: CellTypeTag::None,
614 v: Some("50".to_string()),
615 f: None,
616 is: None,
617 }],
618 },
619 ],
620 };
621 ws
622 }
623
624 #[test]
625 fn bounded_rows_charge_repeated_shared_strings_before_cloning() {
626 let mut sst = SharedStringTable::new();
627 sst.add(&"x".repeat(1_024));
628 let mut ws = WorksheetXml::default();
629 ws.sheet_data.rows.push(Row {
630 r: 1,
631 spans: None,
632 s: None,
633 custom_format: None,
634 ht: None,
635 hidden: None,
636 custom_height: None,
637 outline_level: None,
638 cells: vec![
639 Cell {
640 r: "A1".try_into().unwrap(),
641 col: 1,
642 s: None,
643 t: CellTypeTag::SharedString,
644 v: Some("0".to_string()),
645 f: None,
646 is: None,
647 },
648 Cell {
649 r: "B1".try_into().unwrap(),
650 col: 2,
651 s: None,
652 t: CellTypeTag::SharedString,
653 v: Some("0".to_string()),
654 f: None,
655 is: None,
656 },
657 ],
658 });
659 let exact = u64::try_from(std::mem::size_of::<(u32, Vec<(u32, CellValue)>)>()).unwrap()
660 + 2 * (u64::try_from(std::mem::size_of::<(u32, CellValue)>()).unwrap() + 1_024);
661 let exact_limits = TraversalLimits::new(1, 2, 2, exact).unwrap();
662
663 let bounded = get_rows_with_limits(&ws, &sst, &[], exact_limits).unwrap();
664 assert_eq!(bounded, get_rows(&ws, &sst, &[]).unwrap());
665
666 let error = get_rows_with_limits(
667 &ws,
668 &sst,
669 &[],
670 TraversalLimits::new(1, 2, 2, exact - 1).unwrap(),
671 )
672 .unwrap_err();
673 let Error::ResourceLimitExceeded(metadata) = error else {
674 panic!("expected resource limit error");
675 };
676 assert_eq!(
677 metadata.dimension(),
678 crate::ResourceDimension::RetainedBytes
679 );
680 assert_eq!(metadata.limit(), exact - 1);
681 assert_eq!(metadata.observed(), exact);
682
683 let error = get_rows_with_limits(
684 &ws,
685 &sst,
686 &[],
687 TraversalLimits::new(1, 1, 2, exact).unwrap(),
688 )
689 .unwrap_err();
690 let Error::ResourceLimitExceeded(metadata) = error else {
691 panic!("expected resource limit error");
692 };
693 assert_eq!(metadata.dimension(), crate::ResourceDimension::ColumnCount);
694 assert_eq!(metadata.limit(), 1);
695 assert_eq!(metadata.observed(), 2);
696 }
697
698 #[test]
699 fn test_insert_rows_shifts_cells_down() {
700 let mut ws = sample_ws();
701 insert_rows(&mut ws, 2, 3).unwrap();
702
703 assert_eq!(ws.sheet_data.rows[0].r, 1);
705 assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
706
707 assert_eq!(ws.sheet_data.rows[1].r, 5);
709 assert_eq!(ws.sheet_data.rows[1].cells[0].r, "A5");
710
711 assert_eq!(ws.sheet_data.rows[2].r, 8);
713 assert_eq!(ws.sheet_data.rows[2].cells[0].r, "C8");
714 }
715
716 #[test]
717 fn test_insert_rows_at_row_1() {
718 let mut ws = sample_ws();
719 insert_rows(&mut ws, 1, 2).unwrap();
720
721 assert_eq!(ws.sheet_data.rows[0].r, 3);
723 assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A3");
724 assert_eq!(ws.sheet_data.rows[1].r, 4);
725 assert_eq!(ws.sheet_data.rows[2].r, 7);
726 }
727
728 #[test]
729 fn test_insert_rows_count_zero_is_noop() {
730 let mut ws = sample_ws();
731 insert_rows(&mut ws, 1, 0).unwrap();
732 assert_eq!(ws.sheet_data.rows[0].r, 1);
733 assert_eq!(ws.sheet_data.rows[1].r, 2);
734 assert_eq!(ws.sheet_data.rows[2].r, 5);
735 }
736
737 #[test]
738 fn test_insert_rows_row_zero_returns_error() {
739 let mut ws = sample_ws();
740 let result = insert_rows(&mut ws, 0, 1);
741 assert!(result.is_err());
742 }
743
744 #[test]
745 fn test_insert_rows_beyond_max_returns_error() {
746 let mut ws = WorksheetXml::default();
747 ws.sheet_data.rows.push(Row {
748 r: MAX_ROWS,
749 spans: None,
750 s: None,
751 custom_format: None,
752 ht: None,
753 hidden: None,
754 custom_height: None,
755 outline_level: None,
756 cells: vec![],
757 });
758 let result = insert_rows(&mut ws, 1, 1);
759 assert!(result.is_err());
760 }
761
762 #[test]
763 fn test_insert_rows_u32_overflow_returns_error_without_mutation() {
764 let mut ws = sample_ws();
765 let before = ws.clone();
766
767 let result = insert_rows(&mut ws, 1, u32::MAX);
768
769 assert!(matches!(result, Err(Error::InvalidRowNumber(u32::MAX))));
770 assert_eq!(ws, before);
771 }
772
773 #[test]
774 fn test_insert_rows_on_empty_sheet() {
775 let mut ws = WorksheetXml::default();
776 insert_rows(&mut ws, 1, 5).unwrap();
777 assert!(ws.sheet_data.rows.is_empty());
778 }
779
780 #[test]
781 fn test_remove_row_shifts_up() {
782 let mut ws = sample_ws();
783 remove_row(&mut ws, 2).unwrap();
784
785 assert_eq!(ws.sheet_data.rows[0].r, 1);
787 assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
788
789 assert_eq!(ws.sheet_data.rows.len(), 2);
791 assert_eq!(ws.sheet_data.rows[1].r, 4);
792 assert_eq!(ws.sheet_data.rows[1].cells[0].r, "C4");
793 }
794
795 #[test]
796 fn test_remove_first_row() {
797 let mut ws = sample_ws();
798 remove_row(&mut ws, 1).unwrap();
799
800 assert_eq!(ws.sheet_data.rows[0].r, 1);
802 assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
803 assert_eq!(ws.sheet_data.rows[1].r, 4);
804 }
805
806 #[test]
807 fn test_remove_nonexistent_row_still_shifts() {
808 let mut ws = sample_ws();
809 remove_row(&mut ws, 3).unwrap();
811 assert_eq!(ws.sheet_data.rows.len(), 3); assert_eq!(ws.sheet_data.rows[2].r, 4); }
814
815 #[test]
816 fn test_remove_row_zero_returns_error() {
817 let mut ws = sample_ws();
818 let result = remove_row(&mut ws, 0);
819 assert!(result.is_err());
820 }
821
822 #[test]
823 fn test_duplicate_row_inserts_copy_below() {
824 let mut ws = sample_ws();
825 duplicate_row(&mut ws, 1).unwrap();
826
827 assert_eq!(ws.sheet_data.rows[0].r, 1);
829 assert_eq!(ws.sheet_data.rows[0].cells[0].r, "A1");
830 assert_eq!(ws.sheet_data.rows[0].cells[0].v, Some("10".to_string()));
831
832 assert_eq!(ws.sheet_data.rows[1].r, 2);
834 assert_eq!(ws.sheet_data.rows[1].cells[0].r, "A2");
835 assert_eq!(ws.sheet_data.rows[1].cells[0].v, Some("10".to_string()));
836 assert_eq!(ws.sheet_data.rows[1].cells.len(), 2);
837
838 assert_eq!(ws.sheet_data.rows[2].r, 3);
840 assert_eq!(ws.sheet_data.rows[2].cells[0].r, "A3");
841 }
842
843 #[test]
844 fn test_duplicate_row_to_specific_target() {
845 let mut ws = sample_ws();
846 duplicate_row_to(&mut ws, 1, 5).unwrap();
847
848 assert_eq!(ws.sheet_data.rows[0].r, 1);
850
851 let row5 = ws.sheet_data.rows.iter().find(|r| r.r == 5).unwrap();
853 assert_eq!(row5.cells[0].r, "A5");
854 assert_eq!(row5.cells[0].v, Some("10".to_string()));
855
856 let row6 = ws.sheet_data.rows.iter().find(|r| r.r == 6).unwrap();
858 assert_eq!(row6.cells[0].r, "C6");
859 }
860
861 #[test]
862 fn test_duplicate_nonexistent_row_returns_error() {
863 let mut ws = sample_ws();
864 let result = duplicate_row(&mut ws, 99);
865 assert!(result.is_err());
866 }
867
868 #[test]
869 fn test_set_and_get_row_height() {
870 let mut ws = sample_ws();
871 set_row_height(&mut ws, 1, 25.5).unwrap();
872
873 assert_eq!(get_row_height(&ws, 1), Some(25.5));
874 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
875 assert_eq!(row.custom_height, Some(true));
876 }
877
878 #[test]
879 fn test_set_row_height_creates_row_if_missing() {
880 let mut ws = WorksheetXml::default();
881 set_row_height(&mut ws, 10, 30.0).unwrap();
882
883 assert_eq!(get_row_height(&ws, 10), Some(30.0));
884 assert_eq!(ws.sheet_data.rows.len(), 1);
885 assert_eq!(ws.sheet_data.rows[0].r, 10);
886 }
887
888 #[test]
889 fn test_set_row_height_zero_is_valid() {
890 let mut ws = WorksheetXml::default();
891 set_row_height(&mut ws, 1, 0.0).unwrap();
892 assert_eq!(get_row_height(&ws, 1), Some(0.0));
893 }
894
895 #[test]
896 fn test_set_row_height_max_is_valid() {
897 let mut ws = WorksheetXml::default();
898 set_row_height(&mut ws, 1, 409.0).unwrap();
899 assert_eq!(get_row_height(&ws, 1), Some(409.0));
900 }
901
902 #[test]
903 fn test_set_row_height_exceeds_max_returns_error() {
904 let mut ws = WorksheetXml::default();
905 let result = set_row_height(&mut ws, 1, 410.0);
906 assert!(result.is_err());
907 assert!(matches!(
908 result.unwrap_err(),
909 Error::RowHeightExceeded { .. }
910 ));
911 }
912
913 #[test]
914 fn test_set_row_height_negative_returns_error() {
915 let mut ws = WorksheetXml::default();
916 let result = set_row_height(&mut ws, 1, -1.0);
917 assert!(result.is_err());
918 }
919
920 #[test]
921 fn test_set_row_height_row_zero_returns_error() {
922 let mut ws = WorksheetXml::default();
923 let result = set_row_height(&mut ws, 0, 15.0);
924 assert!(result.is_err());
925 }
926
927 #[test]
928 fn test_get_row_height_nonexistent_returns_none() {
929 let ws = WorksheetXml::default();
930 assert_eq!(get_row_height(&ws, 99), None);
931 }
932
933 #[test]
934 fn test_set_row_hidden() {
935 let mut ws = sample_ws();
936 set_row_visible(&mut ws, 1, false).unwrap();
937
938 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
939 assert_eq!(row.hidden, Some(true));
940 }
941
942 #[test]
943 fn test_set_row_visible_clears_hidden() {
944 let mut ws = sample_ws();
945 set_row_visible(&mut ws, 1, false).unwrap();
946 set_row_visible(&mut ws, 1, true).unwrap();
947
948 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
949 assert_eq!(row.hidden, None);
950 }
951
952 #[test]
953 fn test_set_row_visible_creates_row_if_missing() {
954 let mut ws = WorksheetXml::default();
955 set_row_visible(&mut ws, 3, false).unwrap();
956 assert_eq!(ws.sheet_data.rows.len(), 1);
957 assert_eq!(ws.sheet_data.rows[0].r, 3);
958 assert_eq!(ws.sheet_data.rows[0].hidden, Some(true));
959 }
960
961 #[test]
962 fn test_set_row_visible_row_zero_returns_error() {
963 let mut ws = WorksheetXml::default();
964 let result = set_row_visible(&mut ws, 0, true);
965 assert!(result.is_err());
966 }
967
968 #[test]
969 fn test_set_row_outline_level() {
970 let mut ws = sample_ws();
971 set_row_outline_level(&mut ws, 1, 3).unwrap();
972
973 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
974 assert_eq!(row.outline_level, Some(3));
975 }
976
977 #[test]
978 fn test_set_row_outline_level_zero_clears() {
979 let mut ws = sample_ws();
980 set_row_outline_level(&mut ws, 1, 3).unwrap();
981 set_row_outline_level(&mut ws, 1, 0).unwrap();
982
983 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
984 assert_eq!(row.outline_level, None);
985 }
986
987 #[test]
988 fn test_set_row_outline_level_exceeds_max_returns_error() {
989 let mut ws = sample_ws();
990 let result = set_row_outline_level(&mut ws, 1, 8);
991 assert!(result.is_err());
992 }
993
994 #[test]
995 fn test_set_row_outline_level_row_zero_returns_error() {
996 let mut ws = WorksheetXml::default();
997 let result = set_row_outline_level(&mut ws, 0, 1);
998 assert!(result.is_err());
999 }
1000
1001 #[test]
1002 fn test_get_row_visible_default_is_true() {
1003 let ws = sample_ws();
1004 assert!(get_row_visible(&ws, 1));
1005 }
1006
1007 #[test]
1008 fn test_get_row_visible_nonexistent_row_is_true() {
1009 let ws = WorksheetXml::default();
1010 assert!(get_row_visible(&ws, 99));
1011 }
1012
1013 #[test]
1014 fn test_get_row_visible_after_hide() {
1015 let mut ws = sample_ws();
1016 set_row_visible(&mut ws, 1, false).unwrap();
1017 assert!(!get_row_visible(&ws, 1));
1018 }
1019
1020 #[test]
1021 fn test_get_row_visible_after_hide_then_show() {
1022 let mut ws = sample_ws();
1023 set_row_visible(&mut ws, 1, false).unwrap();
1024 set_row_visible(&mut ws, 1, true).unwrap();
1025 assert!(get_row_visible(&ws, 1));
1026 }
1027
1028 #[test]
1029 fn test_get_row_outline_level_default_is_zero() {
1030 let ws = sample_ws();
1031 assert_eq!(get_row_outline_level(&ws, 1), 0);
1032 }
1033
1034 #[test]
1035 fn test_get_row_outline_level_nonexistent_row() {
1036 let ws = WorksheetXml::default();
1037 assert_eq!(get_row_outline_level(&ws, 99), 0);
1038 }
1039
1040 #[test]
1041 fn test_get_row_outline_level_after_set() {
1042 let mut ws = sample_ws();
1043 set_row_outline_level(&mut ws, 1, 5).unwrap();
1044 assert_eq!(get_row_outline_level(&ws, 1), 5);
1045 }
1046
1047 #[test]
1048 fn test_get_row_outline_level_after_clear() {
1049 let mut ws = sample_ws();
1050 set_row_outline_level(&mut ws, 1, 3).unwrap();
1051 set_row_outline_level(&mut ws, 1, 0).unwrap();
1052 assert_eq!(get_row_outline_level(&ws, 1), 0);
1053 }
1054
1055 #[test]
1058 fn test_get_rows_empty_sheet() {
1059 let ws = WorksheetXml::default();
1060 let sst = SharedStringTable::new();
1061 let rows = get_rows(&ws, &sst, &[]).unwrap();
1062 assert!(rows.is_empty());
1063 }
1064
1065 #[test]
1066 fn test_get_rows_returns_numeric_values() {
1067 let ws = sample_ws();
1068 let sst = SharedStringTable::new();
1069 let rows = get_rows(&ws, &sst, &[]).unwrap();
1070
1071 assert_eq!(rows.len(), 3);
1072
1073 assert_eq!(rows[0].0, 1);
1075 assert_eq!(rows[0].1.len(), 2);
1076 assert_eq!(rows[0].1[0].0, 1);
1077 assert_eq!(rows[0].1[0].1, CellValue::Number(10.0));
1078 assert_eq!(rows[0].1[1].0, 2);
1079 assert_eq!(rows[0].1[1].1, CellValue::Number(20.0));
1080
1081 assert_eq!(rows[1].0, 2);
1083 assert_eq!(rows[1].1.len(), 1);
1084 assert_eq!(rows[1].1[0].0, 1);
1085 assert_eq!(rows[1].1[0].1, CellValue::Number(30.0));
1086
1087 assert_eq!(rows[2].0, 5);
1089 assert_eq!(rows[2].1.len(), 1);
1090 assert_eq!(rows[2].1[0].0, 3);
1091 assert_eq!(rows[2].1[0].1, CellValue::Number(50.0));
1092 }
1093
1094 #[test]
1095 fn test_get_rows_shared_strings() {
1096 let mut sst = SharedStringTable::new();
1097 sst.add("hello");
1098 sst.add("world");
1099
1100 let mut ws = WorksheetXml::default();
1101 ws.sheet_data = SheetData {
1102 rows: vec![Row {
1103 r: 1,
1104 spans: None,
1105 s: None,
1106 custom_format: None,
1107 ht: None,
1108 hidden: None,
1109 custom_height: None,
1110 outline_level: None,
1111 cells: vec![
1112 Cell {
1113 r: "A1".try_into().unwrap(),
1114 col: 1,
1115 s: None,
1116 t: CellTypeTag::SharedString,
1117 v: Some("0".to_string()),
1118 f: None,
1119 is: None,
1120 },
1121 Cell {
1122 r: "B1".try_into().unwrap(),
1123 col: 2,
1124 s: None,
1125 t: CellTypeTag::SharedString,
1126 v: Some("1".to_string()),
1127 f: None,
1128 is: None,
1129 },
1130 ],
1131 }],
1132 };
1133
1134 let rows = get_rows(&ws, &sst, &[]).unwrap();
1135 assert_eq!(rows.len(), 1);
1136 assert_eq!(rows[0].1[0].1, CellValue::String("hello".to_string()));
1137 assert_eq!(rows[0].1[1].1, CellValue::String("world".to_string()));
1138 }
1139
1140 #[test]
1141 fn test_get_rows_mixed_types() {
1142 let mut sst = SharedStringTable::new();
1143 sst.add("text");
1144
1145 let mut ws = WorksheetXml::default();
1146 ws.sheet_data = SheetData {
1147 rows: vec![Row {
1148 r: 1,
1149 spans: None,
1150 s: None,
1151 custom_format: None,
1152 ht: None,
1153 hidden: None,
1154 custom_height: None,
1155 outline_level: None,
1156 cells: vec![
1157 Cell {
1158 r: "A1".try_into().unwrap(),
1159 col: 1,
1160 s: None,
1161 t: CellTypeTag::SharedString,
1162 v: Some("0".to_string()),
1163 f: None,
1164 is: None,
1165 },
1166 Cell {
1167 r: "B1".try_into().unwrap(),
1168 col: 2,
1169 s: None,
1170 t: CellTypeTag::None,
1171 v: Some("42.5".to_string()),
1172 f: None,
1173 is: None,
1174 },
1175 Cell {
1176 r: "C1".try_into().unwrap(),
1177 col: 3,
1178 s: None,
1179 t: CellTypeTag::Boolean,
1180 v: Some("1".to_string()),
1181 f: None,
1182 is: None,
1183 },
1184 Cell {
1185 r: "D1".try_into().unwrap(),
1186 col: 4,
1187 s: None,
1188 t: CellTypeTag::Error,
1189 v: Some("#DIV/0!".to_string()),
1190 f: None,
1191 is: None,
1192 },
1193 ],
1194 }],
1195 };
1196
1197 let rows = get_rows(&ws, &sst, &[]).unwrap();
1198 assert_eq!(rows.len(), 1);
1199 assert_eq!(rows[0].1[0].1, CellValue::String("text".to_string()));
1200 assert_eq!(rows[0].1[1].1, CellValue::Number(42.5));
1201 assert_eq!(rows[0].1[2].1, CellValue::Bool(true));
1202 assert_eq!(rows[0].1[3].1, CellValue::Error("#DIV/0!".to_string()));
1203 }
1204
1205 #[test]
1206 fn test_get_rows_skips_rows_with_no_cells() {
1207 let mut ws = WorksheetXml::default();
1208 ws.sheet_data = SheetData {
1209 rows: vec![
1210 Row {
1211 r: 1,
1212 spans: None,
1213 s: None,
1214 custom_format: None,
1215 ht: None,
1216 hidden: None,
1217 custom_height: None,
1218 outline_level: None,
1219 cells: vec![Cell {
1220 r: "A1".try_into().unwrap(),
1221 col: 1,
1222 s: None,
1223 t: CellTypeTag::None,
1224 v: Some("1".to_string()),
1225 f: None,
1226 is: None,
1227 }],
1228 },
1229 Row {
1231 r: 2,
1232 spans: None,
1233 s: None,
1234 custom_format: None,
1235 ht: Some(30.0),
1236 hidden: None,
1237 custom_height: Some(true),
1238 outline_level: None,
1239 cells: vec![],
1240 },
1241 Row {
1242 r: 3,
1243 spans: None,
1244 s: None,
1245 custom_format: None,
1246 ht: None,
1247 hidden: None,
1248 custom_height: None,
1249 outline_level: None,
1250 cells: vec![Cell {
1251 r: "A3".try_into().unwrap(),
1252 col: 1,
1253 s: None,
1254 t: CellTypeTag::None,
1255 v: Some("3".to_string()),
1256 f: None,
1257 is: None,
1258 }],
1259 },
1260 ],
1261 };
1262
1263 let sst = SharedStringTable::new();
1264 let rows = get_rows(&ws, &sst, &[]).unwrap();
1265 assert_eq!(rows.len(), 2);
1267 assert_eq!(rows[0].0, 1);
1268 assert_eq!(rows[1].0, 3);
1269 }
1270
1271 #[test]
1272 fn test_get_rows_with_formula() {
1273 let mut ws = WorksheetXml::default();
1274 ws.sheet_data = SheetData {
1275 rows: vec![Row {
1276 r: 1,
1277 spans: None,
1278 s: None,
1279 custom_format: None,
1280 ht: None,
1281 hidden: None,
1282 custom_height: None,
1283 outline_level: None,
1284 cells: vec![Cell {
1285 r: "A1".try_into().unwrap(),
1286 col: 1,
1287 s: None,
1288 t: CellTypeTag::None,
1289 v: Some("42".to_string()),
1290 f: Some(Box::new(sheetkit_xml::worksheet::CellFormula {
1291 t: None,
1292 reference: None,
1293 si: None,
1294 value: Some("B1+C1".to_string()),
1295 })),
1296 is: None,
1297 }],
1298 }],
1299 };
1300
1301 let sst = SharedStringTable::new();
1302 let rows = get_rows(&ws, &sst, &[]).unwrap();
1303 assert_eq!(rows.len(), 1);
1304 match &rows[0].1[0].1 {
1305 CellValue::Formula { expr, result } => {
1306 assert_eq!(expr, "B1+C1");
1307 assert_eq!(*result, Some(Box::new(CellValue::Number(42.0))));
1308 }
1309 _ => panic!("expected Formula"),
1310 }
1311 }
1312
1313 #[test]
1314 fn test_formula_cached_results_preserve_cell_types() {
1315 let formula = sheetkit_xml::worksheet::CellFormula {
1316 t: None,
1317 reference: None,
1318 si: None,
1319 value: Some("A1".to_string()),
1320 };
1321 let sst = SharedStringTable::new();
1322
1323 let cases = [
1324 (CellTypeTag::Boolean, "1", false, CellValue::Bool(true)),
1325 (
1326 CellTypeTag::Error,
1327 "#N/A",
1328 false,
1329 CellValue::Error("#N/A".to_string()),
1330 ),
1331 (
1332 CellTypeTag::FormulaString,
1333 "=dangerous text",
1334 false,
1335 CellValue::String("=dangerous text".to_string()),
1336 ),
1337 (
1338 CellTypeTag::Number,
1339 "45292",
1340 true,
1341 CellValue::Date(45_292.0),
1342 ),
1343 ];
1344
1345 for (cell_type, value, promote_number_to_date, expected) in cases {
1346 let resolved = parse_cell_type_value(
1347 cell_type,
1348 Some(value),
1349 Some(&formula),
1350 None,
1351 &sst,
1352 promote_number_to_date,
1353 );
1354 assert_eq!(
1355 resolved,
1356 CellValue::Formula {
1357 expr: "A1".to_string(),
1358 result: Some(Box::new(expected)),
1359 }
1360 );
1361 }
1362 }
1363
1364 #[test]
1365 fn test_invalid_error_payloads_are_classified_as_text() {
1366 let formula = sheetkit_xml::worksheet::CellFormula {
1367 t: None,
1368 reference: None,
1369 si: None,
1370 value: Some("A1".to_string()),
1371 };
1372 let sst = SharedStringTable::new();
1373
1374 assert_eq!(
1375 parse_cell_type_value(CellTypeTag::Error, Some("=direct"), None, None, &sst, false,),
1376 CellValue::String("=direct".to_string())
1377 );
1378 assert_eq!(
1379 parse_cell_type_value(
1380 CellTypeTag::Error,
1381 Some("+cached"),
1382 Some(&formula),
1383 None,
1384 &sst,
1385 false,
1386 ),
1387 CellValue::Formula {
1388 expr: "A1".to_string(),
1389 result: Some(Box::new(CellValue::String("+cached".to_string()))),
1390 }
1391 );
1392 }
1393
1394 #[test]
1395 fn test_get_rows_with_inline_string() {
1396 let mut ws = WorksheetXml::default();
1397 ws.sheet_data = SheetData {
1398 rows: vec![Row {
1399 r: 1,
1400 spans: None,
1401 s: None,
1402 custom_format: None,
1403 ht: None,
1404 hidden: None,
1405 custom_height: None,
1406 outline_level: None,
1407 cells: vec![Cell {
1408 r: "A1".try_into().unwrap(),
1409 col: 1,
1410 s: None,
1411 t: CellTypeTag::InlineString,
1412 v: None,
1413 f: None,
1414 is: Some(Box::new(sheetkit_xml::worksheet::InlineString {
1415 t: Some("inline text".to_string()),
1416 r: vec![],
1417 r_ph: vec![],
1418 })),
1419 }],
1420 }],
1421 };
1422
1423 let sst = SharedStringTable::new();
1424 let rows = get_rows(&ws, &sst, &[]).unwrap();
1425 assert_eq!(rows.len(), 1);
1426 assert_eq!(rows[0].1[0].1, CellValue::String("inline text".to_string()));
1427 }
1428
1429 #[test]
1432 fn test_get_row_style_default_is_zero() {
1433 let ws = WorksheetXml::default();
1434 assert_eq!(get_row_style(&ws, 1), 0);
1435 }
1436
1437 #[test]
1438 fn test_get_row_style_nonexistent_row_is_zero() {
1439 let ws = sample_ws();
1440 assert_eq!(get_row_style(&ws, 99), 0);
1441 }
1442
1443 #[test]
1444 fn test_set_row_style_applies_style() {
1445 let mut ws = sample_ws();
1446 set_row_style(&mut ws, 1, 5).unwrap();
1447
1448 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1449 assert_eq!(row.s, Some(5));
1450 assert_eq!(row.custom_format, Some(true));
1451 }
1452
1453 #[test]
1454 fn test_set_row_style_applies_to_existing_cells() {
1455 let mut ws = sample_ws();
1456 set_row_style(&mut ws, 1, 3).unwrap();
1457
1458 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1459 for cell in &row.cells {
1460 assert_eq!(cell.s, Some(3));
1461 }
1462 }
1463
1464 #[test]
1465 fn test_get_row_style_after_set() {
1466 let mut ws = sample_ws();
1467 set_row_style(&mut ws, 2, 7).unwrap();
1468 assert_eq!(get_row_style(&ws, 2), 7);
1469 }
1470
1471 #[test]
1472 fn test_set_row_style_creates_row_if_missing() {
1473 let mut ws = WorksheetXml::default();
1474 set_row_style(&mut ws, 5, 2).unwrap();
1475
1476 assert_eq!(ws.sheet_data.rows.len(), 1);
1477 assert_eq!(ws.sheet_data.rows[0].r, 5);
1478 assert_eq!(ws.sheet_data.rows[0].s, Some(2));
1479 }
1480
1481 #[test]
1482 fn test_set_row_style_zero_clears_custom_format() {
1483 let mut ws = sample_ws();
1484 set_row_style(&mut ws, 1, 5).unwrap();
1485 set_row_style(&mut ws, 1, 0).unwrap();
1486
1487 let row = ws.sheet_data.rows.iter().find(|r| r.r == 1).unwrap();
1488 assert_eq!(row.s, Some(0));
1489 assert_eq!(row.custom_format, None);
1490 }
1491
1492 #[test]
1493 fn test_set_row_style_row_zero_returns_error() {
1494 let mut ws = WorksheetXml::default();
1495 let result = set_row_style(&mut ws, 0, 1);
1496 assert!(result.is_err());
1497 }
1498}