craft-html, craft-flow: preserve table structure, colgroup widths and vertical merges (#1785) (#1802)

* craft-html, craft-flow: preserve table structure, colgroup widths and vertical merges (#1785)

* craft-html: address CodeRabbit review feedback on vmerge and colgroups (#1785)

* craft-html: precompute grid column offsets in table export

* craft-html: preserve fully covered rows during table import (#1785)

* craft-html: resolve merge conflict artifacts and unclosed delimiter in tests (#1785)

* craft-flow, craft-html: validate matching spans on vmerge and preserve leading grid columns (#1785)
This commit is contained in:
batistalucasv authored and GitHub committed 2026-11-17 21:31:10 -06:00
1 parent c52dc70c6c
commit c0edd96888
6 files changed
+681 -23

No files matched your search

+5
View File
@@ -1114,6 +1114,9 @@ fn flow_table(doc: &Document, t: &Table, depth: usize, tracked: FlowOpts) -> FTa
// Word. Only Repeat as header row makes it one then.
let header = r.props.header || (ri == 0 && style.is_some() && t.props.look.header_row && t.rows.len() > 1);
let mut cells = Vec::new();
for _ in 0..r.first_grid() {
cells.push(Cell::default());
}
for (ci, c) in r.cells.iter().enumerate() {
let styled = if bake { styled_cell(t, style.as_ref(), (ri, ci), ncols) } else { None };
let mut rowspan = 1;
@@ -1159,6 +1162,8 @@ fn flow_table(doc: &Document, t: &Table, depth: usize, tracked: FlowOpts) -> FTa
Some(Box::new(crate::CellPic { img, repeat: p.repeat, align: p.align }))
}),
width: None,
vmerge_restart: c.props.vmerge == VMerge::Restart,
synthetic_covered: false,
});
}
rows.push(cells);
+35
View File
@@ -907,6 +907,41 @@ impl<'a> Builder<'a> {
}
tb.rows.push(row);
}
let starts: Vec<(usize, usize)> = (0..tb.rows.first().map_or(0, |row| row.cells.len()))
.filter(|&ci| tb.rows.first().and_then(|row| row.cells.get(ci)).is_some_and(|c| c.props.vmerge == VMerge::Continue))
.map(|ci| (ci, tb.grid_col(0, ci)))
.collect();
for (ci, g) in starts {
let span = tb.rows.first().map_or(1, |r| r.cells[ci].props.span);
let more = tb
.cell_at_grid(1, g)
.filter(|&i| tb.grid_col(1, i) == g)
.and_then(|i| tb.rows.get(1)?.cells.get(i))
.is_some_and(|c| c.props.vmerge == VMerge::Continue && c.props.span == span);
if let Some(cell) = tb.rows.first_mut().and_then(|r| r.cells.get_mut(ci)) {
cell.props.vmerge = if more { VMerge::Restart } else { VMerge::None };
}
}
for r in 1..tb.rows.len() {
for ci in 0..tb.rows[r].cells.len() {
if tb.rows[r].cells[ci].props.vmerge == VMerge::Continue {
let g = tb.grid_col(r, ci);
let span = tb.rows[r].cells[ci].props.span;
let prev_r = r - 1;
if let Some(up_ci) = tb.cell_at_grid(prev_r, g)
&& tb.grid_col(prev_r, up_ci) == g
&& tb.rows[prev_r].cells[up_ci].props.span == span
{
let up_cell = &mut tb.rows[prev_r].cells[up_ci];
if up_cell.props.vmerge == VMerge::None {
up_cell.props.vmerge = VMerge::Restart;
}
} else {
tb.rows[r].cells[ci].props.vmerge = VMerge::None;
}
}
}
}
// Its markup kept for the writer, by its place among the top's tables.
if depth == 0 {
if t.kept.is_some() || t.wrap.is_some() {
+15 -3
View File
@@ -881,6 +881,10 @@ pub struct Cell {
/// The width, points, the source gives a cell spanning one column (HTML): see
/// [`FTable::widths_from_cells`].
pub width: Option<f32>,
/// Whether the source explicitly started a vertical merge (`mso-yfti-vmerge:restart`).
pub vmerge_restart: bool,
/// Whether this covered placeholder was synthesized by [`FTable::insert_covered`].
pub synthetic_covered: bool,
}
/// A cell's background picture: the picture at its own size, how it fills the cell, and where an
@@ -907,6 +911,8 @@ impl Default for Cell {
direction: Default::default(),
picture: None,
width: None,
vmerge_restart: false,
synthetic_covered: false,
}
}
}
@@ -999,8 +1005,8 @@ impl FTable {
let mut g = 0usize;
let mut ci = 0usize;
while let Some(c) = self.rows.get(r).and_then(|row| row.get(ci)) {
let (span, rs, covered) = (c.colspan.clamp(1, 63) as usize, c.rowspan.clamp(1, 1000) as usize, c.covered);
if rs > 1 && !covered {
let (span, rs, vmerge_restart) = (c.colspan.clamp(1, 63) as usize, c.rowspan.clamp(1, 1000) as usize, c.vmerge_restart);
if rs > 1 {
for k in 1..rs {
work += 1;
if work > MAX_COVERED_WORK {
@@ -1017,8 +1023,14 @@ impl FTable {
}
x += cc.colspan.clamp(1, 63) as usize;
}
if at < row.len() && x == g && row[at].covered && (vmerge_restart || row[at].synthetic_covered) {
// Row already has a matching explicit continuation (when this cell had
// `mso-yfti-vmerge:restart`) or a synthetic placeholder from an earlier
// row. Avoid adding a duplicate covered cell which would make the row ragged.
continue;
}
if row.len() < 64 {
row.insert(at, Cell { colspan: span as u32, covered: true, ..Default::default() });
row.insert(at, Cell { colspan: span as u32, covered: true, synthetic_covered: true, ..Default::default() });
}
}
}
+128 -14
View File
@@ -55,6 +55,27 @@ struct TableB {
row: Option<Vec<Cell>>,
/// The table or one of its cells asks for borders.
bordered: bool,
/// Explicit column widths from `<col>` and childless `<colgroup>`.
col_widths: Vec<Option<f32>>,
/// Pending `<colgroup>`: `(span, width, has_child_cols)`.
pending_colgroup: Option<(usize, Option<f32>, bool)>,
}
impl TableB {
/// Commit pending colgroup widths: if childless, push span columns with group width.
/// When child `<col>` elements are present, they have already received the group width
/// during `<col>` handling; columns from earlier groups are never backfilled.
fn commit_pending_colgroup(&mut self) {
if let Some((span, group_w, has_child_cols)) = self.pending_colgroup.take()
&& !has_child_cols
{
for _ in 0..span {
if self.col_widths.len() < MAX_TABLE_COLS {
self.col_widths.push(group_w);
}
}
}
}
}
struct ElementStyle {
@@ -863,6 +884,15 @@ impl<'r> Builder<'r> {
}
}
/// Finalize an open HTML element popped from the stack.
///
/// Side effects:
/// - Flushes any buffered inline text into the current block container.
/// - Sets `pending_page_break` if the element requests page break before or after.
/// - For `Cell`: pops the cell container, attaches generated blocks to the cell, and pushes into the active row.
/// - For `Tr`: commits any pending `<colgroup>` definitions and pushes the completed row into the active table.
/// - For `Table`: commits pending colgroup widths, finalizes table rows with `insert_covered` (bounded to `MAX_ROWS`),
/// resolves explicit column widths from colgroups/cells, and appends the resulting table to the enclosing container.
fn close(&mut self, e: &El) {
if e.page_break_after || e.page_break {
self.pending_page_break = true;
@@ -881,26 +911,53 @@ impl<'r> Builder<'r> {
}
}
ElKind::Tr => {
if let Some(t) = self.tables.last_mut()
&& let Some(r) = t.row.take()
{
t.rows.push(r);
if let Some(t) = self.tables.last_mut() {
t.commit_pending_colgroup();
if let Some(r) = t.row.take() {
t.rows.push(r);
}
}
}
ElKind::Table => {
if let Some(mut t) = self.tables.pop() {
t.commit_pending_colgroup();
if let Some(r) = t.row.take() {
t.rows.push(r);
}
let borderless = !t.bordered;
// Keep at most MAX_ROWS rows (the model drops the rest anyway): bounds the
// O(rows × rowspan) work of `insert_covered` on a table of millions of `<tr>`.
let rows: Vec<_> = t.rows.into_iter().filter(|r| !r.is_empty()).take(craft_wordmodel::table::MAX_ROWS).collect();
let rows: Vec<_> = t.rows.into_iter().take(craft_wordmodel::table::MAX_ROWS).collect();
let mut ft = FTable { rows, widths: Vec::new(), borderless, extra: None, kept: None, wrap: None };
let col_widths = &t.col_widths;
if !ft.rows.is_empty() {
ft.insert_covered();
// Columns keep the widths their cells give when every column has one.
if ft.cols() <= MAX_TABLE_COLS {
ft.rows.retain(|r| !r.is_empty());
}
if !ft.rows.is_empty() {
if !col_widths.is_empty() && ft.cols() <= MAX_TABLE_COLS {
let mut widths = vec![None; ft.cols()];
for (i, &cw) in col_widths.iter().take(ft.cols()).enumerate() {
if let Some(w) = cw {
widths[i] = Some(w);
}
}
for row in &ft.rows {
let mut g = 0;
for c in row {
if let (Some(w), Some(slot)) = (c.width, widths.get_mut(g)) {
slot.get_or_insert(w);
}
g += c.colspan.clamp(1, 63) as usize;
}
}
if widths.iter().any(Option::is_some) {
let known_sum: f32 = widths.iter().filter_map(|w| *w).sum();
let known_count = widths.iter().filter(|w| w.is_some()).count();
let avg = if known_count > 0 { known_sum / known_count as f32 } else { 72.0 };
ft.widths = widths.into_iter().map(|w| w.unwrap_or(avg)).collect();
}
} else if ft.cols() <= MAX_TABLE_COLS {
ft.widths_from_cells();
}
self.container().push(FBlock::Table(ft));
@@ -1001,6 +1058,14 @@ impl<'r> Builder<'r> {
}
}
/// Process void or special HTML elements (`br`, `hr`, `wbr`, `col`, `colgroup`, `img`).
///
/// Side effects:
/// - `br` / `wbr`: inserts line break or zero-width break into the active paragraph.
/// - `hr`: inserts a thematic horizontal rule block with borders and spacing into the container.
/// - `col`: extracts span and explicit CSS width, resolves against active `<colgroup>`, and appends up to `MAX_TABLE_COLS` column widths to the table.
/// - `colgroup`: commits any previous pending colgroup and buffers new span and width styles until child cols or closing tag arrive.
/// - `img`: parses dimensions, styles, and data/remote sources, creating an image block or inline image run.
fn start_special(&mut self, name: &str, attrs: &[(String, String)]) -> bool {
match name {
"br" => {
@@ -1020,6 +1085,34 @@ impl<'r> Builder<'r> {
let fmt = self.fmt();
self.start_para().push_text("\u{200B}", &fmt);
}
"col" => {
let css = self.css_of(name, attrs);
let span = attr(attrs, "span").and_then(|v| v.trim().parse::<usize>().ok()).unwrap_or(1).clamp(1, MAX_TABLE_COLS);
let w = cell_width(&css, attrs);
if let Some(t) = self.tables.last_mut() {
let group_w = if let Some((_, group_w, has_child_cols)) = &mut t.pending_colgroup {
*has_child_cols = true;
*group_w
} else {
None
};
let effective_w = w.or(group_w);
for _ in 0..span {
if t.col_widths.len() < MAX_TABLE_COLS {
t.col_widths.push(effective_w);
}
}
}
}
"colgroup" => {
let css = self.css_of(name, attrs);
let span = attr(attrs, "span").and_then(|v| v.trim().parse::<usize>().ok()).unwrap_or(1).clamp(1, MAX_TABLE_COLS);
let w = cell_width(&css, attrs);
if let Some(t) = self.tables.last_mut() {
t.commit_pending_colgroup();
t.pending_colgroup = Some((span, w, false));
}
}
"img" => {
let alt = attr(attrs, "alt").unwrap_or("").to_string();
let dim = |key: &str| attr(attrs, key).and_then(|v| v.trim().trim_end_matches("px").trim().parse::<f32>().ok()).map(|p| p * 0.75);
@@ -1164,12 +1257,20 @@ impl<'r> Builder<'r> {
let css = self.css_of(name, attrs);
let ElementStyle { mut fmt, block_background, align, preserve, page_break, page_break_after } = self.element_style(name, attrs, kind, &css);
match kind {
ElKind::Table => self.tables.push(TableB { rows: Vec::new(), row: None, bordered: declares_border(attrs, &css, true) }),
ElKind::Table => self.tables.push(TableB {
rows: Vec::new(),
row: None,
bordered: declares_border(attrs, &css, true),
col_widths: Vec::new(),
pending_colgroup: None,
}),
ElKind::Tr => {
if let Some(t) = self.tables.last_mut()
&& let Some(r) = t.row.take()
{
t.rows.push(r);
if let Some(t) = self.tables.last_mut() {
t.commit_pending_colgroup();
if let Some(r) = t.row.take() {
t.rows.push(r);
}
t.row = Some(Vec::new());
}
}
ElKind::Cell => {
@@ -1216,11 +1317,16 @@ impl<'r> Builder<'r> {
_ => {}
}
}
// The last declaration wins, as in the cascade.
let mso_vmerge = decls(&css).filter(|(k, _)| k == "mso-yfti-vmerge").last().map(|(_, v)| v.trim().to_ascii_lowercase());
let is_mso_vmerge_continue = mso_vmerge.as_deref() == Some("continue");
let is_mso_vmerge_restart = mso_vmerge.as_deref() == Some("restart");
let rowspan = attr(attrs, "rowspan").and_then(|v| v.trim().parse::<u32>().ok()).map(|v| v.clamp(1, 1000)).unwrap_or(1);
self.cells.push(Cell {
blocks: Vec::new(),
colspan,
rowspan: attr(attrs, "rowspan").and_then(|v| v.trim().parse::<u32>().ok()).map(|v| v.clamp(1, 1000)).unwrap_or(1),
covered: false,
rowspan,
covered: is_mso_vmerge_continue,
header: name == "th",
shading,
borders: cell_borders(&css),
@@ -1229,6 +1335,8 @@ impl<'r> Builder<'r> {
direction: Default::default(),
picture: None,
width: if colspan == 1 { cell_width(&css, attrs) } else { None },
vmerge_restart: is_mso_vmerge_restart,
synthetic_covered: false,
});
fmt.background = None;
self.containers.push(Vec::new());
@@ -1261,6 +1369,12 @@ impl<'r> Builder<'r> {
}
return;
}
if name == "colgroup" {
if let Some(t) = self.tables.last_mut() {
t.commit_pending_colgroup();
}
return;
}
let crosses = matches!(name, "table");
let target = if matches!(name, "td" | "th") {
self.find_open(|e| e.kind == ElKind::Cell, |e| e.kind == ElKind::Table)
+75 -6
View File
@@ -263,21 +263,87 @@ fn para_html(p: &Para) -> String {
}
}
/// Render an HTML table element, emitting `<colgroup>` column widths and cell attributes.
fn table_html(t: &FTable, out: &mut String, depth: usize) {
out.push_str("<table style=\"border-collapse:collapse\">\n");
for row in &t.rows {
out.push_str("<tr>");
for c in row {
if c.covered {
if !t.widths.is_empty() {
out.push_str("<colgroup>\n");
for w in &t.widths {
out.push_str(&format!("<col style=\"width:{w:.2}pt\">\n"));
}
out.push_str("</colgroup>\n");
}
let nrows = t.rows.len();
let grid_cols: Vec<Vec<usize>> = t
.rows
.iter()
.map(|row| {
let mut x = 0usize;
row.iter()
.map(|c| {
let start = x;
x = x.saturating_add(c.colspan.clamp(1, 63) as usize);
start
})
.collect()
})
.collect();
let cell_at_grid = |r: usize, target_g: usize| -> Option<usize> { grid_cols.get(r)?.binary_search(&target_g).ok() };
let grid_col = |r: usize, ci: usize| -> usize { grid_cols.get(r).and_then(|row| row.get(ci)).copied().unwrap_or(0) };
let mut is_covered: Vec<Vec<bool>> = t.rows.iter().map(|r| vec![false; r.len()]).collect();
let mut rowspans: Vec<Vec<u32>> = t.rows.iter().map(|r| r.iter().map(|c| c.rowspan.clamp(1, 1000)).collect()).collect();
for r in 0..nrows {
let row_len = t.rows.get(r).map_or(0, |row| row.len());
for ci in 0..row_len {
if is_covered.get(r).and_then(|row| row.get(ci)).copied().unwrap_or(false) {
continue;
}
let Some(c) = t.rows.get(r).and_then(|row| row.get(ci)) else { continue };
let g = grid_col(r, ci);
let span = c.colspan.clamp(1, 63) as usize;
let mut extent = 1u32;
for down_r in (r + 1)..nrows {
let Some(down_ci) = cell_at_grid(down_r, g) else { break };
let Some(down_c) = t.rows.get(down_r).and_then(|row| row.get(down_ci)) else { break };
let down_covered = is_covered.get(down_r).and_then(|row| row.get(down_ci)).copied().unwrap_or(false);
if grid_col(down_r, down_ci) == g
&& down_c.colspan.clamp(1, 63) as usize == span
&& down_c.covered
&& !down_c.vmerge_restart
&& !down_covered
{
if let Some(down_row) = is_covered.get_mut(down_r)
&& let Some(slot) = down_row.get_mut(down_ci)
{
*slot = true;
}
extent = extent.saturating_add(1);
} else {
break;
}
}
if let Some(slot) = rowspans.get_mut(r).and_then(|row| row.get_mut(ci)) {
*slot = (*slot).max(extent);
}
}
}
for (ri, row) in t.rows.iter().enumerate() {
out.push_str("<tr>");
for (ci, c) in row.iter().enumerate() {
if is_covered.get(ri).and_then(|r| r.get(ci)).copied().unwrap_or(false) {
continue;
}
let rowspan = rowspans.get(ri).and_then(|r| r.get(ci)).copied().unwrap_or(c.rowspan.clamp(1, 1000));
let tag = if c.header { "th" } else { "td" };
let mut attrs = String::new();
if c.colspan > 1 {
attrs.push_str(&format!(" colspan=\"{}\"", c.colspan));
}
if c.rowspan > 1 {
attrs.push_str(&format!(" rowspan=\"{}\"", c.rowspan));
if rowspan > 1 {
attrs.push_str(&format!(" rowspan=\"{}\"", rowspan));
}
let v_css = match c.valign {
Some(VAlign::Center) => "vertical-align:middle",
@@ -288,6 +354,9 @@ fn table_html(t: &FTable, out: &mut String, depth: usize) {
if !t.borderless {
css.insert(0, "border:1px solid #999".to_string());
}
if let Some(w) = c.width {
css.push(format!("width:{w:.2}pt"));
}
if let Some(s) = c.shading {
css.push(format!("background-color:#{}", s.hex()));
}
+423
View File
@@ -717,6 +717,195 @@ fn cells_give_their_columns_widths() {
assert_eq!(t.widths, [75.0, 150.0]);
}
#[test]
fn col_elements_give_table_column_widths() {
let f = parse("<table><colgroup><col width=100><col style='width: 150pt'></colgroup><tr><td>A</td><td>B</td></tr></table>");
let FBlock::Table(t) = &f.blocks[0] else { panic!() };
assert_eq!(t.widths, [75.0, 150.0]);
// col with span
let f2 = parse(
"<table><colgroup><col span=2 style='width: 72pt'><col style='width: 144pt'></colgroup><tr><td>1</td><td>2</td><td>3</td></tr></table>",
);
let FBlock::Table(t2) = &f2.blocks[0] else { panic!() };
assert_eq!(t2.widths, [72.0, 72.0, 144.0]);
// Childless colgroup defines widths across declared span
let f3 = parse("<table><colgroup span=2 width=100></colgroup><tr><td>1</td><td>2</td></tr></table>");
let FBlock::Table(t3) = &f3.blocks[0] else { panic!() };
assert_eq!(t3.widths, [75.0, 75.0]);
// Child col elements override colgroup widths
let f4 = parse("<table><colgroup width=100><col width=200></colgroup><tr><td>1</td></tr></table>");
let FBlock::Table(t4) = &f4.blocks[0] else { panic!() };
assert_eq!(t4.widths, [150.0]);
// Mixed childless colgroup and colgroup with child col elements
let f5 = parse(
"<table><colgroup span=1 width=100></colgroup><colgroup><col style='width: 200pt'><col style='width: 300pt'></colgroup><tr><td>1</td><td>2</td><td>3</td></tr></table>",
);
let FBlock::Table(t5) = &f5.blocks[0] else { panic!() };
assert_eq!(t5.widths, [75.0, 200.0, 300.0]);
// Child col elements inherit parent colgroup width when unset
let f6 = parse("<table><colgroup width=120><col><col></colgroup><tr><td>1</td><td>2</td></tr></table>");
let FBlock::Table(t6) = &f6.blocks[0] else { panic!() };
assert_eq!(t6.widths, [90.0, 90.0]);
// Child col elements without width inherit group width while explicit child width takes precedence
let f7 = parse("<table><colgroup width=120><col width=200><col></colgroup><tr><td>1</td><td>2</td></tr></table>");
let FBlock::Table(t7) = &f7.blocks[0] else { panic!() };
assert_eq!(t7.widths, [150.0, 90.0]);
// Partial explicit col widths fall back to average for unset columns
let f8 = parse("<table><colgroup><col style='width: 100pt'><col></colgroup><tr><td>1</td><td>2</td></tr></table>");
let FBlock::Table(t8) = &f8.blocks[0] else { panic!() };
assert_eq!(t8.widths, [100.0, 100.0]);
// Export includes colgroup
let doc = model::to_doc(&f);
let html = export(&doc);
assert!(html.contains("<colgroup>"), "html export includes colgroup: {html}");
assert!(html.contains("<col style=\"width:75.00pt\">"), "{html}");
assert!(html.contains("<col style=\"width:150.00pt\">"), "{html}");
}
#[test]
fn word_html_vertical_merge_is_preserved() {
use craft_wordmodel::props::VMerge;
let html = "<table>\
<tr><td style='mso-yfti-vmerge:restart'>Top</td><td>B1</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>Cont</td><td>B2</td></tr>\
</table>";
let f = parse(html);
let FBlock::Table(t) = &f.blocks[0] else { panic!() };
assert_eq!(t.rows.len(), 2);
assert_eq!(t.rows[0].len(), 2);
assert_eq!(t.rows[1].len(), 2, "second row must have exactly 2 cells, no duplicate synthetic cell");
assert!(!t.rows[0][0].covered);
assert!(t.rows[1][0].covered);
let doc = model::to_doc(&f);
let craft_wordmodel::Block::Table(tb) = &*doc.body[0] else { panic!() };
assert_eq!(tb.rows[0].cells[0].props.vmerge, VMerge::Restart);
assert_eq!(tb.rows[1].cells[0].props.vmerge, VMerge::Continue);
assert_eq!(tb.rows[1].cells.len(), 2, "table model second row has exactly 2 cells");
assert_eq!(tb.vertical_extent(0, 0), Some((0, 2)));
}
#[test]
fn html_multiple_colgroups_do_not_backfill_earlier_groups() {
// Earlier colgroup with unset column must not be backfilled by later colgroup width.
let html = "<table>\
<colgroup><col></colgroup>\
<colgroup style='width: 200pt'><col style='width: 50pt'></colgroup>\
<tr><td>1</td><td>2</td></tr>\
</table>";
let f = parse(html);
let FBlock::Table(t) = &f.blocks[0] else { panic!() };
assert_eq!(t.widths, [50.0, 50.0], "column 0 was not backfilled by group 2 width of 200pt");
}
#[test]
fn word_html_rowspan_with_explicit_vmerge_continue_no_duplicate_cell() {
use craft_wordmodel::props::VMerge;
let html = "<table>\
<tr><td rowspan=2 style='mso-yfti-vmerge:restart'>A</td><td>B1</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>A_cont</td><td>B2</td></tr>\
</table>";
let f = parse(html);
let FBlock::Table(t) = &f.blocks[0] else { panic!() };
assert_eq!(t.rows.len(), 2);
assert_eq!(t.rows[0].len(), 2);
assert_eq!(t.rows[1].len(), 2, "second row must have exactly 2 cells, not ragged");
assert!(!t.rows[0][0].covered);
assert!(t.rows[1][0].covered);
let doc = model::to_doc(&f);
let craft_wordmodel::Block::Table(tb) = &*doc.body[0] else { panic!() };
assert_eq!(tb.rows[0].cells[0].props.vmerge, VMerge::Restart);
assert_eq!(tb.rows[1].cells[0].props.vmerge, VMerge::Continue);
assert_eq!(tb.rows[1].cells.len(), 2);
assert_eq!(tb.vertical_extent(0, 0), Some((0, 2)));
}
#[test]
fn to_doc_normalises_row_0_continue_cell() {
use craft_wordmodel::props::VMerge;
// Case 1: Row 0 has continue and Row 1 has continue -> Row 0 normalised to Restart.
let html_multi = "<table>\
<tr><td style='mso-yfti-vmerge:continue'>TopCont</td><td>B1</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>BottomCont</td><td>B2</td></tr>\
</table>";
let f_multi = parse(html_multi);
let doc_multi = model::to_doc(&f_multi);
let craft_wordmodel::Block::Table(tb_multi) = &*doc_multi.body[0] else { panic!() };
assert_eq!(tb_multi.rows[0].cells[0].props.vmerge, VMerge::Restart, "row 0 continue normalised to restart");
assert_eq!(tb_multi.rows[1].cells[0].props.vmerge, VMerge::Continue);
// Case 2: Row 0 has continue but table has only 1 row (or no continuation) -> normalised to None.
let html_single = "<table>\
<tr><td style='mso-yfti-vmerge:continue'>SoloCont</td><td>B1</td></tr>\
</table>";
let f_single = parse(html_single);
let doc_single = model::to_doc(&f_single);
let craft_wordmodel::Block::Table(tb_single) = &*doc_single.body[0] else { panic!() };
assert_eq!(tb_single.rows[0].cells[0].props.vmerge, VMerge::None, "orphaned row 0 continue normalised to none");
// Case 3: Row 0 col 1 has continue, Row 1 has a spanning continue starting at col 0 -> col 1 normalised to None.
let html_span = "<table>\
<tr><td>A0</td><td style='mso-yfti-vmerge:continue'>B0</td></tr>\
<tr><td colspan='2' style='mso-yfti-vmerge:continue'>SpanCont</td></tr>\
</table>";
let f_span = parse(html_span);
let doc_span = model::to_doc(&f_span);
let craft_wordmodel::Block::Table(tb_span) = &*doc_span.body[0] else { panic!() };
assert_eq!(tb_span.rows[0].cells[1].props.vmerge, VMerge::None, "unaligned spanning continuation in row 1 must not mark row 0 cell as restart");
}
/// #1785: A covered continuation cell with `rowspan > 1` expands into the following row when
/// no restart cell above spans it.
#[test]
fn covered_continuation_with_rowspan_expands_into_next_row() {
use craft_wordmodel::props::VMerge;
let html = "<table>\
<tr><td style='mso-yfti-vmerge:restart'>Top</td><td>B0</td></tr>\
<tr><td rowspan='2' style='mso-yfti-vmerge:continue'>Mid</td><td>B1</td></tr>\
<tr><td>B2</td></tr>\
</table>";
let f = parse(html);
let doc = model::to_doc(&f);
let craft_wordmodel::Block::Table(tb) = &*doc.body[0] else { panic!() };
assert_eq!(tb.rows.len(), 3);
assert_eq!(tb.rows[2].cells.len(), 2, "row 2 should have placeholder + B2");
assert_eq!(tb.rows[2].cells[0].props.vmerge, VMerge::Continue);
}
/// #1785: A plain `rowspan=2` cell `A` in col 0 followed by `B` (`vmerge:restart`) and `D`
/// must still insert a placeholder for `A` in row 1 even when `B`'s explicit `vmerge:continue`
/// is the first `<td>` in row 1.
#[test]
fn rowspan_before_explicit_vmerge_continue_keeps_grid_columns() {
use craft_wordmodel::props::VMerge;
let html = "<table>\
<tr><td rowspan='2'>A</td><td rowspan='2' style='mso-yfti-vmerge:restart'>B</td><td>D</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>B_cont</td><td>D1</td></tr>\
</table>";
let f = parse(html);
let doc = model::to_doc(&f);
let craft_wordmodel::Block::Table(tb) = &*doc.body[0] else { panic!() };
assert_eq!(tb.rows.len(), 2);
assert_eq!(tb.rows[0].cells.len(), 3);
assert_eq!(tb.rows[1].cells.len(), 3, "row 1 should have placeholder for A, B_cont, and D1");
assert_eq!(tb.rows[1].cells[0].props.vmerge, VMerge::Continue);
assert_eq!(tb.rows[1].cells[1].props.vmerge, VMerge::Continue);
let craft_wordmodel::Block::Para(p1) = &*tb.rows[1].cells[1].blocks[0] else { panic!() };
assert_eq!(p1.text, "B_cont");
assert_eq!(tb.rows[1].cells[2].props.vmerge, VMerge::None);
let craft_wordmodel::Block::Para(p2) = &*tb.rows[1].cells[2].blocks[0] else { panic!() };
assert_eq!(p2.text, "D1");
}
#[test]
fn cells_take_their_css_borders() {
use craft_wordmodel::props::{Border, BorderStyle};
@@ -768,6 +957,240 @@ fn hostile_style_sheets_never_panic() {
}
}
#[test]
fn conflicting_mso_vmerge_declarations_last_wins() {
let html_restart_wins = "<table><tr><td style='mso-yfti-vmerge: continue; mso-yfti-vmerge: restart'>A</td></tr></table>";
let f1 = parse(html_restart_wins);
let FBlock::Table(t1) = &f1.blocks[0] else { panic!() };
assert!(t1.rows[0][0].vmerge_restart);
assert!(!t1.rows[0][0].covered);
let html_continue_wins = "<table><tr><td style='mso-yfti-vmerge: restart; mso-yfti-vmerge: continue'>B</td></tr></table>";
let f2 = parse(html_continue_wins);
let FBlock::Table(t2) = &f2.blocks[0] else { panic!() };
assert!(!t2.rows[0][0].vmerge_restart);
assert!(t2.rows[0][0].covered);
}
#[test]
fn export_flow_derives_rowspan_for_vmerge_continuations() {
let html = "<table>\
<tr><td style='mso-yfti-vmerge:restart'>Top</td><td>B1</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>Cont</td><td>B2</td></tr>\
</table>";
let f = parse(html);
let exported = export_flow(&f, "en");
assert!(exported.contains("<td rowspan=\"2\""), "must derive rowspan=\"2\" for restart cell: {exported}");
assert!(!exported.contains("Cont</td>"), "covered continuation cell should not be emitted: {exported}");
assert!(exported.contains(">B1</td>"), "{exported}");
assert!(exported.contains(">B2</td>"), "{exported}");
}
#[test]
fn export_flow_preserves_orphan_covered_continuation_content() {
let html = "<table>\
<tr><td style='mso-yfti-vmerge:continue'>Orphan0</td><td>B0</td></tr>\
<tr><td>A1</td><td>B1</td></tr>\
</table>";
let f = parse(html);
let exported = export_flow(&f, "en");
assert!(exported.contains("Orphan0</td>"), "orphan continuation content in row 0 must be preserved: {exported}");
}
#[test]
fn html_roundtrip_preserves_colgroups_widths_and_vmerge() {
use craft_wordmodel::props::VMerge;
let html = "<table>\
<colgroup><col style='width: 80pt'></colgroup>\
<colgroup><col style='width: 120pt'></colgroup>\
<tr><td style='mso-yfti-vmerge:restart'>MergeA</td><td>B1</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>MergeA_cont</td><td>B2</td></tr>\
</table>";
let f1 = parse(html);
let FBlock::Table(t1) = &f1.blocks[0] else { panic!() };
assert_eq!(t1.widths, [80.0, 120.0]);
assert_eq!(t1.rows.len(), 2);
assert_eq!(t1.rows[0].len(), 2);
assert_eq!(t1.rows[1].len(), 2);
assert!(!t1.rows[0][0].covered);
assert!(t1.rows[0][0].vmerge_restart);
assert!(t1.rows[1][0].covered);
let doc1 = model::to_doc(&f1);
let craft_wordmodel::Block::Table(tb1) = &*doc1.body[0] else { panic!() };
assert_eq!(tb1.rows[0].cells[0].props.vmerge, VMerge::Restart);
assert_eq!(tb1.rows[1].cells[0].props.vmerge, VMerge::Continue);
assert_eq!(tb1.vertical_extent(0, 0), Some((0, 2)));
// Export to HTML via export()
let exported = export(&doc1);
assert!(exported.contains("<colgroup>"), "exported HTML must contain colgroup: {exported}");
assert!(exported.contains("width:80.00pt"), "{exported}");
assert!(exported.contains("width:120.00pt"), "{exported}");
assert!(exported.contains("rowspan=\"2\""), "exported HTML must emit rowspan=\"2\": {exported}");
// Parse the exported HTML again
let f2 = parse(&exported);
let FBlock::Table(t2) = &f2.blocks[0] else { panic!() };
assert_eq!(t2.widths, t1.widths, "column widths must match");
assert_eq!(t2.rows.len(), t1.rows.len(), "row counts must match");
assert_eq!(t2.rows[0].len(), t1.rows[0].len(), "row 0 cell count must match");
assert_eq!(t2.rows[1].len(), t1.rows[1].len(), "row 1 cell count must match");
assert_eq!(t2.rows[0][0].covered, t1.rows[0][0].covered, "row 0 cell 0 covered flag must match");
assert_eq!(t2.rows[1][0].covered, t1.rows[1][0].covered, "row 1 cell 0 covered flag must match");
let doc2 = model::to_doc(&f2);
let craft_wordmodel::Block::Table(tb2) = &*doc2.body[0] else { panic!() };
assert_eq!(tb2.rows[0].cells[0].props.vmerge, tb1.rows[0].cells[0].props.vmerge, "vmerge restart matches");
assert_eq!(tb2.rows[1].cells[0].props.vmerge, tb1.rows[1].cells[0].props.vmerge, "vmerge continue matches");
assert_eq!(tb2.vertical_extent(0, 0), tb1.vertical_extent(0, 0), "vertical merge extent matches");
}
fn assert_single_col_vmerge_table(tb: &craft_wordmodel::Table) {
use craft_wordmodel::props::VMerge;
assert_eq!(tb.rows.len(), 3, "table must have 3 rows");
assert_eq!(tb.grid.len(), 1, "table must have 1 column");
assert_eq!(tb.rows[0].cells.len(), 1);
assert_eq!(tb.rows[1].cells.len(), 1);
assert_eq!(tb.rows[2].cells.len(), 1);
assert_eq!(tb.rows[0].cells[0].props.vmerge, VMerge::Restart);
assert_eq!(tb.rows[1].cells[0].props.vmerge, VMerge::Continue);
assert_eq!(tb.rows[2].cells[0].props.vmerge, VMerge::None);
assert_eq!(tb.vertical_extent(0, 0), Some((0, 2)));
assert_eq!(tb.grid_col(2, 0), 0, "Bottom cell must be at grid column 0");
let bottom_text = match &*tb.rows[2].cells[0].blocks[0] {
craft_wordmodel::Block::Para(p) => &p.text,
_ => panic!("expected paragraph in Bottom cell"),
};
assert_eq!(bottom_text, "Bottom", "Bottom must be at row 2, cell 0");
}
#[test]
fn html_roundtrip_preserves_fully_covered_row_and_single_column_table() {
// A one-column table with a Word vertical merge across the first two rows,
// followed by an ordinary "Bottom" cell in row three.
let html = "<table>\
<tr><td style='mso-yfti-vmerge:restart'>Top</td></tr>\
<tr><td style='mso-yfti-vmerge:continue'>Cont</td></tr>\
<tr><td>Bottom</td></tr>\
</table>";
let f1 = parse(html);
let FBlock::Table(t1) = &f1.blocks[0] else { panic!() };
assert_eq!(t1.rows.len(), 3, "initial import must have 3 rows");
assert_eq!(t1.cols(), 1, "initial import must have 1 column");
assert_eq!(t1.rows[0].len(), 1);
assert_eq!(t1.rows[1].len(), 1);
assert_eq!(t1.rows[2].len(), 1);
assert!(!t1.rows[0][0].covered);
assert!(t1.rows[0][0].vmerge_restart);
assert!(t1.rows[1][0].covered);
assert!(!t1.rows[2][0].covered);
let doc1 = model::to_doc(&f1);
let craft_wordmodel::Block::Table(tb1) = &*doc1.body[0] else { panic!() };
assert_single_col_vmerge_table(tb1);
// Export to HTML via export()
let exported = export(&doc1);
assert!(exported.contains("rowspan=\"2\""), "exported HTML must emit rowspan=\"2\": {exported}");
assert!(exported.contains("<tr></tr>"), "covered row with no visible cells must emit empty tr: {exported}");
assert!(exported.contains("Bottom"), "exported HTML must contain Bottom: {exported}");
// Parse the exported HTML again
let f2 = parse(&exported);
let FBlock::Table(t2) = &f2.blocks[0] else { panic!() };
assert_eq!(t2.rows.len(), 3, "round-trip Flow must keep 3 rows");
assert_eq!(t2.cols(), 1, "round-trip Flow must keep 1 column");
assert_eq!(t2.rows[0].len(), 1, "row 0 has 1 cell");
assert_eq!(t2.rows[1].len(), 1, "row 1 (fully covered row) has 1 cell");
assert_eq!(t2.rows[2].len(), 1, "row 2 has 1 cell");
assert!(!t2.rows[0][0].covered);
assert!(t2.rows[1][0].covered, "row 1 cell must be covered placeholder");
assert!(!t2.rows[2][0].covered, "row 2 cell (Bottom) must not be covered");
// Convert round-tripped flow to document model
let doc2 = model::to_doc(&f2);
let craft_wordmodel::Block::Table(tb2) = &*doc2.body[0] else { panic!() };
assert_single_col_vmerge_table(tb2);
}
#[test]
fn vmerge_validation_requires_matching_spans() {
use craft_wordmodel::props::VMerge;
// 1. Later-row check: row 0 has colspan=2, row 1 has continuation with colspan=1.
// Mismatched spans must clear continuation to None and NOT promote row 0 cell to Restart.
let ft_mismatched = FTable {
rows: vec![
vec![Cell { colspan: 2, ..Cell::default() }],
vec![Cell { colspan: 1, covered: true, ..Cell::default() }, Cell { colspan: 1, ..Cell::default() }],
],
widths: vec![50.0, 50.0],
..Default::default()
};
let doc = model::to_doc(&Flow { blocks: vec![FBlock::Table(ft_mismatched)], ..Default::default() });
let craft_wordmodel::Block::Table(tb) = &*doc.body[0] else { panic!() };
assert_eq!(tb.rows[0].cells[0].props.vmerge, VMerge::None, "mismatched span must not promote to Restart");
assert_eq!(tb.rows[1].cells[0].props.vmerge, VMerge::None, "mismatched span must clear Continue to None");
// 2. First-row check: row 0 has continuation with colspan=2, row 1 has continuation with colspan=1.
// Mismatched spans must clear row 0 continuation to None, not promote to Restart.
let ft_row0_mismatched = FTable {
rows: vec![
vec![Cell { colspan: 2, covered: true, ..Cell::default() }],
vec![Cell { colspan: 1, covered: true, ..Cell::default() }, Cell { colspan: 1, ..Cell::default() }],
],
widths: vec![50.0, 50.0],
..Default::default()
};
let doc0 = model::to_doc(&Flow { blocks: vec![FBlock::Table(ft_row0_mismatched)], ..Default::default() });
let craft_wordmodel::Block::Table(tb0) = &*doc0.body[0] else { panic!() };
assert_eq!(tb0.rows[0].cells[0].props.vmerge, VMerge::None, "mismatched span in row 0 must clear to None");
assert_eq!(tb0.rows[1].cells[0].props.vmerge, VMerge::None, "mismatched span in row 1 must clear to None");
// 3. Matching spans: row 0 has colspan=2, row 1 has continuation with colspan=2.
// Matching spans must promote row 0 to Restart and keep row 1 as Continue.
let ft_matching = FTable {
rows: vec![vec![Cell { colspan: 2, ..Cell::default() }], vec![Cell { colspan: 2, covered: true, ..Cell::default() }]],
widths: vec![50.0, 50.0],
..Default::default()
};
let doc_m = model::to_doc(&Flow { blocks: vec![FBlock::Table(ft_matching)], ..Default::default() });
let craft_wordmodel::Block::Table(tb_m) = &*doc_m.body[0] else { panic!() };
assert_eq!(tb_m.rows[0].cells[0].props.vmerge, VMerge::Restart);
assert_eq!(tb_m.rows[1].cells[0].props.vmerge, VMerge::Continue);
}
#[test]
fn export_table_preserves_first_grid_column_alignment() {
let mut doc = craft_wordmodel::Document::default();
let mut table = craft_wordmodel::Table::new(2, 3, 240.0);
table.grid = vec![40.0, 80.0, 120.0];
table.rows[0].cells = vec![craft_wordmodel::Cell::with_text("A"), craft_wordmodel::Cell::with_text("B"), craft_wordmodel::Cell::with_text("C")];
table.rows[1].props.grid_before = 1;
table.rows[1].cells = vec![craft_wordmodel::Cell::with_text("D"), craft_wordmodel::Cell::with_text("E")];
doc.body = vec![std::sync::Arc::new(craft_wordmodel::Block::Table(table))];
// Flow representation should preserve the leading grid position
let flow = model::from_doc(&doc);
let FBlock::Table(ft) = &flow.blocks[0] else { panic!() };
assert_eq!(ft.rows.len(), 2);
assert_eq!(ft.rows[0].len(), 3);
assert_eq!(ft.rows[1].len(), 3, "row 1 must have 3 cells (1 leading placeholder + 2 data cells)");
assert_eq!(ft.widths, vec![40.0, 80.0, 120.0]);
// HTML export should emit 3 colgroup cols and preserve cell alignment
let html = export(&doc);
assert!(html.contains("<col style=\"width:40.00pt\">"), "must contain col 0 width: {html}");
assert!(html.contains("<col style=\"width:80.00pt\">"), "must contain col 1 width: {html}");
assert!(html.contains("<col style=\"width:120.00pt\">"), "must contain col 2 width: {html}");
assert!(html.contains(">D</td>"), "must contain cell D: {html}");
assert!(html.contains(">E</td>"), "must contain cell E: {html}");
}
/// Ensure container elements (such as `div` and `p`) with background colors do not leak
/// character shading onto their child text runs (#1786).
#[test]