Skip to content

DesignCraft: An open-source page and layout design editor written by scratch in pure Rust

refactor(compose): move the border_tests module of table.rs to table/border_tests.rs

aiongg0982b3da0351
diff --git a/crates/compose/src/table.rs b/crates/compose/src/table.rs
index 9a41a546e..c620622a3 100644
--- a/crates/compose/src/table.rs
+++ b/crates/compose/src/table.rs
@@ -1096,483 +1096,4 @@ mod height_tests {
}
#[cfg(test)]
-mod border_tests {
- use super::*;
- use designcraft_doc::{CellRange, ParaFormat, SpreadRef, build::NewDocument};
-
- fn compose_table(table: Table) -> ComposedStory {
- let mut doc = Document::new(&NewDocument::default());
- let layer = doc.default_layer();
- let (_, sid) = doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 120.0, 200.0), layer, "", ParaFormat::default()).unwrap();
- doc.story_mut(sid).unwrap().insert_table(0, table);
- crate::compose_story(&doc, sid, &ComposeOptions::default())
- }
-
- #[test]
- fn explicit_cell_edges_override_table_border_without_changing_native_defaults() {
- let mut table = Table::new(77, 1, 1, 0, 0, 100.0);
- table.options.border.weight = 2.0;
- table.cell_mut(0, 0).unwrap().strokes = std::array::from_fn(|_| CellStroke::none());
- let native = compose_table(table.clone());
- let strokes = &native.frames[0].tables[0].strokes;
- assert_eq!(strokes.len(), 4, "default cells still use all four table borders");
- assert!(strokes.iter().all(|s| s.stroke.weight == 2.0));
-
- let cell = table.cell_mut(0, 0).unwrap();
- cell.border_overrides = [true, true, true, false];
- cell.strokes[2] = CellStroke { weight: 3.0, ..Default::default() };
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2, "top and left None overrides suppress borders");
- let bottom = fragment.strokes.iter().find(|s| s.a.y == fragment.rect.y1 && s.b.y == fragment.rect.y1).unwrap();
- assert_eq!(bottom.stroke.weight, 3.0);
- let right = fragment.strokes.iter().find(|s| s.a.x == fragment.rect.x1 && s.b.x == fragment.rect.x1).unwrap();
- assert_eq!(right.stroke.weight, 2.0, "unoverridden right edge keeps the table border");
- }
-
- #[test]
- fn merged_cell_keeps_explicit_border_suppression() {
- let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
- table.merge(CellRange::new(0, 0, 1, 1)).unwrap();
- let cell = table.cell_mut(0, 0).unwrap();
- cell.border_overrides = [true; 4];
- cell.strokes = std::array::from_fn(|_| CellStroke::none());
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.cells.len(), 1);
- assert!(fragment.strokes.is_empty());
- }
-
- fn rule_table(body: usize, cols: usize, header: usize, footer: usize) -> Table {
- let mut table = Table::new(77, body, cols, header, footer, 100.0);
- table.options.border = CellStroke::none();
- for row in &mut table.rows {
- row.height = 20.0;
- row.mode = RowHeightMode::Exactly;
- }
- for cell in &mut table.cells {
- cell.insets = [0.0; 4];
- cell.strokes = std::array::from_fn(|_| CellStroke::none());
- }
- table
- }
-
- fn set_rule(table: &mut Table, row: usize, col: usize, side: usize, weight: f64, priority: i32) {
- let cell = table.cell_mut(row, col).unwrap();
- cell.strokes[side] = CellStroke { weight, ..Default::default() };
- cell.stroke_defined[side] = true;
- cell.stroke_priorities[side] = priority;
- }
-
- fn assert_no_overlapping_rules(fragment: &TableFrag) {
- for (i, a) in fragment.strokes.iter().enumerate() {
- for b in &fragment.strokes[i + 1..] {
- let horizontal_overlap = a.a.y == a.b.y && a.a.y == b.a.y && b.a.y == b.b.y && a.a.x.max(b.a.x) < a.b.x.min(b.b.x);
- let vertical_overlap = a.a.x == a.b.x && a.a.x == b.a.x && b.a.x == b.b.x && a.a.y.max(b.a.y) < a.b.y.min(b.b.y);
- assert!(!horizontal_overlap && !vertical_overlap, "duplicate shared edge: {a:?}, {b:?}");
- }
- }
- }
-
- #[test]
- fn header_bottom_only_style_survives_zero_body_edges() {
- // Synthetic equivalent of a header with a one-point bottom rule and zero on all
- // remaining header/body edges. Both sides supply style formatting at priority zero.
- let mut table = rule_table(2, 3, 1, 0);
- for cell in &mut table.cells {
- cell.stroke_defined = [true; 4];
- cell.border_overrides = [true; 4];
- }
- for col in 0..3 {
- set_rule(&mut table, 0, col, 2, 1.0, 0);
- }
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- let y = fragment.cell(0, 0).unwrap().rect.y1;
- assert_eq!(fragment.strokes.len(), 3);
- assert!(fragment.strokes.iter().all(|s| s.a.y == y && s.b.y == y && s.stroke.weight == 1.0));
- assert_eq!(fragment.strokes.iter().map(|s| s.b.x - s.a.x).sum::<f64>(), 100.0);
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn shared_rules_choose_numeric_priority_once_and_preserve_drawing_order() {
- let mut table = rule_table(2, 2, 0, 0);
- set_rule(&mut table, 0, 0, 2, 3.0, 7);
- set_rule(&mut table, 1, 0, 0, 1.0, 4);
- set_rule(&mut table, 0, 0, 3, 4.0, 3);
- set_rule(&mut table, 0, 1, 1, 2.0, 9);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- let horizontal = &fragment.strokes[0];
- assert_eq!(horizontal.a.y, horizontal.b.y);
- assert_eq!(horizontal.stroke.weight, 3.0);
- let vertical = &fragment.strokes[1];
- assert_eq!(vertical.a.x, vertical.b.x);
- assert_eq!(vertical.stroke.weight, 2.0, "higher priority draws last at a crossing");
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn signed_negative_priorities_resolve_and_draw_in_numeric_order() {
- let mut table = rule_table(2, 2, 0, 0);
- set_rule(&mut table, 0, 0, 2, 1.0, -2);
- set_rule(&mut table, 1, 0, 0, 3.0, -1);
- set_rule(&mut table, 0, 0, 3, 2.0, -3);
- set_rule(&mut table, 0, 1, 1, 4.0, -2);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- assert_eq!(fragment.strokes[0].stroke.weight, 4.0, "priority -2 draws before -1");
- assert_eq!(fragment.strokes[0].a.x, fragment.strokes[0].b.x);
- assert_eq!(fragment.strokes[1].stroke.weight, 3.0, "priority -1 wins over -2");
- assert_eq!(fragment.strokes[1].a.y, fragment.strokes[1].b.y);
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn default_zero_priority_beats_a_negative_priority_rule() {
- let mut table = rule_table(2, 1, 0, 0);
- set_rule(&mut table, 0, 0, 2, 3.0, -1);
- assert_eq!(table.cell(1, 0).unwrap().stroke_priorities, [0; 4]);
- let composed = compose_table(table.clone());
- assert!(composed.frames[0].tables[0].strokes.is_empty(), "priority zero None suppresses priority -1");
- table.cell_mut(1, 0).unwrap().strokes[0] = CellStroke::default();
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 1);
- assert_eq!(fragment.strokes[0].stroke.weight, 1.0, "the priority-zero native rule wins over priority -1");
- }
-
- #[test]
- fn higher_priority_zero_or_none_suppresses_a_visible_shared_rule() {
- for invisible in [CellStroke::none(), CellStroke { color: designcraft_color::swatch::NONE.into(), ..Default::default() }] {
- let mut table = rule_table(2, 2, 0, 0);
- set_rule(&mut table, 0, 0, 2, 3.0, 7);
- set_rule(&mut table, 1, 0, 0, 0.0, 8);
- table.cell_mut(1, 0).unwrap().strokes[0] = invisible.clone();
- set_rule(&mut table, 0, 0, 3, 3.0, 7);
- set_rule(&mut table, 0, 1, 1, 0.0, 8);
- table.cell_mut(0, 1).unwrap().strokes[1] = invisible;
- let composed = compose_table(table);
- assert!(composed.frames[0].tables[0].strokes.is_empty());
- }
- }
-
- #[test]
- fn supplied_zero_shared_edge_beats_missing_native_default() {
- let mut table = Table::new(77, 2, 1, 0, 0, 100.0);
- table.options.border = CellStroke::none();
- let upper = table.cell_mut(0, 0).unwrap();
- upper.strokes[2] = CellStroke::none();
- upper.stroke_defined[2] = true;
- let composed = compose_table(table.clone());
- assert!(composed.frames[0].tables[0].strokes.is_empty(), "explicit zero beats a missing edge's one-point default");
- table.cell_mut(0, 0).unwrap().stroke_defined[2] = false;
- let composed = compose_table(table);
- assert_eq!(composed.frames[0].tables[0].strokes.len(), 1, "a missing zero cannot suppress the opposite visible default");
- }
-
- #[test]
- fn specified_zero_priority_outer_edges_keep_per_side_table_borders() {
- for direction in [designcraft_doc::TextDirection::LeftToRight, designcraft_doc::TextDirection::RightToLeft] {
- let mut table = rule_table(1, 1, 0, 0);
- table.options.direction = direction;
- table.options.borders = std::array::from_fn(|i| Some(CellStroke { weight: (i + 1) as f64, ..Default::default() }));
- table.cell_mut(0, 0).unwrap().stroke_defined = [true; 4];
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 4);
- for rule in &fragment.strokes {
- let expected = if rule.a.y == rule.b.y {
- if rule.a.y == fragment.rect.y0 { 1.0 } else { 3.0 }
- } else if rule.a.x == fragment.rect.x0 {
- 2.0
- } else {
- 4.0
- };
- assert_eq!(rule.stroke.weight, expected, "priority-zero cell values do not override perimeter formatting");
- }
- assert_no_overlapping_rules(fragment);
- }
- }
-
- fn uniform_pattern(weight: f64) -> designcraft_doc::AltStrokes {
- let stroke = CellStroke { weight, ..Default::default() };
- designcraft_doc::AltStrokes { first: 1, next: 1, first_stroke: stroke.clone(), next_stroke: stroke, skip_first: 0, skip_last: 0 }
- }
-
- #[test]
- fn uniform_zero_table_patterns_suppress_missing_grid_edges_but_not_perimeter() {
- let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
- table.options.row_strokes = Some(uniform_pattern(0.0));
- table.options.column_strokes = Some(uniform_pattern(0.0));
- table.options.border.weight = 2.0;
- let composed = compose_table(table.clone());
- let fragment = &composed.frames[0].tables[0];
- assert!(!fragment.strokes.is_empty(), "table perimeter remains visible");
- assert!(fragment.strokes.iter().all(|s| {
- s.stroke.weight == 2.0
- && ((s.a.x == s.b.x && (s.a.x == fragment.rect.x0 || s.a.x == fragment.rect.x1))
- || (s.a.y == s.b.y && (s.a.y == fragment.rect.y0 || s.a.y == fragment.rect.y1)))
- }));
- assert_no_overlapping_rules(fragment);
- table.options.border = CellStroke::none();
- set_rule(&mut table, 0, 0, 2, 3.0, 0);
- set_rule(&mut table, 0, 1, 1, 4.0, 0);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2, "supplied cell strokes override the table patterns");
- assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 3.0));
- assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 4.0));
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn uniform_visible_table_patterns_supply_continuous_rules_below_explicit_none() {
- let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
- table.options.border = CellStroke::none();
- table.options.row_strokes = Some(uniform_pattern(2.0));
- table.options.column_strokes = Some(uniform_pattern(3.0));
- let composed = compose_table(table.clone());
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2, "a table pattern stays continuous across cell boundaries");
- assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 2.0 && s.b.x - s.a.x == 100.0));
- assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 3.0 && s.b.y - s.a.y == fragment.rect.height()));
- for cell in &mut table.cells {
- cell.strokes = std::array::from_fn(|_| CellStroke::none());
- cell.stroke_defined = [true; 4];
- }
- let composed = compose_table(table);
- assert!(composed.frames[0].tables[0].strokes.is_empty(), "explicit cell None is stronger than table patterns");
- }
-
- #[test]
- fn uniform_table_patterns_leave_header_and_footer_edges_unchanged() {
- let mut table = Table::new(77, 2, 2, 1, 1, 100.0);
- table.options.border = CellStroke::none();
- table.options.row_strokes = Some(uniform_pattern(0.0));
- table.options.column_strokes = Some(uniform_pattern(0.0));
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- let header = fragment.cell(0, 0).unwrap().rect;
- let body = fragment.cell(1, 0).unwrap().rect;
- let footer = fragment.cell(3, 0).unwrap().rect;
- assert!(fragment.strokes.iter().any(|s| s.a == Point::new(header.x1, header.y0) && s.b == Point::new(header.x1, header.y1)));
- assert!(fragment.strokes.iter().any(|s| s.a == Point::new(footer.x1, footer.y0) && s.b == Point::new(footer.x1, footer.y1)));
- assert!(!fragment.strokes.iter().any(|s| s.a.y == body.y1 && s.b.y == body.y1));
- assert!(!fragment.strokes.iter().any(|s| s.a == Point::new(body.x1, body.y0) && s.b == Point::new(body.x1, body.y1)));
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn unverified_nonuniform_or_skipped_pattern_phase_keeps_native_edges() {
- for skipped in [false, true] {
- let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
- table.options.border = CellStroke::none();
- let mut pattern = uniform_pattern(2.0);
- if skipped {
- pattern.skip_first = 1;
- } else {
- pattern.next_stroke.weight = 3.0;
- }
- table.options.row_strokes = Some(pattern.clone());
- table.options.column_strokes = Some(pattern);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 4);
- assert!(fragment.strokes.iter().all(|s| s.stroke.weight == 1.0));
- }
- }
-
- #[test]
- fn metadata_free_native_and_legacy_edges_keep_top_and_left_suppression() {
- let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
- table.options.border = CellStroke::none();
- let composed = compose_table(table.clone());
- assert_eq!(composed.frames[0].tables[0].strokes.len(), 4, "unmodified native grid control");
- // The metadata arrays also default to zero/false when reading legacy JSON. Older
- // native table.setCell code changed these strokes without setting any metadata.
- table.cell_mut(1, 0).unwrap().strokes[0] = CellStroke::none();
- table.cell_mut(0, 1).unwrap().strokes[1].color = designcraft_color::swatch::NONE.into();
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- let hidden_top = fragment.cell(1, 0).unwrap().rect;
- let hidden_left = fragment.cell(0, 1).unwrap().rect;
- assert!(!fragment.strokes.iter().any(|s| s.a == Point::new(hidden_top.x0, hidden_top.y0) && s.b == Point::new(hidden_top.x1, hidden_top.y0)));
- assert!(
- !fragment.strokes.iter().any(|s| s.a == Point::new(hidden_left.x0, hidden_left.y0) && s.b == Point::new(hidden_left.x0, hidden_left.y1))
- );
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn equal_priority_visible_rules_keep_top_and_left_ownership() {
- let mut table = rule_table(2, 2, 0, 0);
- set_rule(&mut table, 0, 0, 2, 5.0, 0);
- set_rule(&mut table, 1, 0, 0, 2.0, 0);
- set_rule(&mut table, 0, 0, 3, 6.0, 0);
- set_rule(&mut table, 0, 1, 1, 3.0, 0);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- assert_eq!(fragment.strokes[0].stroke.weight, 2.0);
- assert_eq!(fragment.strokes[1].stroke.weight, 3.0);
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn row_spanning_edge_resolves_each_neighbor_without_internal_rules() {
- let mut table = rule_table(2, 2, 0, 0);
- table.merge(CellRange::new(0, 0, 1, 0)).unwrap();
- set_rule(&mut table, 0, 0, 3, 1.0, 5);
- set_rule(&mut table, 0, 1, 1, 2.0, 6);
- set_rule(&mut table, 1, 1, 1, 3.0, 4);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- let upper = fragment.strokes.iter().find(|s| s.stroke.weight == 2.0).unwrap();
- let lower = fragment.strokes.iter().find(|s| s.stroke.weight == 1.0).unwrap();
- assert_eq!(upper.a, Point::new(50.0, fragment.rect.y0));
- assert_eq!(upper.b, lower.a);
- assert_eq!(lower.b, Point::new(50.0, fragment.rect.y1));
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn column_spanning_edge_resolves_each_neighbor_without_internal_rules() {
- let mut table = rule_table(2, 2, 0, 0);
- table.merge(CellRange::new(0, 0, 0, 1)).unwrap();
- set_rule(&mut table, 0, 0, 2, 1.0, 5);
- set_rule(&mut table, 1, 0, 0, 2.0, 6);
- set_rule(&mut table, 1, 1, 0, 3.0, 4);
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 2);
- let left = fragment.strokes.iter().find(|s| s.stroke.weight == 2.0).unwrap();
- let right = fragment.strokes.iter().find(|s| s.stroke.weight == 1.0).unwrap();
- let y = fragment.cell(0, 0).unwrap().rect.y1;
- assert_eq!(left.a, Point::new(fragment.rect.x0, y));
- assert_eq!(left.b, right.a);
- assert_eq!(right.b, Point::new(fragment.rect.x1, y));
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn merged_winning_dashed_edge_stays_continuous_across_losing_neighbors() {
- let mut table = rule_table(2, 2, 0, 0);
- table.columns.iter_mut().for_each(|column| column.width = 45.0);
- table.merge(CellRange::new(1, 0, 1, 1)).unwrap();
- set_rule(&mut table, 1, 0, 0, 1.0, 1);
- table.cell_mut(1, 0).unwrap().strokes[0].kind = designcraft_doc::StrokeType::Dashed { pattern: vec![6.0, 4.0] };
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 1, "one winning source edge must retain one dash phase");
- let rule = &fragment.strokes[0];
- let merged = fragment.cell(1, 0).unwrap().rect;
- assert_eq!(rule.a, Point::new(merged.x0, merged.y0));
- assert_eq!(rule.b, Point::new(merged.x1, merged.y0));
- assert_eq!(rule.b.x - rule.a.x, 90.0);
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn merged_perimeter_keeps_four_continuous_strokes() {
- let mut table = rule_table(2, 2, 0, 0);
- table.merge(CellRange::new(0, 0, 1, 1)).unwrap();
- table.options.border.weight = 2.0;
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 4);
- assert_eq!(fragment.strokes.iter().filter(|s| s.a.y == s.b.y).count(), 2);
- assert_eq!(fragment.strokes.iter().filter(|s| s.a.x == s.b.x).count(), 2);
- assert_no_overlapping_rules(fragment);
- }
-
- #[test]
- fn rtl_shared_rules_use_physical_edges_and_outer_borders() {
- let mut table = rule_table(1, 2, 0, 0);
- table.options.direction = designcraft_doc::TextDirection::RightToLeft;
- table.columns[0].width = 30.0;
- table.columns[1].width = 70.0;
- set_rule(&mut table, 0, 0, 1, 2.0, 9);
- set_rule(&mut table, 0, 1, 3, 4.0, 2);
- set_rule(&mut table, 0, 0, 3, 5.0, 3);
- table.cell_mut(0, 0).unwrap().border_overrides[3] = true;
- set_rule(&mut table, 0, 1, 1, 6.0, 4);
- table.cell_mut(0, 1).unwrap().border_overrides[1] = true;
- let composed = compose_table(table);
- let fragment = &composed.frames[0].tables[0];
- assert_eq!(fragment.strokes.len(), 3);
- for (x, weight) in [(0.0, 6.0), (70.0, 2.0), (100.0, 5.0)] {
- let rule = fragment.strokes.iter().find(|s| s.a.x == x && s.b.x == x).unwrap();
- assert_eq!(rule.stroke.weight, weight);
- }
- assert_no_overlapping_rules(fragment);
- }
-
- fn compose_two_fragments(table: Table, height: f64) -> ComposedStory {
- let mut doc = Document::new(&NewDocument::default());
- let layer = doc.default_layer();
- let (first, sid) = doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 120.0, height), layer, "", ParaFormat::default()).unwrap();
- let (second, _) =
- doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 200.0, 120.0, 200.0 + height), layer, "", ParaFormat::default()).unwrap();
- doc.thread(first, second).unwrap();
- doc.story_mut(sid).unwrap().insert_table(0, table);
- let composed = crate::compose_story(&doc, sid, &ComposeOptions::default());
- assert!(!composed.is_overset(), "overset at {:?}", composed.overset_at);
- assert_eq!(composed.frames[0].tables.len(), 1);
- assert_eq!(composed.frames[1].tables.len(), 1);
- composed
- }
-
- #[test]
- fn repeated_header_and_footer_rules_resolve_displayed_fragment_neighbors() {
- let mut table = rule_table(4, 2, 1, 1);
- table.merge(CellRange::new(0, 0, 0, 1)).unwrap();
- table.merge(CellRange::new(5, 0, 5, 1)).unwrap();
- set_rule(&mut table, 0, 0, 2, 1.0, 2);
- set_rule(&mut table, 5, 0, 0, 2.0, 3);
- // Keep 19 points for the anchor's trailing empty paragraph, still below the
- // 100 points needed to fit a third body row plus the header and footer.
- let composed = compose_two_fragments(table, 99.0);
- for (i, frame) in composed.frames.iter().enumerate() {
- let fragment = &frame.tables[0];
- let header = fragment.cell(0, 0).unwrap();
- let footer = fragment.cell(5, 0).unwrap();
- assert_eq!(header.repeated, i == 1);
- assert_eq!(footer.repeated, i == 0);
- assert_eq!(fragment.strokes.len(), 2);
- let header_rules: Vec<_> = fragment.strokes.iter().filter(|s| s.a.y == header.rect.y1 && s.b.y == header.rect.y1).collect();
- let footer_rules: Vec<_> = fragment.strokes.iter().filter(|s| s.a.y == footer.rect.y0 && s.b.y == footer.rect.y0).collect();
- assert_eq!(header_rules.len(), 1);
- assert!(header_rules.iter().all(|s| s.stroke.weight == 1.0));
- assert_eq!(footer_rules.len(), 1);
- assert!(footer_rules.iter().all(|s| s.stroke.weight == 2.0));
- assert_no_overlapping_rules(fragment);
- }
- assert!(composed.frames[0].tables[0].cell(1, 0).is_some());
- assert!(composed.frames[1].tables[0].cell(3, 0).is_some());
- }
-
- #[test]
- fn fragment_boundary_does_not_resolve_against_an_undisplayed_neighbor() {
- let mut table = rule_table(4, 1, 0, 0);
- set_rule(&mut table, 1, 0, 2, 3.0, 5);
- table.cell_mut(1, 0).unwrap().border_overrides[2] = true;
- set_rule(&mut table, 2, 0, 0, 4.0, 6);
- table.cell_mut(2, 0).unwrap().border_overrides[0] = true;
- // Two rows fit in each frame; leave room for the trailing empty paragraph.
- let composed = compose_two_fragments(table, 59.0);
- let first = &composed.frames[0].tables[0];
- let second = &composed.frames[1].tables[0];
- assert_eq!(first.strokes.len(), 1);
- assert_eq!(first.strokes[0].stroke.weight, 3.0);
- assert_eq!(first.strokes[0].a.y, first.rect.y1);
- assert_eq!(second.strokes.len(), 1);
- assert_eq!(second.strokes[0].stroke.weight, 4.0);
- assert_eq!(second.strokes[0].a.y, second.rect.y0);
- }
-}
+mod border_tests;
diff --git a/crates/compose/src/table/border_tests.rs b/crates/compose/src/table/border_tests.rs
new file mode 100644
index 000000000..5a28d7274
--- /dev/null
+++ b/crates/compose/src/table/border_tests.rs
@@ -0,0 +1,475 @@
+use super::*;
+use designcraft_doc::{CellRange, ParaFormat, SpreadRef, build::NewDocument};
+
+fn compose_table(table: Table) -> ComposedStory {
+ let mut doc = Document::new(&NewDocument::default());
+ let layer = doc.default_layer();
+ let (_, sid) = doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 120.0, 200.0), layer, "", ParaFormat::default()).unwrap();
+ doc.story_mut(sid).unwrap().insert_table(0, table);
+ crate::compose_story(&doc, sid, &ComposeOptions::default())
+}
+
+#[test]
+fn explicit_cell_edges_override_table_border_without_changing_native_defaults() {
+ let mut table = Table::new(77, 1, 1, 0, 0, 100.0);
+ table.options.border.weight = 2.0;
+ table.cell_mut(0, 0).unwrap().strokes = std::array::from_fn(|_| CellStroke::none());
+ let native = compose_table(table.clone());
+ let strokes = &native.frames[0].tables[0].strokes;
+ assert_eq!(strokes.len(), 4, "default cells still use all four table borders");
+ assert!(strokes.iter().all(|s| s.stroke.weight == 2.0));
+
+ let cell = table.cell_mut(0, 0).unwrap();
+ cell.border_overrides = [true, true, true, false];
+ cell.strokes[2] = CellStroke { weight: 3.0, ..Default::default() };
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2, "top and left None overrides suppress borders");
+ let bottom = fragment.strokes.iter().find(|s| s.a.y == fragment.rect.y1 && s.b.y == fragment.rect.y1).unwrap();
+ assert_eq!(bottom.stroke.weight, 3.0);
+ let right = fragment.strokes.iter().find(|s| s.a.x == fragment.rect.x1 && s.b.x == fragment.rect.x1).unwrap();
+ assert_eq!(right.stroke.weight, 2.0, "unoverridden right edge keeps the table border");
+}
+
+#[test]
+fn merged_cell_keeps_explicit_border_suppression() {
+ let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
+ table.merge(CellRange::new(0, 0, 1, 1)).unwrap();
+ let cell = table.cell_mut(0, 0).unwrap();
+ cell.border_overrides = [true; 4];
+ cell.strokes = std::array::from_fn(|_| CellStroke::none());
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.cells.len(), 1);
+ assert!(fragment.strokes.is_empty());
+}
+
+fn rule_table(body: usize, cols: usize, header: usize, footer: usize) -> Table {
+ let mut table = Table::new(77, body, cols, header, footer, 100.0);
+ table.options.border = CellStroke::none();
+ for row in &mut table.rows {
+ row.height = 20.0;
+ row.mode = RowHeightMode::Exactly;
+ }
+ for cell in &mut table.cells {
+ cell.insets = [0.0; 4];
+ cell.strokes = std::array::from_fn(|_| CellStroke::none());
+ }
+ table
+}
+
+fn set_rule(table: &mut Table, row: usize, col: usize, side: usize, weight: f64, priority: i32) {
+ let cell = table.cell_mut(row, col).unwrap();
+ cell.strokes[side] = CellStroke { weight, ..Default::default() };
+ cell.stroke_defined[side] = true;
+ cell.stroke_priorities[side] = priority;
+}
+
+fn assert_no_overlapping_rules(fragment: &TableFrag) {
+ for (i, a) in fragment.strokes.iter().enumerate() {
+ for b in &fragment.strokes[i + 1..] {
+ let horizontal_overlap = a.a.y == a.b.y && a.a.y == b.a.y && b.a.y == b.b.y && a.a.x.max(b.a.x) < a.b.x.min(b.b.x);
+ let vertical_overlap = a.a.x == a.b.x && a.a.x == b.a.x && b.a.x == b.b.x && a.a.y.max(b.a.y) < a.b.y.min(b.b.y);
+ assert!(!horizontal_overlap && !vertical_overlap, "duplicate shared edge: {a:?}, {b:?}");
+ }
+ }
+}
+
+#[test]
+fn header_bottom_only_style_survives_zero_body_edges() {
+ // Synthetic equivalent of a header with a one-point bottom rule and zero on all
+ // remaining header/body edges. Both sides supply style formatting at priority zero.
+ let mut table = rule_table(2, 3, 1, 0);
+ for cell in &mut table.cells {
+ cell.stroke_defined = [true; 4];
+ cell.border_overrides = [true; 4];
+ }
+ for col in 0..3 {
+ set_rule(&mut table, 0, col, 2, 1.0, 0);
+ }
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ let y = fragment.cell(0, 0).unwrap().rect.y1;
+ assert_eq!(fragment.strokes.len(), 3);
+ assert!(fragment.strokes.iter().all(|s| s.a.y == y && s.b.y == y && s.stroke.weight == 1.0));
+ assert_eq!(fragment.strokes.iter().map(|s| s.b.x - s.a.x).sum::<f64>(), 100.0);
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn shared_rules_choose_numeric_priority_once_and_preserve_drawing_order() {
+ let mut table = rule_table(2, 2, 0, 0);
+ set_rule(&mut table, 0, 0, 2, 3.0, 7);
+ set_rule(&mut table, 1, 0, 0, 1.0, 4);
+ set_rule(&mut table, 0, 0, 3, 4.0, 3);
+ set_rule(&mut table, 0, 1, 1, 2.0, 9);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ let horizontal = &fragment.strokes[0];
+ assert_eq!(horizontal.a.y, horizontal.b.y);
+ assert_eq!(horizontal.stroke.weight, 3.0);
+ let vertical = &fragment.strokes[1];
+ assert_eq!(vertical.a.x, vertical.b.x);
+ assert_eq!(vertical.stroke.weight, 2.0, "higher priority draws last at a crossing");
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn signed_negative_priorities_resolve_and_draw_in_numeric_order() {
+ let mut table = rule_table(2, 2, 0, 0);
+ set_rule(&mut table, 0, 0, 2, 1.0, -2);
+ set_rule(&mut table, 1, 0, 0, 3.0, -1);
+ set_rule(&mut table, 0, 0, 3, 2.0, -3);
+ set_rule(&mut table, 0, 1, 1, 4.0, -2);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ assert_eq!(fragment.strokes[0].stroke.weight, 4.0, "priority -2 draws before -1");
+ assert_eq!(fragment.strokes[0].a.x, fragment.strokes[0].b.x);
+ assert_eq!(fragment.strokes[1].stroke.weight, 3.0, "priority -1 wins over -2");
+ assert_eq!(fragment.strokes[1].a.y, fragment.strokes[1].b.y);
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn default_zero_priority_beats_a_negative_priority_rule() {
+ let mut table = rule_table(2, 1, 0, 0);
+ set_rule(&mut table, 0, 0, 2, 3.0, -1);
+ assert_eq!(table.cell(1, 0).unwrap().stroke_priorities, [0; 4]);
+ let composed = compose_table(table.clone());
+ assert!(composed.frames[0].tables[0].strokes.is_empty(), "priority zero None suppresses priority -1");
+ table.cell_mut(1, 0).unwrap().strokes[0] = CellStroke::default();
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 1);
+ assert_eq!(fragment.strokes[0].stroke.weight, 1.0, "the priority-zero native rule wins over priority -1");
+}
+
+#[test]
+fn higher_priority_zero_or_none_suppresses_a_visible_shared_rule() {
+ for invisible in [CellStroke::none(), CellStroke { color: designcraft_color::swatch::NONE.into(), ..Default::default() }] {
+ let mut table = rule_table(2, 2, 0, 0);
+ set_rule(&mut table, 0, 0, 2, 3.0, 7);
+ set_rule(&mut table, 1, 0, 0, 0.0, 8);
+ table.cell_mut(1, 0).unwrap().strokes[0] = invisible.clone();
+ set_rule(&mut table, 0, 0, 3, 3.0, 7);
+ set_rule(&mut table, 0, 1, 1, 0.0, 8);
+ table.cell_mut(0, 1).unwrap().strokes[1] = invisible;
+ let composed = compose_table(table);
+ assert!(composed.frames[0].tables[0].strokes.is_empty());
+ }
+}
+
+#[test]
+fn supplied_zero_shared_edge_beats_missing_native_default() {
+ let mut table = Table::new(77, 2, 1, 0, 0, 100.0);
+ table.options.border = CellStroke::none();
+ let upper = table.cell_mut(0, 0).unwrap();
+ upper.strokes[2] = CellStroke::none();
+ upper.stroke_defined[2] = true;
+ let composed = compose_table(table.clone());
+ assert!(composed.frames[0].tables[0].strokes.is_empty(), "explicit zero beats a missing edge's one-point default");
+ table.cell_mut(0, 0).unwrap().stroke_defined[2] = false;
+ let composed = compose_table(table);
+ assert_eq!(composed.frames[0].tables[0].strokes.len(), 1, "a missing zero cannot suppress the opposite visible default");
+}
+
+#[test]
+fn specified_zero_priority_outer_edges_keep_per_side_table_borders() {
+ for direction in [designcraft_doc::TextDirection::LeftToRight, designcraft_doc::TextDirection::RightToLeft] {
+ let mut table = rule_table(1, 1, 0, 0);
+ table.options.direction = direction;
+ table.options.borders = std::array::from_fn(|i| Some(CellStroke { weight: (i + 1) as f64, ..Default::default() }));
+ table.cell_mut(0, 0).unwrap().stroke_defined = [true; 4];
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 4);
+ for rule in &fragment.strokes {
+ let expected = if rule.a.y == rule.b.y {
+ if rule.a.y == fragment.rect.y0 { 1.0 } else { 3.0 }
+ } else if rule.a.x == fragment.rect.x0 {
+ 2.0
+ } else {
+ 4.0
+ };
+ assert_eq!(rule.stroke.weight, expected, "priority-zero cell values do not override perimeter formatting");
+ }
+ assert_no_overlapping_rules(fragment);
+ }
+}
+
+fn uniform_pattern(weight: f64) -> designcraft_doc::AltStrokes {
+ let stroke = CellStroke { weight, ..Default::default() };
+ designcraft_doc::AltStrokes { first: 1, next: 1, first_stroke: stroke.clone(), next_stroke: stroke, skip_first: 0, skip_last: 0 }
+}
+
+#[test]
+fn uniform_zero_table_patterns_suppress_missing_grid_edges_but_not_perimeter() {
+ let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
+ table.options.row_strokes = Some(uniform_pattern(0.0));
+ table.options.column_strokes = Some(uniform_pattern(0.0));
+ table.options.border.weight = 2.0;
+ let composed = compose_table(table.clone());
+ let fragment = &composed.frames[0].tables[0];
+ assert!(!fragment.strokes.is_empty(), "table perimeter remains visible");
+ assert!(fragment.strokes.iter().all(|s| {
+ s.stroke.weight == 2.0
+ && ((s.a.x == s.b.x && (s.a.x == fragment.rect.x0 || s.a.x == fragment.rect.x1))
+ || (s.a.y == s.b.y && (s.a.y == fragment.rect.y0 || s.a.y == fragment.rect.y1)))
+ }));
+ assert_no_overlapping_rules(fragment);
+ table.options.border = CellStroke::none();
+ set_rule(&mut table, 0, 0, 2, 3.0, 0);
+ set_rule(&mut table, 0, 1, 1, 4.0, 0);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2, "supplied cell strokes override the table patterns");
+ assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 3.0));
+ assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 4.0));
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn uniform_visible_table_patterns_supply_continuous_rules_below_explicit_none() {
+ let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
+ table.options.border = CellStroke::none();
+ table.options.row_strokes = Some(uniform_pattern(2.0));
+ table.options.column_strokes = Some(uniform_pattern(3.0));
+ let composed = compose_table(table.clone());
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2, "a table pattern stays continuous across cell boundaries");
+ assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 2.0 && s.b.x - s.a.x == 100.0));
+ assert!(fragment.strokes.iter().any(|s| s.stroke.weight == 3.0 && s.b.y - s.a.y == fragment.rect.height()));
+ for cell in &mut table.cells {
+ cell.strokes = std::array::from_fn(|_| CellStroke::none());
+ cell.stroke_defined = [true; 4];
+ }
+ let composed = compose_table(table);
+ assert!(composed.frames[0].tables[0].strokes.is_empty(), "explicit cell None is stronger than table patterns");
+}
+
+#[test]
+fn uniform_table_patterns_leave_header_and_footer_edges_unchanged() {
+ let mut table = Table::new(77, 2, 2, 1, 1, 100.0);
+ table.options.border = CellStroke::none();
+ table.options.row_strokes = Some(uniform_pattern(0.0));
+ table.options.column_strokes = Some(uniform_pattern(0.0));
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ let header = fragment.cell(0, 0).unwrap().rect;
+ let body = fragment.cell(1, 0).unwrap().rect;
+ let footer = fragment.cell(3, 0).unwrap().rect;
+ assert!(fragment.strokes.iter().any(|s| s.a == Point::new(header.x1, header.y0) && s.b == Point::new(header.x1, header.y1)));
+ assert!(fragment.strokes.iter().any(|s| s.a == Point::new(footer.x1, footer.y0) && s.b == Point::new(footer.x1, footer.y1)));
+ assert!(!fragment.strokes.iter().any(|s| s.a.y == body.y1 && s.b.y == body.y1));
+ assert!(!fragment.strokes.iter().any(|s| s.a == Point::new(body.x1, body.y0) && s.b == Point::new(body.x1, body.y1)));
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn unverified_nonuniform_or_skipped_pattern_phase_keeps_native_edges() {
+ for skipped in [false, true] {
+ let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
+ table.options.border = CellStroke::none();
+ let mut pattern = uniform_pattern(2.0);
+ if skipped {
+ pattern.skip_first = 1;
+ } else {
+ pattern.next_stroke.weight = 3.0;
+ }
+ table.options.row_strokes = Some(pattern.clone());
+ table.options.column_strokes = Some(pattern);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 4);
+ assert!(fragment.strokes.iter().all(|s| s.stroke.weight == 1.0));
+ }
+}
+
+#[test]
+fn metadata_free_native_and_legacy_edges_keep_top_and_left_suppression() {
+ let mut table = Table::new(77, 2, 2, 0, 0, 100.0);
+ table.options.border = CellStroke::none();
+ let composed = compose_table(table.clone());
+ assert_eq!(composed.frames[0].tables[0].strokes.len(), 4, "unmodified native grid control");
+ // The metadata arrays also default to zero/false when reading legacy JSON. Older
+ // native table.setCell code changed these strokes without setting any metadata.
+ table.cell_mut(1, 0).unwrap().strokes[0] = CellStroke::none();
+ table.cell_mut(0, 1).unwrap().strokes[1].color = designcraft_color::swatch::NONE.into();
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ let hidden_top = fragment.cell(1, 0).unwrap().rect;
+ let hidden_left = fragment.cell(0, 1).unwrap().rect;
+ assert!(!fragment.strokes.iter().any(|s| s.a == Point::new(hidden_top.x0, hidden_top.y0) && s.b == Point::new(hidden_top.x1, hidden_top.y0)));
+ assert!(!fragment.strokes.iter().any(|s| s.a == Point::new(hidden_left.x0, hidden_left.y0) && s.b == Point::new(hidden_left.x0, hidden_left.y1)));
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn equal_priority_visible_rules_keep_top_and_left_ownership() {
+ let mut table = rule_table(2, 2, 0, 0);
+ set_rule(&mut table, 0, 0, 2, 5.0, 0);
+ set_rule(&mut table, 1, 0, 0, 2.0, 0);
+ set_rule(&mut table, 0, 0, 3, 6.0, 0);
+ set_rule(&mut table, 0, 1, 1, 3.0, 0);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ assert_eq!(fragment.strokes[0].stroke.weight, 2.0);
+ assert_eq!(fragment.strokes[1].stroke.weight, 3.0);
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn row_spanning_edge_resolves_each_neighbor_without_internal_rules() {
+ let mut table = rule_table(2, 2, 0, 0);
+ table.merge(CellRange::new(0, 0, 1, 0)).unwrap();
+ set_rule(&mut table, 0, 0, 3, 1.0, 5);
+ set_rule(&mut table, 0, 1, 1, 2.0, 6);
+ set_rule(&mut table, 1, 1, 1, 3.0, 4);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ let upper = fragment.strokes.iter().find(|s| s.stroke.weight == 2.0).unwrap();
+ let lower = fragment.strokes.iter().find(|s| s.stroke.weight == 1.0).unwrap();
+ assert_eq!(upper.a, Point::new(50.0, fragment.rect.y0));
+ assert_eq!(upper.b, lower.a);
+ assert_eq!(lower.b, Point::new(50.0, fragment.rect.y1));
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn column_spanning_edge_resolves_each_neighbor_without_internal_rules() {
+ let mut table = rule_table(2, 2, 0, 0);
+ table.merge(CellRange::new(0, 0, 0, 1)).unwrap();
+ set_rule(&mut table, 0, 0, 2, 1.0, 5);
+ set_rule(&mut table, 1, 0, 0, 2.0, 6);
+ set_rule(&mut table, 1, 1, 0, 3.0, 4);
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 2);
+ let left = fragment.strokes.iter().find(|s| s.stroke.weight == 2.0).unwrap();
+ let right = fragment.strokes.iter().find(|s| s.stroke.weight == 1.0).unwrap();
+ let y = fragment.cell(0, 0).unwrap().rect.y1;
+ assert_eq!(left.a, Point::new(fragment.rect.x0, y));
+ assert_eq!(left.b, right.a);
+ assert_eq!(right.b, Point::new(fragment.rect.x1, y));
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn merged_winning_dashed_edge_stays_continuous_across_losing_neighbors() {
+ let mut table = rule_table(2, 2, 0, 0);
+ table.columns.iter_mut().for_each(|column| column.width = 45.0);
+ table.merge(CellRange::new(1, 0, 1, 1)).unwrap();
+ set_rule(&mut table, 1, 0, 0, 1.0, 1);
+ table.cell_mut(1, 0).unwrap().strokes[0].kind = designcraft_doc::StrokeType::Dashed { pattern: vec![6.0, 4.0] };
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 1, "one winning source edge must retain one dash phase");
+ let rule = &fragment.strokes[0];
+ let merged = fragment.cell(1, 0).unwrap().rect;
+ assert_eq!(rule.a, Point::new(merged.x0, merged.y0));
+ assert_eq!(rule.b, Point::new(merged.x1, merged.y0));
+ assert_eq!(rule.b.x - rule.a.x, 90.0);
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn merged_perimeter_keeps_four_continuous_strokes() {
+ let mut table = rule_table(2, 2, 0, 0);
+ table.merge(CellRange::new(0, 0, 1, 1)).unwrap();
+ table.options.border.weight = 2.0;
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 4);
+ assert_eq!(fragment.strokes.iter().filter(|s| s.a.y == s.b.y).count(), 2);
+ assert_eq!(fragment.strokes.iter().filter(|s| s.a.x == s.b.x).count(), 2);
+ assert_no_overlapping_rules(fragment);
+}
+
+#[test]
+fn rtl_shared_rules_use_physical_edges_and_outer_borders() {
+ let mut table = rule_table(1, 2, 0, 0);
+ table.options.direction = designcraft_doc::TextDirection::RightToLeft;
+ table.columns[0].width = 30.0;
+ table.columns[1].width = 70.0;
+ set_rule(&mut table, 0, 0, 1, 2.0, 9);
+ set_rule(&mut table, 0, 1, 3, 4.0, 2);
+ set_rule(&mut table, 0, 0, 3, 5.0, 3);
+ table.cell_mut(0, 0).unwrap().border_overrides[3] = true;
+ set_rule(&mut table, 0, 1, 1, 6.0, 4);
+ table.cell_mut(0, 1).unwrap().border_overrides[1] = true;
+ let composed = compose_table(table);
+ let fragment = &composed.frames[0].tables[0];
+ assert_eq!(fragment.strokes.len(), 3);
+ for (x, weight) in [(0.0, 6.0), (70.0, 2.0), (100.0, 5.0)] {
+ let rule = fragment.strokes.iter().find(|s| s.a.x == x && s.b.x == x).unwrap();
+ assert_eq!(rule.stroke.weight, weight);
+ }
+ assert_no_overlapping_rules(fragment);
+}
+
+fn compose_two_fragments(table: Table, height: f64) -> ComposedStory {
+ let mut doc = Document::new(&NewDocument::default());
+ let layer = doc.default_layer();
+ let (first, sid) = doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 0.0, 120.0, height), layer, "", ParaFormat::default()).unwrap();
+ let (second, _) = doc.add_text_frame(SpreadRef::Doc(0), Rect::new(0.0, 200.0, 120.0, 200.0 + height), layer, "", ParaFormat::default()).unwrap();
+ doc.thread(first, second).unwrap();
+ doc.story_mut(sid).unwrap().insert_table(0, table);
+ let composed = crate::compose_story(&doc, sid, &ComposeOptions::default());
+ assert!(!composed.is_overset(), "overset at {:?}", composed.overset_at);
+ assert_eq!(composed.frames[0].tables.len(), 1);
+ assert_eq!(composed.frames[1].tables.len(), 1);
+ composed
+}
+
+#[test]
+fn repeated_header_and_footer_rules_resolve_displayed_fragment_neighbors() {
+ let mut table = rule_table(4, 2, 1, 1);
+ table.merge(CellRange::new(0, 0, 0, 1)).unwrap();
+ table.merge(CellRange::new(5, 0, 5, 1)).unwrap();
+ set_rule(&mut table, 0, 0, 2, 1.0, 2);
+ set_rule(&mut table, 5, 0, 0, 2.0, 3);
+ // Keep 19 points for the anchor's trailing empty paragraph, still below the
+ // 100 points needed to fit a third body row plus the header and footer.
+ let composed = compose_two_fragments(table, 99.0);
+ for (i, frame) in composed.frames.iter().enumerate() {
+ let fragment = &frame.tables[0];
+ let header = fragment.cell(0, 0).unwrap();
+ let footer = fragment.cell(5, 0).unwrap();
+ assert_eq!(header.repeated, i == 1);
+ assert_eq!(footer.repeated, i == 0);
+ assert_eq!(fragment.strokes.len(), 2);
+ let header_rules: Vec<_> = fragment.strokes.iter().filter(|s| s.a.y == header.rect.y1 && s.b.y == header.rect.y1).collect();
+ let footer_rules: Vec<_> = fragment.strokes.iter().filter(|s| s.a.y == footer.rect.y0 && s.b.y == footer.rect.y0).collect();
+ assert_eq!(header_rules.len(), 1);
+ assert!(header_rules.iter().all(|s| s.stroke.weight == 1.0));
+ assert_eq!(footer_rules.len(), 1);
+ assert!(footer_rules.iter().all(|s| s.stroke.weight == 2.0));
+ assert_no_overlapping_rules(fragment);
+ }
+ assert!(composed.frames[0].tables[0].cell(1, 0).is_some());
+ assert!(composed.frames[1].tables[0].cell(3, 0).is_some());
+}
+
+#[test]
+fn fragment_boundary_does_not_resolve_against_an_undisplayed_neighbor() {
+ let mut table = rule_table(4, 1, 0, 0);
+ set_rule(&mut table, 1, 0, 2, 3.0, 5);
+ table.cell_mut(1, 0).unwrap().border_overrides[2] = true;
+ set_rule(&mut table, 2, 0, 0, 4.0, 6);
+ table.cell_mut(2, 0).unwrap().border_overrides[0] = true;
+ // Two rows fit in each frame; leave room for the trailing empty paragraph.
+ let composed = compose_two_fragments(table, 59.0);
+ let first = &composed.frames[0].tables[0];
+ let second = &composed.frames[1].tables[0];
+ assert_eq!(first.strokes.len(), 1);
+ assert_eq!(first.strokes[0].stroke.weight, 3.0);
+ assert_eq!(first.strokes[0].a.y, first.rect.y1);
+ assert_eq!(second.strokes.len(), 1);
+ assert_eq!(second.strokes[0].stroke.weight, 4.0);
+ assert_eq!(second.strokes[0].a.y, second.rect.y0);
+}