2032 lines
94 KiB
Rust
2032 lines
94 KiB
Rust
//! Round-trip tests: build documents programmatically → write → read → compare.
|
||
|
||
use std::sync::Arc;
|
||
|
||
use wordcraft_doc::numbering::ListKind;
|
||
use wordcraft_doc::para::{Anchor, Float, FloatAlign, NoteKind, ShapeKind, Wrap};
|
||
use wordcraft_doc::props::{
|
||
Align, Border, BorderStyle, Borders, CharProps, HeightRule, Highlight, LineSpacing, NumRef, ParaProps, Rgb, RowProps, TabAlign, TabLeader,
|
||
TabStop, TableLook, TextColor, TextDirection, Underline, VAlign, VMerge, VertAlign,
|
||
};
|
||
use wordcraft_doc::section::{Columns, DocGrid, DocGridType, LineNumberRestart, LineNumbering, NumFormat, SectionProps, SectionStart};
|
||
use wordcraft_doc::styles::{Style, StyleKind};
|
||
use wordcraft_doc::table::{Cell, Table};
|
||
use wordcraft_doc::{Block, Blocks, Comment, Document, InlineObject, Paragraph, PartKind, Revision, RevisionKind, Watermark, para_block};
|
||
|
||
fn rt(doc: &Document) -> Document {
|
||
let bytes = wordcraft_docx::write(doc).expect("write");
|
||
wordcraft_docx::read(&bytes).expect("read")
|
||
}
|
||
|
||
fn paras(doc: &Document) -> Vec<&Paragraph> {
|
||
doc.body.iter().filter_map(|b| b.as_para()).collect()
|
||
}
|
||
|
||
fn part_text(doc: &Document, id: Option<u32>) -> String {
|
||
id.and_then(|i| doc.parts.get(&i))
|
||
.map(|p| p.blocks.iter().filter_map(|b| b.as_para()).map(|p| p.plain_text()).collect::<Vec<_>>().join("\n"))
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn doc_with(blocks: Vec<Paragraph>) -> Document {
|
||
let mut d = Document::new();
|
||
d.body = blocks.into_iter().map(para_block).collect();
|
||
d
|
||
}
|
||
|
||
/// A paragraph built from (text, props) runs.
|
||
fn para_runs(runs: &[(&str, CharProps)]) -> Paragraph {
|
||
let mut p = Paragraph::new();
|
||
for (t, c) in runs {
|
||
let off = p.len();
|
||
p.insert_text(off, t, c).unwrap();
|
||
}
|
||
p
|
||
}
|
||
|
||
fn tiny_png() -> Vec<u8> {
|
||
let img = image::RgbaImage::from_fn(3, 2, |x, y| image::Rgba([x as u8 * 80, y as u8 * 120, 200, 255]));
|
||
let mut out = std::io::Cursor::new(Vec::new());
|
||
img.write_to(&mut out, image::ImageFormat::Png).unwrap();
|
||
out.into_inner()
|
||
}
|
||
|
||
#[test]
|
||
fn every_char_prop_round_trips() {
|
||
let all = CharProps {
|
||
style: Some("Strong".into()),
|
||
font: Some("Georgia".into()),
|
||
size: Some(10.5),
|
||
bold: Some(true),
|
||
italic: Some(false),
|
||
underline: Some(Underline::DotDash),
|
||
underline_color: Some(Rgb(1, 2, 3)),
|
||
strike: Some(true),
|
||
double_strike: Some(false),
|
||
color: Some(TextColor::Rgb(Rgb(0xAA, 0x10, 0x20))),
|
||
highlight: Some(Highlight::Turquoise),
|
||
shading: Some(Rgb(0xEE, 0xEE, 0x00)),
|
||
border: Some(Border { style: BorderStyle::Double, width: 1.5, color: Some(Rgb(0xC0, 0, 0)), space: 2.0 }),
|
||
vert_align: Some(VertAlign::Superscript),
|
||
caps: Some(true),
|
||
small_caps: Some(false),
|
||
hidden: Some(true),
|
||
spacing: Some(1.5),
|
||
scale: Some(150.0),
|
||
position: Some(3.0),
|
||
kern: Some(8.0),
|
||
outline: Some(true),
|
||
shadow: Some(true),
|
||
emboss: Some(false),
|
||
engrave: Some(true),
|
||
// WordArt effects ([MS-DOCX] w14 run properties).
|
||
text_effects: Some(Box::new(wordcraft_doc::wordart::TextEffects {
|
||
fill: Some(wordcraft_doc::wordart::TextFill::Gradient {
|
||
stops: vec![
|
||
wordcraft_doc::wordart::GradStop { pos: 0.0, color: Rgb(0x15, 0x60, 0x82), transparency: 0.0 },
|
||
wordcraft_doc::wordart::GradStop { pos: 100.0, color: Rgb(0xE9, 0x71, 0x32), transparency: 25.0 },
|
||
],
|
||
angle: 90.0,
|
||
}),
|
||
outline: Some(wordcraft_doc::wordart::TextOutline { color: Some(Rgb(0x0E, 0x28, 0x41)), width: 1.5, transparency: 0.0 }),
|
||
shadow: Some(wordcraft_doc::effects::Shadow {
|
||
color: Rgb::BLACK,
|
||
transparency: 60.0,
|
||
blur: 4.0,
|
||
distance: 3.0,
|
||
angle: 45.0,
|
||
rot_with_shape: false,
|
||
}),
|
||
glow: Some(wordcraft_doc::effects::Glow { color: Rgb(0x0F, 0x9E, 0xD5), size: 5.0, transparency: 40.0 }),
|
||
reflection: Some(wordcraft_doc::wordart::Reflection::default()),
|
||
})),
|
||
lang: Some("fr-FR".into()),
|
||
no_proof: Some(true),
|
||
rtl: Some(false),
|
||
cs: Some(true),
|
||
font_cs: Some("B Nazanin".into()),
|
||
font_ea: Some("宋体".into()),
|
||
size_cs: Some(13.0),
|
||
bold_cs: Some(false),
|
||
italic_cs: Some(true),
|
||
lang_bidi: Some("fa-IR".into()),
|
||
link: None,
|
||
ins: None,
|
||
del: None,
|
||
fmt_change: None,
|
||
};
|
||
let auto =
|
||
CharProps { color: Some(TextColor::Auto), highlight: Some(Highlight::None), vert_align: Some(VertAlign::Subscript), ..Default::default() };
|
||
let d = doc_with(vec![para_runs(&[("plain ", CharProps::default()), ("everything", all.clone()), (" auto", auto.clone())])]);
|
||
let r = rt(&d);
|
||
let p = paras(&r)[0];
|
||
assert_eq!(p.text, "plain everything auto");
|
||
assert_eq!(p.runs.len(), 3);
|
||
assert_eq!(p.runs[1].props, all);
|
||
assert_eq!(p.runs[2].props, auto);
|
||
assert_eq!(p.runs[0].props, CharProps::default());
|
||
}
|
||
|
||
#[test]
|
||
fn every_para_prop_round_trips() {
|
||
let b = Border { style: BorderStyle::Double, width: 0.75, color: Some(Rgb(9, 8, 7)), space: 4.0 };
|
||
let pp = ParaProps {
|
||
style: Some("Heading1".into()),
|
||
align: Some(Align::Justify),
|
||
indent_left: Some(36.0),
|
||
indent_right: Some(18.0),
|
||
indent_first: Some(-18.0),
|
||
indent_left_chars: Some(1.5),
|
||
indent_right_chars: Some(0.0),
|
||
indent_first_chars: Some(-1.0),
|
||
space_before: Some(6.0),
|
||
space_after: Some(12.0),
|
||
line_spacing: Some(LineSpacing::Multiple(1.5)),
|
||
contextual_spacing: Some(true),
|
||
mirror_indents: Some(true),
|
||
keep_next: Some(true),
|
||
keep_lines: Some(false),
|
||
page_break_before: Some(true),
|
||
widow_control: Some(false),
|
||
outline_level: Some(2),
|
||
numbering: Some(NumRef { num: 0, level: 0 }),
|
||
tabs: Some(vec![
|
||
TabStop { pos: 72.0, align: TabAlign::Center, leader: TabLeader::Dot },
|
||
TabStop { pos: 144.0, align: TabAlign::Right, leader: TabLeader::None },
|
||
TabStop { pos: 200.0, align: TabAlign::Decimal, leader: TabLeader::Underscore },
|
||
TabStop { pos: 216.0, align: TabAlign::Clear, leader: TabLeader::None },
|
||
TabStop { pos: 250.0, align: TabAlign::Bar, leader: TabLeader::MiddleDot },
|
||
]),
|
||
shading: Some(Rgb(0xDD, 0xEE, 0xFF)),
|
||
borders: Some(Borders { top: Some(b), left: Some(Border::single(0.5)), bottom: Some(b), right: None, between: Some(b), inside_v: None }),
|
||
suppress_hyphens: Some(true),
|
||
suppress_line_numbers: Some(true),
|
||
bidi: Some(false),
|
||
drop_cap: None,
|
||
kinsoku: Some(false),
|
||
word_wrap: Some(false),
|
||
overflow_punct: Some(false),
|
||
top_line_punct: Some(true),
|
||
auto_space_de: Some(false),
|
||
auto_space_dn: Some(true),
|
||
num_change: None,
|
||
fmt_change: None,
|
||
snap_to_grid: Some(false),
|
||
};
|
||
let variants = [
|
||
ParaProps { line_spacing: Some(LineSpacing::AtLeast(14.0)), indent_first: Some(24.0), align: Some(Align::Center), ..Default::default() },
|
||
ParaProps { line_spacing: Some(LineSpacing::Exactly(20.0)), align: Some(Align::Right), ..Default::default() },
|
||
ParaProps { align: Some(Align::Distribute), ..Default::default() },
|
||
ParaProps { kinsoku: Some(true), word_wrap: Some(true), auto_space_dn: Some(false), ..Default::default() },
|
||
ParaProps::default(),
|
||
];
|
||
let mut ps = vec![Paragraph::with_text("main", CharProps::default())];
|
||
ps[0].props = pp.clone();
|
||
ps[0].mark = CharProps { bold: Some(true), size: Some(14.0), ..Default::default() };
|
||
for v in &variants {
|
||
let mut p = Paragraph::with_text("v", CharProps::default());
|
||
p.props = v.clone();
|
||
ps.push(p);
|
||
}
|
||
let r = rt(&doc_with(ps));
|
||
let got = paras(&r);
|
||
assert_eq!(got[0].props, pp);
|
||
assert_eq!(got[0].mark, CharProps { bold: Some(true), size: Some(14.0), ..Default::default() });
|
||
for (i, v) in variants.iter().enumerate() {
|
||
assert_eq!(&got[i + 1].props, v, "variant {i}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn styles_and_lists_round_trip() {
|
||
let mut d = Document::new();
|
||
d.styles.upsert(Style {
|
||
id: "MyStyle".into(),
|
||
name: "My Style".into(),
|
||
kind: StyleKind::Paragraph,
|
||
based_on: Some("Normal".into()),
|
||
next: Some("Normal".into()),
|
||
linked: Some("MyStyleChar".into()),
|
||
para: ParaProps { space_after: Some(3.0), align: Some(Align::Center), ..Default::default() },
|
||
chr: CharProps { italic: Some(true), color: Some(TextColor::Rgb(Rgb(1, 2, 3))), ..Default::default() },
|
||
priority: Some(5),
|
||
quick: true,
|
||
hidden: false,
|
||
builtin: false,
|
||
locked: true,
|
||
table: None,
|
||
});
|
||
d.styles.upsert(Style {
|
||
id: "MyStyleChar".into(),
|
||
name: "My Style Char".into(),
|
||
kind: StyleKind::Character,
|
||
linked: Some("MyStyle".into()),
|
||
chr: CharProps { italic: Some(true), ..Default::default() },
|
||
hidden: true,
|
||
..Default::default()
|
||
});
|
||
let bullets = d.numbering.add_list(ListKind::Bullet);
|
||
let nums = d.numbering.add_list(ListKind::Legal);
|
||
let outline = d.numbering.add_list(ListKind::Outline);
|
||
if let Some(n) = d.numbering.nums.iter_mut().find(|n| n.id == outline) {
|
||
n.start_overrides.push((0, 4));
|
||
}
|
||
let mut ps = Vec::new();
|
||
for (i, num) in [bullets, nums, nums, outline].iter().enumerate() {
|
||
let mut p = Paragraph::with_text(&format!("item {i}"), CharProps::default());
|
||
p.props.numbering = Some(NumRef { num: *num, level: (i % 2) as u8 });
|
||
p.props.style = Some("MyStyle".into());
|
||
ps.push(p);
|
||
}
|
||
d.body = ps.into_iter().map(para_block).collect();
|
||
let r = rt(&d);
|
||
assert_eq!(r.numbering, d.numbering);
|
||
assert_eq!(r.styles.default_chr, d.styles.default_chr);
|
||
assert_eq!(r.styles.default_para, d.styles.default_para);
|
||
for s in &d.styles.styles {
|
||
assert_eq!(r.styles.get(&s.id), Some(s), "style {}", s.id);
|
||
}
|
||
assert_eq!(r.styles.styles.len(), d.styles.styles.len());
|
||
assert_eq!(paras(&r)[1].props.numbering, Some(NumRef { num: nums, level: 1 }));
|
||
}
|
||
|
||
#[test]
|
||
fn tables_with_merges_round_trip() {
|
||
let mut t = Table::new(3, 3, 468.0);
|
||
t.props.width = Some(468.0);
|
||
t.props.align = Some(Align::Center);
|
||
t.props.indent = Some(5.0);
|
||
t.props.borders = Some(Borders::all(Border::single(0.5)));
|
||
t.props.cell_margins = Some([1.0, 5.4, 1.0, 5.4]);
|
||
t.props.fixed = true;
|
||
t.props.look = TableLook { header_row: true, total_row: true, banded_rows: false, first_column: false, last_column: true, banded_columns: true };
|
||
t.props.shading = Some(Rgb(1, 1, 1));
|
||
t.props.caption = Some("Sales".into());
|
||
t.rows[0].props = RowProps { height: Some(20.0), height_rule: HeightRule::Exact, header: true, cant_split: true, fmt_change: None };
|
||
t.rows[1].props = RowProps { height: Some(15.0), height_rule: HeightRule::AtLeast, ..Default::default() };
|
||
t.merge(0, 0, 0, 1); // horizontal
|
||
t.merge(1, 2, 2, 2); // vertical
|
||
{
|
||
let c = &mut t.rows[1].cells[0];
|
||
c.props.shading = Some(Rgb(0xFF, 0, 0));
|
||
c.props.valign = VAlign::Bottom;
|
||
c.props.text_direction = TextDirection::Up;
|
||
c.props.no_wrap = true;
|
||
c.props.margins = Some([2.0, 3.0, 4.0, 5.0]);
|
||
c.props.width = None;
|
||
c.props.width_pct = Some(40.0);
|
||
c.props.borders = Some(Borders::box_(Border { style: BorderStyle::Dashed, width: 1.0, color: Some(Rgb(0, 0, 255)), space: 0.0 }));
|
||
c.blocks = vec![para_block(Paragraph::with_text("red", CharProps::default()))];
|
||
}
|
||
// Nested table in a cell (followed by the required paragraph).
|
||
let inner = Table::new(1, 2, 100.0);
|
||
t.rows[2].cells[0].blocks = vec![Arc::new(Block::Table(inner)), para_block(Paragraph::new())];
|
||
let mut d = Document::new();
|
||
d.body = vec![para_block(Paragraph::with_text("before", CharProps::default())), Arc::new(Block::Table(t.clone())), para_block(Paragraph::new())];
|
||
let r = rt(&d);
|
||
let got = r.body[1].as_table().expect("table");
|
||
assert_eq!(got.props, t.props);
|
||
assert_eq!(got.grid, t.grid);
|
||
assert_eq!(got.rows.len(), 3);
|
||
for (gr, er) in got.rows.iter().zip(&t.rows) {
|
||
assert_eq!(gr.props, er.props);
|
||
assert_eq!(gr.cells.len(), er.cells.len());
|
||
for (gc, ec) in gr.cells.iter().zip(&er.cells) {
|
||
assert_eq!(gc.props, ec.props);
|
||
assert_eq!(gc.blocks, ec.blocks);
|
||
}
|
||
}
|
||
assert_eq!(got.rows[0].cells[0].span(), 2);
|
||
assert_eq!(got.rows[2].cells[2].props.vmerge, VMerge::Continue);
|
||
}
|
||
|
||
#[test]
|
||
fn sections_headers_footers_round_trip() {
|
||
let mut d = Document::new();
|
||
let page = |instr: &str| {
|
||
let mut p = Paragraph::with_text("Page ", CharProps::default());
|
||
p.insert_object(5, InlineObject::Field { instr: instr.into(), result: "1".into(), locked: false, code: false }, &CharProps::default())
|
||
.unwrap();
|
||
p
|
||
};
|
||
let h1 = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Header one", CharProps::default()))]);
|
||
let hf = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("First page header", CharProps::default()))]);
|
||
let f1 = d.add_part(PartKind::Footer, vec![para_block(page("PAGE"))]);
|
||
let f2 = d.add_part(PartKind::Footer, vec![para_block(page("NUMPAGES"))]);
|
||
let mut s1 = SectionProps {
|
||
title_page: true,
|
||
page_num_start: Some(3),
|
||
page_num_format: NumFormat::UpperRoman,
|
||
valign: VAlign::Center,
|
||
page_borders: Some(Borders::box_(Border::single(1.0))),
|
||
line_numbers: Some(LineNumbering { count_by: 5, start: 1, distance: 18.0, restart: LineNumberRestart::Section }),
|
||
gutter: 18.0,
|
||
// #391: a line and character grid (Word writes `w:docGrid` even without a grid).
|
||
doc_grid: Some(DocGrid { kind: DocGridType::LinesAndChars, line_pitch: 17.5, char_space: -1843 }),
|
||
..Default::default()
|
||
};
|
||
s1.headers.default = Some(h1);
|
||
s1.headers.first = Some(hf);
|
||
s1.footers.default = Some(f1);
|
||
let mut s2 = SectionProps { start: SectionStart::OddPage, rtl: true, doc_grid: Some(DocGrid::default()), ..Default::default() };
|
||
s2.set_landscape(true);
|
||
s2.columns = Columns { count: 2, space: 24.0, separator: true, widths: Vec::new() };
|
||
s2.footers.default = Some(f2);
|
||
s2.headers.default = Some(h1);
|
||
let mut p1 = Paragraph::with_text("Section one", CharProps::default());
|
||
p1.section = Some(Box::new(s1.clone()));
|
||
let mut s3 = SectionProps { start: SectionStart::Continuous, ..Default::default() };
|
||
s3.columns = Columns { count: 2, space: 10.0, separator: false, widths: vec![(200.0, 20.0), (248.0, 0.0)] };
|
||
let mut p2 = Paragraph::with_text("Section two", CharProps::default());
|
||
p2.section = Some(Box::new(s2.clone()));
|
||
d.body = vec![para_block(p1), para_block(p2), para_block(Paragraph::with_text("Last", CharProps::default()))];
|
||
d.last_section = s3.clone();
|
||
let r = rt(&d);
|
||
let secs = r.sections();
|
||
assert_eq!(secs.len(), 3);
|
||
let strip = |s: &SectionProps| SectionProps { headers: Default::default(), footers: Default::default(), ..s.clone() };
|
||
assert_eq!(strip(secs[0].1), strip(&s1));
|
||
assert_eq!(strip(secs[1].1), strip(&s2));
|
||
assert_eq!(strip(secs[2].1), strip(&s3));
|
||
assert!(secs[1].1.landscape);
|
||
assert_eq!(part_text(&r, secs[0].1.headers.default), "Header one");
|
||
assert_eq!(part_text(&r, secs[0].1.headers.first), "First page header");
|
||
assert_eq!(secs[0].1.headers.default, secs[1].1.headers.default, "shared header part stays shared");
|
||
let fp = r.parts.get(&secs[0].1.footers.default.unwrap()).unwrap().blocks[0].as_para().unwrap();
|
||
assert_eq!(fp.objects, vec![InlineObject::Field { instr: "PAGE".into(), result: "1".into(), locked: false, code: false }]);
|
||
assert_eq!(part_text(&r, secs[1].1.footers.default), "Page 1");
|
||
assert_eq!(r.parts.get(&secs[0].1.headers.default.unwrap()).unwrap().kind, PartKind::Header);
|
||
}
|
||
|
||
#[test]
|
||
fn images_round_trip() {
|
||
let mut d = Document::new();
|
||
let png = tiny_png();
|
||
let key = d.add_media(png.clone(), "png");
|
||
let inline = InlineObject::Image {
|
||
media: key.clone(),
|
||
w: 72.0,
|
||
h: 48.0,
|
||
alt: "A tiny picture".into(),
|
||
// Room for a shadow: kept through save and load.
|
||
float: Float { effect: [12.0, 12.0, 27.0, 27.0], ..Default::default() },
|
||
crop: [0.1, 0.0, 0.25, 0.05],
|
||
ole: None,
|
||
};
|
||
let floating = InlineObject::Image {
|
||
media: key.clone(),
|
||
w: 100.0,
|
||
h: 50.0,
|
||
alt: String::new(),
|
||
float: Float { wrap: Wrap::Square, h_rel: Anchor::Page, v_rel: Anchor::Margin, x: 36.0, y: 12.5, dist: 9.0, ..Default::default() },
|
||
crop: [0.0; 4],
|
||
ole: None,
|
||
};
|
||
let aligned = InlineObject::Image {
|
||
media: key.clone(),
|
||
w: 20.0,
|
||
h: 20.0,
|
||
alt: String::new(),
|
||
float: Float {
|
||
wrap: Wrap::Square,
|
||
h_rel: Anchor::RightMargin,
|
||
h_align: Some(FloatAlign::Center),
|
||
v_rel: Anchor::TopMargin,
|
||
v_align: Some(FloatAlign::End),
|
||
dist: 9.0,
|
||
dist_top: 2.5,
|
||
dist_bottom: 4.0,
|
||
..Default::default()
|
||
},
|
||
crop: [0.0; 4],
|
||
ole: None,
|
||
};
|
||
let mut floats = vec![floating.clone(), aligned];
|
||
for wrap in [Wrap::Tight, Wrap::Through, Wrap::TopAndBottom, Wrap::BehindText, Wrap::InFrontOfText] {
|
||
floats.push(InlineObject::Image {
|
||
media: key.clone(),
|
||
w: 10.0,
|
||
h: 10.0,
|
||
alt: String::new(),
|
||
float: Float { wrap, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 0.0, y: 0.0, dist: 0.0, ..Default::default() },
|
||
crop: [0.0; 4],
|
||
ole: None,
|
||
});
|
||
}
|
||
let mut p = Paragraph::with_text("pic: ", CharProps::default());
|
||
p.insert_object(5, inline.clone(), &CharProps::default()).unwrap();
|
||
for f in &floats {
|
||
let end = p.len();
|
||
p.insert_object(end, f.clone(), &CharProps::default()).unwrap();
|
||
}
|
||
d.body = vec![para_block(p)];
|
||
let r = rt(&d);
|
||
let got = paras(&r)[0];
|
||
let mut expect = vec![inline];
|
||
expect.extend(floats);
|
||
assert_eq!(got.objects, expect);
|
||
assert_eq!(r.media.get(&key).map(|b| b.as_slice()), Some(png.as_slice()));
|
||
assert_eq!(r.media.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn hyperlinks_and_bookmarks_round_trip() {
|
||
let ext = CharProps { link: Some("https://example.com/a?b=1&c=2".into()), underline: Some(Underline::Single), ..Default::default() };
|
||
let int = CharProps { link: Some("#target".into()), ..Default::default() };
|
||
let mut p = para_runs(&[("see ", CharProps::default()), ("example", ext.clone()), (" and ", CharProps::default()), ("here", int.clone())]);
|
||
p.insert_object(0, InlineObject::BookmarkStart { name: "target".into() }, &CharProps::default()).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::BookmarkEnd { name: "target".into() }, &CharProps::default()).unwrap();
|
||
let d = doc_with(vec![p.clone()]);
|
||
let r = rt(&d);
|
||
let got = paras(&r)[0];
|
||
assert_eq!(got.text, p.text);
|
||
assert_eq!(got.objects, p.objects);
|
||
assert_eq!(got.props_of_char(got.text.find("example").unwrap()), &ext);
|
||
assert_eq!(got.props_of_char(got.text.find("here").unwrap()), &int);
|
||
assert_eq!(r.bookmarks().len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn comments_round_trip() {
|
||
let mut d = Document::new();
|
||
let c0 = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Please check this.", CharProps::default()))]);
|
||
let c1 = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Done.", CharProps::default()))]);
|
||
d.comments.insert(
|
||
0,
|
||
Comment { author: "Ann".into(), initials: "A".into(), date: "2026-01-02T03:04:05Z".into(), parent: None, resolved: true, part: c0 },
|
||
);
|
||
d.comments.insert(
|
||
1,
|
||
Comment { author: "Ben".into(), initials: "B".into(), date: "2026-01-03T00:00:00Z".into(), parent: Some(0), resolved: false, part: c1 },
|
||
);
|
||
let mut p = Paragraph::with_text("commented text", CharProps::default());
|
||
p.insert_object(0, InlineObject::CommentStart { id: 0 }, &CharProps::default()).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::CommentEnd { id: 0 }, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p.clone())];
|
||
let r = rt(&d);
|
||
assert_eq!(paras(&r)[0].objects, p.objects);
|
||
assert_eq!(r.comments.len(), 2);
|
||
for (id, c) in &d.comments {
|
||
let g = r.comments.get(id).expect("comment");
|
||
assert_eq!((&g.author, &g.initials, &g.date, g.parent, g.resolved), (&c.author, &c.initials, &c.date, c.parent, c.resolved));
|
||
assert_eq!(part_text(&r, Some(g.part)), part_text(&d, Some(c.part)));
|
||
assert_eq!(r.parts.get(&g.part).unwrap().kind, PartKind::Comment);
|
||
}
|
||
}
|
||
|
||
/// A table style's cell text formatting, whole-table shading, cell margins and its header row and
|
||
/// row band conditional formats (#146) survive a save.
|
||
#[test]
|
||
fn table_style_formatting_round_trips() {
|
||
use wordcraft_doc::styles::TableStyleParts;
|
||
let mut d = doc_with(vec![Paragraph::with_text("x", CharProps::default())]);
|
||
let parts = TableStyleParts {
|
||
borders: Some(Borders { top: Some(Border::single(1.0)), ..Default::default() }),
|
||
fill: Some(Rgb(0xDD, 0xEB, 0xF7)),
|
||
cell_margins: Some([1.0, 14.4, 0.0, 14.4]),
|
||
header_chr: CharProps { italic: Some(true), ..Default::default() },
|
||
header_fill: Some(Rgb(0xFF, 0xFF, 0)),
|
||
header_borders: Some(Borders::all(Border::single(1.5))),
|
||
band_fill: Some(Rgb(0xF2, 0xF2, 0xF2)),
|
||
band_chr: CharProps { bold: Some(true), color: Some(TextColor::Rgb(Rgb(0, 0x70, 0xC0))), ..Default::default() },
|
||
band_borders: Some(Borders::box_(Border { style: BorderStyle::None, width: 0.0, color: None, space: 0.0 })),
|
||
band_size: Some(3),
|
||
..Default::default()
|
||
};
|
||
d.styles.upsert(Style {
|
||
id: "Whole".into(),
|
||
name: "Whole".into(),
|
||
kind: StyleKind::Table,
|
||
based_on: Some("TableGrid".into()),
|
||
para: ParaProps { align: Some(Align::Center), space_after: Some(0.0), ..Default::default() },
|
||
chr: CharProps { bold: Some(true), color: Some(TextColor::Rgb(Rgb(0xC0, 0, 0))), ..Default::default() },
|
||
table: Some(parts.clone()),
|
||
..Default::default()
|
||
});
|
||
let r = rt(&d);
|
||
let got = r.styles.get("Whole").unwrap();
|
||
assert_eq!(got.based_on.as_deref(), Some("TableGrid"));
|
||
assert_eq!(got.para.align, Some(Align::Center));
|
||
assert_eq!(got.para.space_after, Some(0.0));
|
||
assert_eq!((got.chr.bold, got.chr.color), (Some(true), Some(TextColor::Rgb(Rgb(0xC0, 0, 0)))));
|
||
assert_eq!(got.table.as_ref(), Some(&parts));
|
||
}
|
||
|
||
#[test]
|
||
fn notes_round_trip() {
|
||
let mut d = Document::new();
|
||
let f = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("A footnote.", CharProps::default()))]);
|
||
let f2 = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("Custom.", CharProps::default()))]);
|
||
let e = d.add_part(
|
||
PartKind::Endnote,
|
||
vec![
|
||
para_block(Paragraph::with_text("An endnote.", CharProps::default())),
|
||
para_block(Paragraph::with_text("Second para.", CharProps::default())),
|
||
],
|
||
);
|
||
let mut p = Paragraph::with_text("Text", CharProps::default());
|
||
let sup = CharProps { vert_align: Some(VertAlign::Superscript), ..Default::default() };
|
||
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &sup).unwrap();
|
||
p.insert_object(1, InlineObject::NoteRef { kind: NoteKind::Endnote, id: e, custom: String::new() }, &sup).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f2, custom: "*".into() }, &sup).unwrap();
|
||
d.settings.footnote_format = NumFormat::LowerLetter;
|
||
d.settings.endnote_format = NumFormat::UpperRoman;
|
||
d.body = vec![para_block(p.clone())];
|
||
let r = rt(&d);
|
||
let got = paras(&r)[0];
|
||
assert_eq!(got.text, p.text);
|
||
assert_eq!(got.runs, p.runs);
|
||
let notes: Vec<(NoteKind, String, String)> = got
|
||
.objects
|
||
.iter()
|
||
.map(|o| match o {
|
||
InlineObject::NoteRef { kind, id, custom } => (*kind, part_text(&r, Some(*id)), custom.clone()),
|
||
o => panic!("unexpected {o:?}"),
|
||
})
|
||
.collect();
|
||
assert_eq!(
|
||
notes,
|
||
vec![
|
||
(NoteKind::Endnote, "An endnote.\nSecond para.".into(), String::new()),
|
||
(NoteKind::Footnote, "A footnote.".into(), String::new()),
|
||
(NoteKind::Footnote, "Custom.".into(), "*".into()),
|
||
]
|
||
);
|
||
assert_eq!(r.settings.footnote_format, NumFormat::LowerLetter);
|
||
assert_eq!(r.settings.endnote_format, NumFormat::UpperRoman);
|
||
}
|
||
|
||
/// #385: footnote and endnote options round-trip for the document (settings) and per section
|
||
/// (`w:sectPr`), in schema order: `w:footnotePr` and `w:endnotePr` before `w:type`.
|
||
#[test]
|
||
fn note_options_round_trip_per_section() {
|
||
use wordcraft_doc::section::{NotePos, NoteProps, NoteRestart};
|
||
let mut d = Document::new();
|
||
d.settings.footnote_format = NumFormat::UpperLetter;
|
||
d.settings.footnote_pr =
|
||
NoteProps { pos: Some(NotePos::BeneathText), num_start: Some(4), num_restart: Some(NoteRestart::EachPage), ..Default::default() };
|
||
d.settings.endnote_pr = NoteProps { pos: Some(NotePos::SectEnd), ..Default::default() };
|
||
let mut first = Paragraph::with_text("Section one", CharProps::default());
|
||
let own = NoteProps { num_fmt: Some(NumFormat::LowerRoman), num_start: Some(7), num_restart: Some(NoteRestart::EachSect), ..Default::default() };
|
||
first.section = Some(Box::new(SectionProps {
|
||
footnote_pr: own,
|
||
endnote_pr: NoteProps { num_fmt: Some(NumFormat::Decimal), ..Default::default() },
|
||
..Default::default()
|
||
}));
|
||
d.body = vec![para_block(first), para_block(Paragraph::with_text("Section two", CharProps::default()))];
|
||
let bytes = wordcraft_docx::write(&d).unwrap();
|
||
let r = wordcraft_docx::read(&bytes).unwrap();
|
||
assert_eq!(r.settings.footnote_format, NumFormat::UpperLetter);
|
||
assert_eq!((r.settings.footnote_pr, r.settings.endnote_pr), (d.settings.footnote_pr, d.settings.endnote_pr));
|
||
let sections = r.sections();
|
||
assert_eq!(sections[0].1.footnote_pr, own);
|
||
assert_eq!(sections[0].1.endnote_pr.num_fmt, Some(NumFormat::Decimal));
|
||
assert!(sections[1].1.footnote_pr.is_empty() && sections[1].1.endnote_pr.is_empty());
|
||
assert_eq!(r.note_options(sections[0].1, false).num_start, 7);
|
||
assert_eq!(r.note_options(sections[1].1, false).num_start, 4);
|
||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
let at = |s: &str| xml.find(s).unwrap_or_else(|| panic!("{s} missing"));
|
||
assert!(
|
||
at("<w:footnotePr><w:numFmt w:val=\"lowerRoman\"/><w:numStart w:val=\"7\"/><w:numRestart w:val=\"eachSect\"/></w:footnotePr>")
|
||
< at("<w:type")
|
||
);
|
||
}
|
||
|
||
/// `references.footnote` starts the note's own text with a reference to the note, so the editor shows
|
||
/// its number. In the file that is the `w:footnoteRef` mark; a `w:footnoteReference` there would make
|
||
/// the note cite itself, which LibreOffice refuses to open.
|
||
#[test]
|
||
fn note_never_references_itself() {
|
||
let mut d = Document::new();
|
||
let f = d.add_part(PartKind::Footnote, Vec::new());
|
||
let mut note = Paragraph::with_text(" The note.", CharProps::default());
|
||
note.insert_object(0, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
|
||
d.parts.get_mut(&f).unwrap().blocks = vec![para_block(note)];
|
||
let mut p = Paragraph::with_text("Text", CharProps::default());
|
||
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/footnotes.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(!xml.contains("<w:footnoteReference"), "a footnote cites itself: {xml}");
|
||
assert_eq!(xml.matches("<w:footnoteRef/>").count(), 1, "{xml}");
|
||
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got = paras(&r)[0];
|
||
let Some(InlineObject::NoteRef { id, .. }) = got.objects.first() else { panic!("{:?}", got.objects) };
|
||
assert_eq!(part_text(&r, Some(*id)).trim(), "The note.");
|
||
}
|
||
|
||
/// A note read from a Word file starts with its own number (a reference to itself, from the
|
||
/// `w:footnoteRef` mark). Saving writes that mark back exactly once, with its character style, and
|
||
/// never as a `w:footnoteReference`; reading the saved file gives the same note again.
|
||
#[test]
|
||
fn word_note_mark_round_trips_once() {
|
||
let mut d = Document::new();
|
||
let f = d.add_part(PartKind::Footnote, Vec::new());
|
||
let e = d.add_part(PartKind::Endnote, Vec::new());
|
||
for (id, kind, style) in [(f, NoteKind::Footnote, "FootnoteReference"), (e, NoteKind::Endnote, "EndnoteReference")] {
|
||
let mut note =
|
||
Paragraph::with_text(" The note.", CharProps::default()).styled(if kind == NoteKind::Footnote { "FootnoteText" } else { "EndnoteText" });
|
||
note.insert_object(
|
||
0,
|
||
InlineObject::NoteRef { kind, id, custom: String::new() },
|
||
&CharProps { style: Some(style.into()), ..Default::default() },
|
||
)
|
||
.unwrap();
|
||
// A second paragraph: the mark is not repeated there.
|
||
d.parts.get_mut(&id).unwrap().blocks = vec![para_block(note), para_block(Paragraph::with_text("More.", CharProps::default()))];
|
||
}
|
||
let mut p = Paragraph::with_text("Text", CharProps::default());
|
||
p.insert_object(4, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::NoteRef { kind: NoteKind::Endnote, id: e, custom: String::new() }, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
|
||
let mut doc = d;
|
||
for pass in 0..2 {
|
||
let bytes = wordcraft_docx::write(&doc).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
for (file, mark, reference, style) in [
|
||
("word/footnotes.xml", "<w:footnoteRef/>", "<w:footnoteReference", "FootnoteReference"),
|
||
("word/endnotes.xml", "<w:endnoteRef/>", "<w:endnoteReference", "EndnoteReference"),
|
||
] {
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name(file).unwrap(), &mut xml).unwrap();
|
||
assert_eq!(xml.matches(mark).count(), 1, "pass {pass}: {xml}");
|
||
assert!(!xml.contains(reference), "pass {pass}: a note cites itself: {xml}");
|
||
assert!(xml.contains(&format!(r#"<w:rStyle w:val="{style}"/></w:rPr>{mark}"#)), "pass {pass}: {xml}");
|
||
}
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let body = paras(&r)[0];
|
||
assert_eq!(body.objects.len(), 2, "pass {pass}");
|
||
for o in &body.objects {
|
||
let InlineObject::NoteRef { kind, id, .. } = o else { panic!("{o:?}") };
|
||
let blocks = &r.parts.get(id).unwrap().blocks;
|
||
assert_eq!(blocks.len(), 2, "pass {pass}");
|
||
let first = blocks[0].as_para().unwrap();
|
||
assert_eq!(first.objects, vec![InlineObject::NoteRef { kind: *kind, id: *id, custom: String::new() }], "pass {pass}");
|
||
assert_eq!(first.plain_text(), " The note.");
|
||
assert!(blocks[1].as_para().unwrap().objects.is_empty(), "pass {pass}");
|
||
}
|
||
doc = r;
|
||
}
|
||
}
|
||
|
||
/// The TOC is a `Contents` paragraph ending in an empty `TOC` field, followed by TOC-styled entries.
|
||
/// In the file the field must contain the entries, inside Word's Table of Contents content control,
|
||
/// or Word shows them as plain text with no Update Table.
|
||
#[test]
|
||
fn toc_field_wraps_its_entries() {
|
||
let mut head = Paragraph::with_text("Contents", CharProps::default()).styled("TOCHeading");
|
||
let end = head.len();
|
||
head.insert_object(
|
||
end,
|
||
InlineObject::Field { instr: "TOC \\o \"1-2\" \\h \\z \\u".into(), result: String::new(), locked: false, code: false },
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
let entries = [("Intro\t1", "TOC1"), ("Detail\t2", "TOC2")];
|
||
let mut blocks = vec![head];
|
||
blocks.extend(entries.iter().map(|(t, st)| Paragraph::with_text(t, CharProps::default()).styled(st)));
|
||
blocks.push(Paragraph::with_text("Body", CharProps::default()));
|
||
let d = doc_with(blocks);
|
||
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
let sdt = xml.find("<w:sdt>").expect("TOC content control");
|
||
assert!(xml.contains(r#"<w:docPartGallery w:val="Table of Contents"/>"#), "{xml}");
|
||
let (begin, fend) = (xml.find(r#"fldCharType="begin""#).unwrap(), xml.find(r#"fldCharType="end""#).unwrap());
|
||
let last_entry = xml.find("Detail").unwrap();
|
||
assert!(sdt < xml.find("Contents").unwrap() && xml.find("</w:sdt>").unwrap() < xml.find(">Body<").unwrap(), "{xml}");
|
||
assert!(begin < xml.find("Intro").unwrap() && fend > last_entry && fend < xml.find("</w:sdt>").unwrap(), "field must span the entries: {xml}");
|
||
// Word starts the field in the first entry; started in the heading, LibreOffice splits the heading.
|
||
let heading_end = xml[..xml.find("Intro").unwrap()].rfind("</w:p>").unwrap();
|
||
assert!(begin > heading_end, "field must start in the first entry, not the heading: {xml}");
|
||
|
||
// WordCraft reads its own TOC back unchanged.
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let ps = paras(&r);
|
||
assert_eq!(ps.iter().map(|p| p.plain_text()).collect::<Vec<_>>(), ["Contents", "Intro\t1", "Detail\t2", "Body"]);
|
||
assert!(matches!(ps[0].objects.first(), Some(InlineObject::Field { instr, .. }) if instr.starts_with("TOC")), "{:?}", ps[0].objects);
|
||
assert!(ps[1].objects.is_empty(), "the field goes back on the heading: {:?}", ps[1].objects);
|
||
assert_eq!(ps[1].props.style.as_deref(), Some("TOC1"));
|
||
}
|
||
|
||
/// Table Layout › Text Direction (#226): each direction is written as Word's `w:textDirection`
|
||
/// value and read back.
|
||
#[test]
|
||
fn cell_text_direction_round_trips() {
|
||
let mut t = Table::new(1, 3, 300.0);
|
||
let dirs = [TextDirection::Horizontal, TextDirection::Down, TextDirection::Up];
|
||
for (c, dir) in t.rows[0].cells.iter_mut().zip(dirs) {
|
||
c.props.text_direction = dir;
|
||
}
|
||
let mut d = Document::new();
|
||
d.body = vec![Arc::new(Block::Table(t)), para_block(Paragraph::new())];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<w:textDirection w:val="tbRl"/>"#), "{xml}");
|
||
assert!(xml.contains(r#"<w:textDirection w:val="btLr"/>"#), "{xml}");
|
||
assert_eq!(xml.matches("w:textDirection").count(), 2, "horizontal cells write nothing: {xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got: Vec<TextDirection> = r.body[0].as_table().expect("table").rows[0].cells.iter().map(|c| c.props.text_direction).collect();
|
||
assert_eq!(got, dirs);
|
||
}
|
||
|
||
/// The TOC field's begin and end belong to the entries' own paragraphs, even when the heading or
|
||
/// an entry holds a text box: the box's paragraphs are written inside them and must not take either.
|
||
#[test]
|
||
fn toc_field_skips_nested_stories() {
|
||
let mut d = Document::new();
|
||
let text_box = |d: &mut Document, text: &str| {
|
||
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text(text, CharProps::default()))]);
|
||
InlineObject::Shape {
|
||
kind: ShapeKind::TextBox,
|
||
w: 72.0,
|
||
h: 36.0,
|
||
fill: None,
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float::default(),
|
||
story: Some(story),
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
}
|
||
};
|
||
let mut head = Paragraph::with_text("Contents", CharProps::default()).styled("TOCHeading");
|
||
let end = head.len();
|
||
head.insert_object(
|
||
end,
|
||
InlineObject::Field { instr: "TOC \\o \"1-1\" \\h \\z \\u".into(), result: String::new(), locked: false, code: false },
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
let end = head.len();
|
||
head.insert_object(end, text_box(&mut d, "Heading box"), &CharProps::default()).unwrap();
|
||
let mut last = Paragraph::with_text("Detail\t2", CharProps::default()).styled("TOC1");
|
||
let end = last.len();
|
||
last.insert_object(end, text_box(&mut d, "Boxed"), &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(head), para_block(last), para_block(Paragraph::with_text("Body", CharProps::default()))];
|
||
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
let boxes: Vec<(usize, usize)> = xml.match_indices("<w:txbxContent>").map(|(a, _)| (a, a + xml[a..].find("</w:txbxContent>").unwrap())).collect();
|
||
assert_eq!(boxes.len(), 2, "{xml}");
|
||
let in_box = |i: usize| boxes.iter().any(|(a, b)| (*a..*b).contains(&i));
|
||
for kind in ["begin", "separate", "end"] {
|
||
let at: Vec<usize> = xml.match_indices(&format!(r#"fldCharType="{kind}""#)).map(|(i, _)| i).collect();
|
||
assert_eq!(at.len(), 1, "{kind}: {xml}");
|
||
assert!(!in_box(at[0]), "field {kind} written inside a text box: {xml}");
|
||
}
|
||
let (begin, end) = (xml.find(r#"fldCharType="begin""#).unwrap(), xml.find(r#"fldCharType="end""#).unwrap());
|
||
assert!(begin > boxes[0].1 && end > boxes[1].1 && end < xml.find("</w:sdt>").unwrap(), "{xml}");
|
||
}
|
||
|
||
#[test]
|
||
fn tracked_changes_round_trip() {
|
||
let mut d = Document::new();
|
||
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Alice".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
|
||
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Bob".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
|
||
d.settings.track_changes = true;
|
||
let ins = CharProps { ins: Some(0), ..Default::default() };
|
||
let del = CharProps { del: Some(1), bold: Some(true), ..Default::default() };
|
||
let both = CharProps { ins: Some(0), del: Some(1), ..Default::default() };
|
||
let p = para_runs(&[("kept ", CharProps::default()), ("added\t", ins.clone()), ("removed", del.clone()), ("gone", both.clone())]);
|
||
let mut p = p;
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::Field { instr: "DATE".into(), result: "today".into(), locked: false, code: false }, &del).unwrap();
|
||
d.body = vec![para_block(p.clone())];
|
||
let r = rt(&d);
|
||
assert_eq!(r.revisions, d.revisions);
|
||
let got = paras(&r)[0];
|
||
assert_eq!(got.text, p.text);
|
||
assert_eq!(got.runs, p.runs);
|
||
assert_eq!(got.objects, p.objects);
|
||
assert!(r.settings.track_changes);
|
||
}
|
||
|
||
#[test]
|
||
fn tracked_paragraph_marks_round_trip() {
|
||
// Issue #229: an inserted / deleted paragraph mark is `w:ins` / `w:del` in the mark's
|
||
// `w:rPr` (ECMA-376 §17.13.5.16, §17.13.5.15), alone or with mark formatting.
|
||
let mut d = Document::new();
|
||
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "Alice".into(), date: "2026-05-01T10:00:00Z".into(), move_name: None });
|
||
d.revisions.push(Revision { kind: RevisionKind::Delete, author: "Bob".into(), date: "2026-05-02T10:00:00Z".into(), move_name: None });
|
||
let mut split = Paragraph::with_text("Owned ALPHA ", CharProps::default());
|
||
split.mark.ins = Some(0);
|
||
let mut joined = Paragraph::with_text("Owned BETA", CharProps::default());
|
||
joined.mark = CharProps { bold: Some(true), del: Some(1), ..Default::default() };
|
||
let last = Paragraph::with_text("plain", CharProps::default());
|
||
d.body = vec![para_block(split), para_block(joined), para_block(last)];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<w:rPr><w:ins w:id="#), "{xml}");
|
||
assert!(xml.contains(r#"<w:rPr><w:del w:id="#), "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got = paras(&r);
|
||
assert_eq!(got.len(), 3);
|
||
let rev = |i: Option<u32>| i.and_then(|i| r.revisions.get(i as usize)).map(|v| (v.kind, v.author.as_str(), v.date.as_str()));
|
||
assert_eq!(rev(got[0].mark.ins), Some((RevisionKind::Insert, "Alice", "2026-05-01T10:00:00Z")));
|
||
assert_eq!(got[0].mark.del, None);
|
||
assert_eq!(rev(got[1].mark.del), Some((RevisionKind::Delete, "Bob", "2026-05-02T10:00:00Z")));
|
||
assert_eq!(got[1].mark.bold, Some(true));
|
||
assert_eq!(got[1].mark.ins, None);
|
||
assert_eq!((got[2].mark.ins, got[2].mark.del), (None, None));
|
||
assert_eq!(got.iter().map(|p| p.text.as_str()).collect::<Vec<_>>(), ["Owned ALPHA ", "Owned BETA", "plain"]);
|
||
}
|
||
|
||
#[test]
|
||
fn fields_and_special_chars_round_trip() {
|
||
let mut p = Paragraph::with_text("a\tb\nc\u{000C}d\u{000E}e\u{2011}f\u{00AD}g spaced ", CharProps::default());
|
||
let fields = [
|
||
InlineObject::Field { instr: "PAGE".into(), result: "4".into(), locked: false, code: false },
|
||
InlineObject::Field { instr: "DATE \\@ \"M/d/yyyy\"".into(), result: "1/2/2026".into(), locked: true, code: false },
|
||
InlineObject::Field { instr: "NUMPAGES".into(), result: String::new(), locked: false, code: false },
|
||
];
|
||
for f in &fields {
|
||
let end = p.len();
|
||
p.insert_object(end, f.clone(), &CharProps { bold: Some(true), ..Default::default() }).unwrap();
|
||
}
|
||
let r = rt(&doc_with(vec![p.clone()]));
|
||
let got = paras(&r)[0];
|
||
assert_eq!(got.text, p.text);
|
||
assert_eq!(got.objects, p.objects);
|
||
assert_eq!(got.runs, p.runs);
|
||
}
|
||
|
||
#[test]
|
||
fn shapes_textboxes_equations_dropcaps_round_trip() {
|
||
let mut d = Document::new();
|
||
let story =
|
||
d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Inside the box", CharProps { bold: Some(true), ..Default::default() }))]);
|
||
let tb = InlineObject::Shape {
|
||
kind: ShapeKind::TextBox,
|
||
w: 144.0,
|
||
h: 72.0,
|
||
fill: Some(Rgb(255, 255, 200)),
|
||
stroke: Some(Rgb(0, 0, 0)),
|
||
stroke_width: 1.0,
|
||
float: Float { wrap: Wrap::Square, h_rel: Anchor::Margin, v_rel: Anchor::Paragraph, x: 10.0, y: 20.0, dist: 0.0, ..Default::default() },
|
||
story: Some(story),
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
let star = InlineObject::Shape {
|
||
kind: ShapeKind::Star,
|
||
w: 20.0,
|
||
h: 20.0,
|
||
fill: None,
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float::default(),
|
||
story: None,
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
let eq = InlineObject::Equation { linear: "x=(-b±√(b^2-4ac))/2a".into(), display: false, math: Default::default() };
|
||
let mut p = Paragraph::with_text("shapes ", CharProps::default());
|
||
for o in [tb, star.clone(), eq.clone()] {
|
||
let end = p.len();
|
||
p.insert_object(end, o, &CharProps::default()).unwrap();
|
||
}
|
||
let mut dc = Paragraph::with_text("Once upon a time", CharProps::default());
|
||
dc.props.drop_cap = Some(3);
|
||
dc.props.space_after = Some(4.0);
|
||
d.body = vec![para_block(p.clone()), para_block(dc.clone())];
|
||
let r = rt(&d);
|
||
let got = paras(&r);
|
||
assert_eq!(got[0].objects.len(), 3);
|
||
match &got[0].objects[0] {
|
||
InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, story, .. } => {
|
||
assert_eq!(
|
||
(*kind, *w, *h, *fill, *stroke, *stroke_width),
|
||
(ShapeKind::TextBox, 144.0, 72.0, Some(Rgb(255, 255, 200)), Some(Rgb(0, 0, 0)), 1.0)
|
||
);
|
||
assert_eq!(float.wrap, Wrap::Square);
|
||
assert_eq!(part_text(&r, *story), "Inside the box");
|
||
}
|
||
o => panic!("{o:?}"),
|
||
}
|
||
assert_eq!(got[0].objects[1], star);
|
||
match &got[0].objects[2] {
|
||
InlineObject::Equation { linear, display, math } => {
|
||
assert_eq!(linear, "x=(-b±√(b^2-4ac))/2a");
|
||
assert!(!display);
|
||
assert_eq!(math.nodes, wordcraft_doc::math::parse_linear(linear), "structure is written as OMML and read back");
|
||
}
|
||
o => panic!("{o:?}"),
|
||
}
|
||
assert_eq!(got.len(), 2, "drop cap paragraph merges back");
|
||
assert_eq!(got[1].text, dc.text);
|
||
assert_eq!(got[1].props, dc.props);
|
||
}
|
||
|
||
/// A group of a picture, a shape and a text box (`wpg:wgp`) comes back as it was saved: its
|
||
/// size, placement and members' space, and each member's offset, size and content.
|
||
#[test]
|
||
fn groups_round_trip() {
|
||
use wordcraft_doc::para::GroupChild;
|
||
let mut d = Document::new();
|
||
let key = d.add_media(tiny_png(), "png");
|
||
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("In the group", CharProps::default()))]);
|
||
let pic = InlineObject::Image { media: key, w: 60.0, h: 40.0, alt: "A picture".into(), float: Float::default(), crop: [0.0; 4], ole: None };
|
||
let oval = InlineObject::Shape {
|
||
kind: ShapeKind::Ellipse,
|
||
w: 50.0,
|
||
h: 30.0,
|
||
fill: Some(Rgb(200, 0, 0)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float::default(),
|
||
story: None,
|
||
freeform: None,
|
||
// A member's shape effects (#275) come back too.
|
||
effects: wordcraft_doc::effects::ShapeEffects {
|
||
shadow: Some(wordcraft_doc::effects::Shadow {
|
||
color: Rgb(0x20, 0x30, 0x40),
|
||
transparency: 60.0,
|
||
blur: 4.0,
|
||
distance: 3.0,
|
||
angle: 135.0,
|
||
rot_with_shape: false,
|
||
}),
|
||
glow: None,
|
||
soft_edge: Some(2.5),
|
||
},
|
||
extra: Default::default(),
|
||
};
|
||
let tb = InlineObject::Shape {
|
||
kind: ShapeKind::TextBox,
|
||
w: 100.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(255, 255, 255)),
|
||
stroke: Some(Rgb(0, 0, 0)),
|
||
stroke_width: 0.75,
|
||
float: Float::default(),
|
||
story: Some(story),
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
let float = Float { wrap: Wrap::Square, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 20.0, y: 10.0, dist: 9.0, ..Default::default() };
|
||
let group = InlineObject::Group {
|
||
w: 240.0,
|
||
h: 120.0,
|
||
float: float.clone(),
|
||
ch_w: 200.0,
|
||
ch_h: 100.0,
|
||
children: vec![
|
||
GroupChild { x: 0.0, y: 0.0, obj: pic },
|
||
GroupChild { x: 150.0, y: 10.0, obj: oval.clone() },
|
||
GroupChild { x: 50.0, y: 60.0, obj: tb },
|
||
],
|
||
canvas: None,
|
||
};
|
||
let mut p = Paragraph::with_text("grouped ", CharProps::default());
|
||
let end = p.len();
|
||
p.insert_object(end, group, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
let r = rt(&d);
|
||
let got = paras(&r);
|
||
let InlineObject::Group { w, h, float: f, ch_w, ch_h, children, .. } = &got[0].objects[0] else { panic!("{:?}", got[0].objects) };
|
||
assert_eq!((*w, *h, *ch_w, *ch_h), (240.0, 120.0, 200.0, 100.0));
|
||
assert_eq!(*f, float);
|
||
assert_eq!(children.iter().map(|c| (c.x, c.y)).collect::<Vec<_>>(), [(0.0, 0.0), (150.0, 10.0), (50.0, 60.0)]);
|
||
match &children[0].obj {
|
||
InlineObject::Image { media, w, h, alt, .. } => {
|
||
assert_eq!((*w, *h, alt.as_str()), (60.0, 40.0, "A picture"));
|
||
assert_eq!(r.media.get(media).map(|m| m.as_slice()), Some(tiny_png().as_slice()));
|
||
}
|
||
o => panic!("{o:?}"),
|
||
}
|
||
assert_eq!(children[1].obj, oval);
|
||
match &children[2].obj {
|
||
InlineObject::Shape { kind, w, h, story, .. } => {
|
||
assert_eq!((*kind, *w, *h), (ShapeKind::TextBox, 100.0, 40.0));
|
||
assert_eq!(part_text(&r, *story), "In the group");
|
||
}
|
||
o => panic!("{o:?}"),
|
||
}
|
||
}
|
||
|
||
/// A Drawing Canvas (`wpc:wpc`, #344) with a picture and a shape comes back as a canvas: its
|
||
/// frame, background and outline, and each member at its offset in the canvas, unscaled.
|
||
#[test]
|
||
fn drawing_canvas_round_trips() {
|
||
use wordcraft_doc::para::{CanvasStyle, GroupChild};
|
||
let mut d = Document::new();
|
||
let key = d.add_media(tiny_png(), "png");
|
||
let pic = InlineObject::Image { media: key, w: 60.0, h: 40.0, alt: "In the canvas".into(), float: Float::default(), crop: [0.0; 4], ole: None };
|
||
let star = InlineObject::Shape {
|
||
kind: ShapeKind::Star,
|
||
w: 72.0,
|
||
h: 72.0,
|
||
fill: Some(Rgb(0xE0, 0xA0, 0x20)),
|
||
stroke: Some(Rgb(0x40, 0x40, 0x40)),
|
||
stroke_width: 1.0,
|
||
float: Float::default(),
|
||
story: None,
|
||
effects: Default::default(),
|
||
freeform: None,
|
||
extra: Default::default(),
|
||
};
|
||
let style = CanvasStyle { fill: Some(Rgb(0xF0, 0xF4, 0xFF)), stroke: Some(Rgb(0x20, 0x40, 0x80)), stroke_width: 1.5 };
|
||
let canvas = InlineObject::Group {
|
||
w: 432.0,
|
||
h: 216.0,
|
||
float: Float::default(),
|
||
ch_w: 432.0,
|
||
ch_h: 216.0,
|
||
children: vec![GroupChild { x: 12.0, y: 18.0, obj: pic }, GroupChild { x: 300.0, y: 100.0, obj: star.clone() }],
|
||
canvas: Some(style),
|
||
};
|
||
let mut p = Paragraph::with_text("drawn ", CharProps::default());
|
||
let end = p.len();
|
||
p.insert_object(end, canvas, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
let bytes = wordcraft_docx::write(&d).unwrap();
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains("wordprocessingCanvas") && xml.contains("<wpc:wpc>") && xml.contains("<wpc:bg>") && xml.contains("<wpc:whole>"), "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).unwrap();
|
||
let got = paras(&r);
|
||
let InlineObject::Group { w, h, ch_w, ch_h, children, canvas, .. } = &got[0].objects[0] else { panic!("{:?}", got[0].objects) };
|
||
assert_eq!((*w, *h, *ch_w, *ch_h), (432.0, 216.0, 432.0, 216.0));
|
||
assert_eq!(*canvas, Some(style));
|
||
assert_eq!(children.iter().map(|c| (c.x, c.y)).collect::<Vec<_>>(), [(12.0, 18.0), (300.0, 100.0)]);
|
||
assert!(matches!(&children[0].obj, InlineObject::Image { w, h, alt, .. } if (*w, *h, alt.as_str()) == (60.0, 40.0, "In the canvas")));
|
||
assert_eq!(children[1].obj, star);
|
||
}
|
||
|
||
/// A turned and flipped Drawing Canvas (#344 with #332): the canvas schema has no transform, so
|
||
/// its turn rides in our `wpc:extLst` extension, after its members; members keep their own turn.
|
||
/// An unturned canvas writes no extension.
|
||
#[test]
|
||
fn rotated_drawing_canvas_round_trips() {
|
||
use wordcraft_doc::para::{CanvasStyle, GroupChild};
|
||
let member = InlineObject::Shape {
|
||
kind: ShapeKind::Rectangle,
|
||
w: 60.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float { rot: 15.0, ..Default::default() },
|
||
story: None,
|
||
effects: Default::default(),
|
||
freeform: None,
|
||
extra: Default::default(),
|
||
};
|
||
let canvas = |float: Float| InlineObject::Group {
|
||
w: 200.0,
|
||
h: 100.0,
|
||
float,
|
||
ch_w: 200.0,
|
||
ch_h: 100.0,
|
||
children: vec![GroupChild { x: 10.0, y: 20.0, obj: member.clone() }],
|
||
canvas: Some(CanvasStyle { fill: Some(Rgb(0xF0, 0xF4, 0xFF)), stroke: None, stroke_width: 0.0 }),
|
||
};
|
||
let square = Float { wrap: Wrap::Square, ..Default::default() };
|
||
let mut p = Paragraph::with_text("c", CharProps::default());
|
||
p.insert_object(1, canvas(Float { rot: 30.0, flip_h: true, ..square.clone() }), &CharProps::default()).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, canvas(square), &CharProps::default()).unwrap();
|
||
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(
|
||
xml.contains(r#"<wpc:extLst><a:ext uri="urn:wordcraft:canvas-xfrm"><a:xfrm rot="1800000" flipH="1"/></a:ext></wpc:extLst></wpc:wpc>"#),
|
||
"{xml}"
|
||
);
|
||
assert_eq!(xml.matches("<wpc:extLst>").count(), 1, "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got = ¶s(&r)[0].objects;
|
||
let spins: Vec<(f32, bool, bool)> = got.iter().map(|o| o.frame().unwrap().2).map(|f| (f.rot, f.flip_h, f.flip_v)).collect();
|
||
assert_eq!(spins, [(30.0, true, false), (0.0, false, false)]);
|
||
let InlineObject::Group { children, canvas, .. } = &got[0] else { panic!("{got:?}") };
|
||
assert!(canvas.is_some());
|
||
assert_eq!(children.len(), 1);
|
||
assert_eq!(children[0].obj.frame().unwrap().2.rot, 15.0);
|
||
}
|
||
|
||
#[test]
|
||
fn compatibility_mode_round_trips() {
|
||
// New documents are Word 2013+ documents; an older file keeps its mode, so saving it doesn't
|
||
// change how Word lays it out.
|
||
assert_eq!(rt(&Document::new()).settings.compat_mode, wordcraft_doc::COMPAT_MODE_CURRENT);
|
||
for mode in [11, 12, 14, 15] {
|
||
let mut d = Document::new();
|
||
d.settings.compat_mode = mode;
|
||
assert_eq!(rt(&d).settings.compat_mode, mode);
|
||
}
|
||
}
|
||
|
||
/// Tools › Templates and Add-ins: the attached template (an external relationship of the settings
|
||
/// part) and "Automatically update document styles" (`w:linkStyles`) round-trip, written in the
|
||
/// schema's order (after `w:mirrorMargins`, before `w:trackRevisions`).
|
||
#[test]
|
||
fn attached_template_and_link_styles_round_trip() {
|
||
let mut d = Document::new();
|
||
d.settings.attached_template = Some("file:///C:/Templates/Report & Co.dotx".into());
|
||
d.settings.link_styles = true;
|
||
d.settings.mirror_margins = true;
|
||
d.settings.track_changes = true;
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/settings.xml").unwrap(), &mut xml).unwrap();
|
||
let at = |tag: &str| xml.find(tag).unwrap_or_else(|| panic!("{tag} missing: {xml}"));
|
||
assert!(at("<w:mirrorMargins") < at("<w:attachedTemplate"));
|
||
assert!(at("<w:attachedTemplate") < at("<w:linkStyles"));
|
||
assert!(at("<w:linkStyles") < at("<w:trackRevisions"));
|
||
let mut rels = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/_rels/settings.xml.rels").unwrap(), &mut rels).unwrap();
|
||
assert!(rels.contains("relationships/attachedTemplate") && rels.contains("TargetMode=\"External\""), "{rels}");
|
||
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
assert_eq!(r.settings.attached_template.as_deref(), Some("file:///C:/Templates/Report & Co.dotx"));
|
||
assert!(r.settings.link_styles);
|
||
|
||
// Detached: neither element nor relationship is written.
|
||
let plain = rt(&Document::new());
|
||
assert_eq!(plain.settings.attached_template, None);
|
||
assert!(!plain.settings.link_styles);
|
||
}
|
||
|
||
#[test]
|
||
fn settings_core_theme_round_trip() {
|
||
let mut d = Document::new();
|
||
d.settings.track_changes = true;
|
||
d.settings.default_tab = 18.0;
|
||
d.settings.even_odd_headers = true;
|
||
d.settings.mirror_margins = true;
|
||
d.settings.auto_hyphenation = true;
|
||
// Hyphenation Options (#407): zone, words in capitals, consecutive hyphens.
|
||
d.settings.hyphenation_zone = 27.0;
|
||
d.settings.hyphenate_caps = false;
|
||
d.settings.consecutive_hyphen_limit = 2;
|
||
d.settings.page_color = Some(Rgb(250, 240, 230));
|
||
d.settings.major_font = "Cambria".into();
|
||
d.settings.minor_font = "Calibri".into();
|
||
d.settings.theme_colors[4] = Rgb(1, 2, 3);
|
||
d.settings.theme_name = "Mine".into();
|
||
d.settings.protection = Some("readOnly".into());
|
||
d.settings.grid_h = 5.5;
|
||
d.settings.grid_v = 18.0;
|
||
d.settings.math = Some(wordcraft_doc::math::MathProps {
|
||
brk_bin: wordcraft_doc::math::BrkBin::Repeat,
|
||
brk_bin_sub: wordcraft_doc::math::BrkBinSub::PlusMinus,
|
||
wrap_indent: 36.0,
|
||
wrap_right: false,
|
||
});
|
||
d.core.title = "Title & <stuff>".into();
|
||
d.core.subject = "Subj".into();
|
||
d.core.creator = "Me".into();
|
||
d.core.keywords = "a, b".into();
|
||
d.core.description = "Desc".into();
|
||
d.core.category = "Cat".into();
|
||
d.core.last_modified_by = "You".into();
|
||
d.core.created = "2026-01-01T00:00:00Z".into();
|
||
d.core.modified = "2026-02-01T00:00:00Z".into();
|
||
d.core.revision = 7;
|
||
let r = rt(&d);
|
||
assert_eq!(r.settings, d.settings);
|
||
assert_eq!(r.core, d.core);
|
||
// Watermarks aren't stored in DOCX by this crate (yet).
|
||
let mut w = d.clone();
|
||
w.settings.watermark = Some(Watermark::default());
|
||
assert_eq!(rt(&w).settings.watermark, None);
|
||
}
|
||
|
||
/// A document that uses everything, for second-generation stability checks.
|
||
fn kitchen_sink() -> Document {
|
||
let mut d = Document::new();
|
||
let png = tiny_png();
|
||
let key = d.add_media(png, "png");
|
||
let num = d.numbering.add_list(ListKind::Numbered);
|
||
let h = d.add_part(PartKind::Header, vec![para_block(Paragraph::with_text("Head", CharProps::default()))]);
|
||
let f = d.add_part(PartKind::Footnote, vec![para_block(Paragraph::with_text("Note", CharProps::default()))]);
|
||
let c = d.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text("Comment", CharProps::default()))]);
|
||
d.comments.insert(3, Comment { author: "X".into(), part: c, ..Default::default() });
|
||
d.revisions.push(Revision { kind: RevisionKind::Insert, author: "A".into(), date: String::new(), move_name: None });
|
||
d.last_section.headers.default = Some(h);
|
||
let mut blocks: Blocks = Vec::new();
|
||
let mut p = para_runs(&[
|
||
("Hello ", CharProps::default()),
|
||
("bold", CharProps { bold: Some(true), ..Default::default() }),
|
||
(" link", CharProps { link: Some("https://x.org".into()), ..Default::default() }),
|
||
]);
|
||
p.insert_object(0, InlineObject::CommentStart { id: 3 }, &CharProps::default()).unwrap();
|
||
let end = p.len();
|
||
p.insert_object(end, InlineObject::CommentEnd { id: 3 }, &CharProps::default()).unwrap();
|
||
let at = p.text.find("bold").unwrap();
|
||
p.insert_object(at, InlineObject::NoteRef { kind: NoteKind::Footnote, id: f, custom: String::new() }, &CharProps::default()).unwrap();
|
||
blocks.push(para_block(p));
|
||
let mut li = Paragraph::with_text("listed", CharProps { ins: Some(0), ..Default::default() });
|
||
li.props.numbering = Some(NumRef { num, level: 0 });
|
||
blocks.push(para_block(li));
|
||
let mut img = Paragraph::new();
|
||
img.insert_object(
|
||
0,
|
||
InlineObject::Image { media: key, w: 30.0, h: 20.0, alt: "pic".into(), float: Float::default(), crop: [0.0; 4], ole: None },
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
blocks.push(para_block(img));
|
||
let mut t = Table::new(2, 2, 300.0);
|
||
t.merge(0, 1, 1, 1);
|
||
t.rows[0].cells[0] = Cell::with_text("cell");
|
||
blocks.push(Arc::new(Block::Table(t)));
|
||
blocks.push(para_block(Paragraph::new()));
|
||
d.body = blocks;
|
||
d
|
||
}
|
||
|
||
#[test]
|
||
fn second_generation_is_stable() {
|
||
let d1 = rt(&kitchen_sink());
|
||
let d2 = rt(&d1);
|
||
assert_eq!(d2.body, d1.body);
|
||
assert_eq!(d2.parts, d1.parts);
|
||
assert_eq!(d2.styles, d1.styles);
|
||
assert_eq!(d2.numbering, d1.numbering);
|
||
assert_eq!(d2.comments, d1.comments);
|
||
assert_eq!(d2.revisions, d1.revisions);
|
||
assert_eq!(d2.settings, d1.settings);
|
||
assert_eq!(d2.media, d1.media);
|
||
assert_eq!(d2, d1);
|
||
}
|
||
|
||
/// A Word XML Document (Flat OPC) carries the same package as a .docx: reading it back gives
|
||
/// what the .docx round trip gives, pictures included (#548).
|
||
#[test]
|
||
fn flat_opc_round_trip_equals_docx() {
|
||
let d = kitchen_sink();
|
||
let xml = wordcraft_docx::write_flat(&d).expect("write flat");
|
||
let text = std::str::from_utf8(&xml).expect("utf-8");
|
||
assert!(text.starts_with("<?xml") && text.contains("<?mso-application progid=\"Word.Document\"?>"));
|
||
assert!(text.contains("pkg:name=\"/word/document.xml\"") && text.contains("<pkg:binaryData>"));
|
||
assert_eq!(wordcraft_docx::sniff_xml(&xml), wordcraft_docx::XmlKind::FlatOpc);
|
||
let back = wordcraft_docx::read_xml(&xml).expect("read flat");
|
||
assert_eq!(back, rt(&d));
|
||
assert_eq!(back.media.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn builtin_stylesheet_survives() {
|
||
let d = Document::new();
|
||
let r = rt(&d);
|
||
assert_eq!(r.styles, d.styles);
|
||
assert_eq!(r.body, d.body);
|
||
assert_eq!(r.last_section, d.last_section);
|
||
}
|
||
|
||
#[test]
|
||
fn hostile_model_values_still_write() {
|
||
let mut d = Document::new();
|
||
let mut p = Paragraph::with_text(
|
||
"x\u{1}\u{FFFE}y<&>\"'",
|
||
CharProps { size: Some(f32::NAN), spacing: Some(f32::INFINITY), font: Some("A\"B<".into()), ..Default::default() },
|
||
);
|
||
p.props.indent_left = Some(f32::NEG_INFINITY);
|
||
p.props.line_spacing = Some(LineSpacing::Multiple(f32::NAN));
|
||
p.insert_object(
|
||
0,
|
||
InlineObject::Opaque { format: "docx".into(), xml: "<w:r><w:t>raw</w:t></w:r>".into(), text: "raw".into() },
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
p.insert_object(0, InlineObject::Opaque { format: "docx".into(), xml: "<broken".into(), text: "fallback".into() }, &CharProps::default())
|
||
.unwrap();
|
||
p.insert_object(
|
||
0,
|
||
InlineObject::Image {
|
||
media: "missing.png".into(),
|
||
w: -5.0,
|
||
h: f32::NAN,
|
||
alt: String::new(),
|
||
float: Float::default(),
|
||
crop: [f32::NAN; 4],
|
||
ole: None,
|
||
},
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
p.insert_object(0, InlineObject::CommentEnd { id: 99 }, &CharProps::default()).unwrap();
|
||
p.insert_object(0, InlineObject::NoteRef { kind: NoteKind::Endnote, id: 12345, custom: String::new() }, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
d.media.insert("weird name/../x".into(), Arc::new(b"GIF89a....".to_vec()));
|
||
d.media.insert("".into(), Arc::new(vec![0, 1, 2]));
|
||
let bytes = wordcraft_docx::write(&d).unwrap();
|
||
let r = wordcraft_docx::read(&bytes).unwrap();
|
||
let t = paras(&r)[0].plain_text();
|
||
assert!(t.contains("y<&>\"'"), "{t}");
|
||
assert!(t.contains("raw") && t.contains("fallback"), "{t}");
|
||
// Media nothing references aren't written.
|
||
assert!(r.media.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn ensure_empty_and_table_end_document_is_valid() {
|
||
let mut d = Document::new();
|
||
d.body = vec![Arc::new(Block::Table(Table::new(1, 1, 100.0)))];
|
||
let r = rt(&d);
|
||
assert!(matches!(*r.body[0], Block::Table(_)));
|
||
assert!(matches!(**r.body.last().unwrap(), Block::Para(_)));
|
||
let mut e = Document::new();
|
||
e.body.clear();
|
||
let r = rt(&e);
|
||
assert_eq!(r.body.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn self_showing_text_box_saves_bounded() {
|
||
// Crafted: a box whose 30 shapes all show that same box. Unbounded, saving would nest it.
|
||
let mut d = Document::from_text("Body");
|
||
let id = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Box", CharProps::default()))]);
|
||
let shape = || InlineObject::Shape {
|
||
kind: ShapeKind::TextBox,
|
||
w: 40.0,
|
||
h: 20.0,
|
||
fill: None,
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float::default(),
|
||
story: Some(id),
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
for _ in 0..30 {
|
||
d.insert_object(
|
||
&wordcraft_doc::Pos { story: wordcraft_doc::StoryRef::Part(id), path: wordcraft_doc::Path::top(0), off: 0 },
|
||
shape(),
|
||
&CharProps::default(),
|
||
)
|
||
.unwrap();
|
||
}
|
||
d.insert_object(&wordcraft_doc::Pos::body(0, 0), shape(), &CharProps::default()).unwrap();
|
||
let bytes = wordcraft_docx::write(&d).unwrap();
|
||
assert!(bytes.len() < 200_000, "{} bytes", bytes.len());
|
||
// It still opens, with the box's text.
|
||
let back = wordcraft_docx::read(&bytes).unwrap();
|
||
assert!(back.parts.values().any(|p| p.kind == PartKind::TextBox));
|
||
}
|
||
|
||
#[test]
|
||
fn char_border_written_between_u_and_shd() {
|
||
let c =
|
||
CharProps { border: Some(Border::single(0.5)), underline: Some(Underline::Single), shading: Some(Rgb(0xFF, 0xFF, 0)), ..Default::default() };
|
||
let bytes = wordcraft_docx::write(&doc_with(vec![para_runs(&[("x", c)])])).unwrap();
|
||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
let bdr = r#"<w:bdr w:val="single" w:sz="4" w:space="0" w:color="auto"/>"#;
|
||
assert_eq!(xml.matches(bdr).count(), 1, "{xml}");
|
||
let at = xml.find(bdr).unwrap();
|
||
assert!(xml.find("<w:u ").unwrap() < at && at < xml.find("<w:shd ").unwrap(), "{xml}");
|
||
}
|
||
|
||
#[test]
|
||
fn floating_tables_round_trip() {
|
||
use wordcraft_doc::para::{Anchor, FloatAlign};
|
||
use wordcraft_doc::props::TableFloat;
|
||
let mut d = Document::new();
|
||
let mut t = Table::new(1, 2, 200.0);
|
||
let f = TableFloat {
|
||
h_rel: Anchor::Margin,
|
||
v_rel: Anchor::Paragraph,
|
||
x: 0.0,
|
||
y: -1.65,
|
||
h_align: None,
|
||
v_align: None,
|
||
dist: [9.0, 0.0, 12.0, 3.0],
|
||
overlap: false,
|
||
};
|
||
t.props.float = Some(f);
|
||
let mut page = Table::new(1, 1, 100.0);
|
||
let centred =
|
||
TableFloat { h_rel: Anchor::Page, v_rel: Anchor::Margin, h_align: Some(FloatAlign::Center), y: 36.0, overlap: true, ..Default::default() };
|
||
page.props.float = Some(centred);
|
||
d.body = vec![Arc::new(Block::Table(t)), Arc::new(Block::Table(page)), para_block(Paragraph::with_text("after", CharProps::default()))];
|
||
let back = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
|
||
let floats: Vec<_> = back.body.iter().filter_map(|b| if let Block::Table(t) = &**b { t.props.float } else { None }).collect();
|
||
assert_eq!(floats, [f, centred]);
|
||
}
|
||
|
||
#[test]
|
||
fn list_level_overrides_round_trip() {
|
||
use wordcraft_doc::numbering::{Counters, Level};
|
||
use wordcraft_doc::section::NumFormat;
|
||
let mut d = Document::new();
|
||
let num = d.numbering.add_list(ListKind::Numbered);
|
||
let restart = d.numbering.restart(num).unwrap();
|
||
let own = Level { format: NumFormat::DecimalZero, text: "%1.%2".into(), indent: 26.5, hanging: 26.5, ..Level::default() };
|
||
if let Some(n) = d.numbering.nums.iter_mut().find(|n| n.id == restart) {
|
||
n.level_overrides = vec![(1, own.clone())];
|
||
}
|
||
let back = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
|
||
let n = back.numbering.num(restart).unwrap();
|
||
assert_eq!(n.level_overrides.len(), 1);
|
||
let (lvl, got) = &n.level_overrides[0];
|
||
assert_eq!((*lvl, got.format, got.text.as_str(), got.indent, got.hanging), (1, NumFormat::DecimalZero, "%1.%2", 26.5, 26.5));
|
||
// The start overrides that `restart` wrote survive beside it.
|
||
assert_eq!(n.start_overrides, d.numbering.num(restart).unwrap().start_overrides);
|
||
let mut c = Counters::default();
|
||
assert_eq!(c.next_label(&back.numbering, restart, 0).unwrap().0, "1.");
|
||
assert_eq!(c.next_label(&back.numbering, restart, 1).unwrap().0, "1.01");
|
||
}
|
||
|
||
/// Ink strokes and freeform shapes are written as DrawingML custom geometry (`a:custGeom`,
|
||
/// `a:moveTo`/`a:lnTo`) in floating drawings and read back with their points, pen, opacity and
|
||
/// drawing order.
|
||
#[test]
|
||
fn ink_and_freeforms_round_trip_as_custom_geometry() {
|
||
use wordcraft_doc::freeform::{FreePath, Freeform, InkTool};
|
||
let shape = |fill, stroke_width, wrap, f: Freeform| InlineObject::Shape {
|
||
kind: ShapeKind::Freeform,
|
||
w: f.w,
|
||
h: f.h,
|
||
fill,
|
||
stroke: Some(Rgb(0xC0, 0, 0)),
|
||
stroke_width,
|
||
float: Float { wrap, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 30.0, y: 12.0, ..Default::default() },
|
||
story: None,
|
||
freeform: Some(Arc::new(f)),
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
// The pen stroke was the seventh drawn: Ink Replay's order comes back too.
|
||
let pen = shape(
|
||
None,
|
||
2.0,
|
||
Wrap::InFrontOfText,
|
||
Freeform { order: Some(7), ..Freeform::ink(InkTool::Pen, 60.0, 20.0, vec![[1.0, 1.0], [30.0, 19.0], [59.0, 4.0]]) },
|
||
);
|
||
let marker = shape(None, 12.0, Wrap::BehindText, Freeform::ink(InkTool::Highlighter, 80.0, 12.0, vec![[6.0, 6.0], [74.0, 6.0]]));
|
||
let triangle = Freeform {
|
||
w: 40.0,
|
||
h: 40.0,
|
||
paths: vec![FreePath { pts: vec![[0.0, 40.0], [20.0, 0.0], [40.0, 40.0]], closed: true }],
|
||
..Default::default()
|
||
};
|
||
let tri = shape(Some(Rgb(0, 0x80, 0)), 1.0, Wrap::Square, triangle);
|
||
let mut p = Paragraph::with_text("Inked", CharProps::default());
|
||
for o in [pen.clone(), marker, tri.clone()] {
|
||
p.insert_object(0, o, &CharProps::default()).unwrap();
|
||
}
|
||
let d = doc_with(vec![p]);
|
||
let bytes = wordcraft_docx::write(&d).unwrap();
|
||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert_eq!(xml.matches("<a:custGeom>").count(), 3, "{xml}");
|
||
assert!(xml.contains(r#"<a:path w="762000" h="254000" fill="none"><a:moveTo><a:pt x="12700" y="12700"/></a:moveTo><a:lnTo>"#), "{xml}");
|
||
assert!(xml.contains(r#"<a:alpha val="50000"/>"#) && xml.contains(r#"cap="rnd""#), "{xml}");
|
||
let r = rt(&d);
|
||
let objs = ¶s(&r)[0].objects;
|
||
assert_eq!(objs.len(), 3);
|
||
// Written in reverse (each inserted at the start): the triangle, the highlighter, the pen.
|
||
assert_eq!(objs[0], tri, "a filled closed freeform comes back as it was");
|
||
let InlineObject::Shape { freeform: Some(m), float, stroke_width, .. } = &objs[1] else { panic!("{:?}", objs[1]) };
|
||
assert_eq!((m.ink, m.alpha, float.wrap, *stroke_width), (Some(InkTool::Highlighter), 0.5, Wrap::BehindText, 12.0));
|
||
assert_eq!(objs[2], pen, "the pen stroke comes back point for point");
|
||
}
|
||
|
||
/// Shape effects (#275): `a:effectLst` with an outer shadow, a glow and soft edges round-trips,
|
||
/// and the effect extent leaves room for them.
|
||
#[test]
|
||
fn shape_effects_round_trip() {
|
||
use wordcraft_doc::effects::{Glow, Shadow, ShapeEffects};
|
||
let effects = ShapeEffects {
|
||
shadow: Some(Shadow { color: Rgb(0x20, 0x30, 0x40), transparency: 60.0, blur: 4.0, distance: 3.0, angle: 135.0, rot_with_shape: false }),
|
||
glow: Some(Glow { color: Rgb(0xC0, 0x50, 0x10), size: 8.0, transparency: 40.0 }),
|
||
soft_edge: Some(2.5),
|
||
};
|
||
let shape = InlineObject::Shape {
|
||
kind: ShapeKind::RoundedRectangle,
|
||
w: 100.0,
|
||
h: 50.0,
|
||
fill: Some(Rgb(0x15, 0x60, 0x82)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float::default(),
|
||
story: None,
|
||
freeform: None,
|
||
effects,
|
||
extra: Default::default(),
|
||
};
|
||
let mut p = Paragraph::with_text("x", CharProps::default());
|
||
p.insert_object(1, shape, &CharProps::default()).unwrap();
|
||
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(
|
||
xml.contains(
|
||
r#"<a:outerShdw blurRad="50800" dist="38100" dir="8100000" algn="tr" rotWithShape="0"><a:srgbClr val="203040"><a:alpha val="40000"/>"#
|
||
),
|
||
"{xml}"
|
||
);
|
||
assert!(xml.contains(r#"<a:glow rad="101600"><a:srgbClr val="C05010"><a:alpha val="60000"/>"#), "{xml}");
|
||
assert!(xml.contains(r#"<a:softEdge rad="31750"/>"#), "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
match paras(&r)[0].objects.first() {
|
||
Some(InlineObject::Shape { effects: got, float, .. }) => {
|
||
assert_eq!(*got, effects);
|
||
assert_eq!(float.effect_extent(), effects.extent());
|
||
}
|
||
o => panic!("{o:?}"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn equation_manual_breaks_round_trip() {
|
||
use wordcraft_doc::math::{MNode, MRun, Math};
|
||
let nodes = vec![
|
||
MNode::Run(MRun::new("a=b")),
|
||
MNode::Run(MRun { brk: Some(1), ..MRun::new("+c") }),
|
||
MNode::Run(MRun { brk: Some(0), ..MRun::new("+d") }),
|
||
];
|
||
let mut d = Document::new();
|
||
let math = Math { nodes: nodes.clone(), ..Default::default() };
|
||
let mut p = Paragraph::with_text("", CharProps::default());
|
||
p.insert_object(0, InlineObject::Equation { linear: "a=b+c+d".into(), display: true, math }, &CharProps::default()).unwrap();
|
||
d.body = vec![para_block(p)];
|
||
let r = rt(&d);
|
||
let got = paras(&r).iter().flat_map(|p| p.objects.iter()).find_map(|o| match o {
|
||
InlineObject::Equation { math, .. } => Some(math.nodes.clone()),
|
||
_ => None,
|
||
});
|
||
assert_eq!(got, Some(nodes));
|
||
// Word's own settings round-trip; a document without them gets none.
|
||
assert_eq!(r.settings.math, None);
|
||
}
|
||
|
||
/// #332: rotation (`a:xfrm/@rot`, 60000ths of a degree) and flips of pictures, shapes, text boxes
|
||
/// and groups survive save and load; the effect extent written covers the rotated bounds, and
|
||
/// reading takes that overhang back out of the effects room.
|
||
#[test]
|
||
fn rotation_and_flips_round_trip() {
|
||
let mut d = Document::new();
|
||
let key = d.add_media(tiny_png(), "png");
|
||
let pic = InlineObject::Image {
|
||
media: key,
|
||
w: 100.0,
|
||
h: 50.0,
|
||
alt: String::new(),
|
||
float: Float { rot: 30.0, effect: [6.0; 4], ..Default::default() },
|
||
crop: [0.0; 4],
|
||
ole: None,
|
||
};
|
||
let shape = |kind, float| InlineObject::Shape {
|
||
kind,
|
||
w: 80.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float,
|
||
story: None,
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra: Default::default(),
|
||
};
|
||
let square = Float { wrap: Wrap::Square, ..Default::default() };
|
||
let tri = shape(ShapeKind::Triangle, Float { rot: 90.0, flip_h: true, ..square.clone() });
|
||
let flipped = shape(ShapeKind::Rectangle, Float { rot: 315.5, flip_v: true, ..square.clone() });
|
||
let group = InlineObject::Group {
|
||
w: 120.0,
|
||
h: 60.0,
|
||
float: Float { rot: 45.0, ..square },
|
||
ch_w: 120.0,
|
||
ch_h: 60.0,
|
||
children: vec![wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: shape(ShapeKind::Ellipse, Float { rot: 10.0, ..Default::default() }) }],
|
||
canvas: None,
|
||
};
|
||
let mut p = Paragraph::with_text("turned ", CharProps::default());
|
||
for o in [pic, tri, flipped, group] {
|
||
let end = p.len();
|
||
p.insert_object(end, o, &CharProps::default()).unwrap();
|
||
}
|
||
d.body = vec![para_block(p)];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<a:xfrm rot="1800000">"#), "{xml}");
|
||
assert!(xml.contains(r#"<a:xfrm rot="5400000" flipH="1">"#), "{xml}");
|
||
assert!(xml.contains(r#"<a:xfrm rot="18930000" flipV="1">"#), "{xml}");
|
||
// The 100 × 50 picture turned 30° covers 111.6 × 93.3: 5.8 and 21.7 pt more on each side,
|
||
// plus its 6 pt of effects room.
|
||
assert!(xml.contains(r#"<wp:effectExtent l="149876" t="351163" r="149876" b="351163"/>"#), "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got = ¶s(&r)[0].objects;
|
||
let spins: Vec<(f32, bool, bool)> = got.iter().map(|o| o.frame().unwrap().2).map(|f| (f.rot, f.flip_h, f.flip_v)).collect();
|
||
assert_eq!(spins, [(30.0, false, false), (90.0, true, false), (315.5, false, true), (45.0, false, false)]);
|
||
let effect = got[0].frame().unwrap().2.effect;
|
||
assert!(effect.iter().all(|e| (e - 6.0).abs() < 0.01), "{effect:?}");
|
||
assert!(got[1].frame().unwrap().2.effect.iter().all(|e| e.abs() < 0.01), "no effects room appears");
|
||
let InlineObject::Group { children, .. } = &got[3] else { panic!("{got:?}") };
|
||
assert_eq!(children[0].obj.frame().unwrap().2.rot, 10.0);
|
||
}
|
||
|
||
/// #332: a group's own turn and flips are on its `wpg:grpSpPr/a:xfrm` and its members keep
|
||
/// theirs inside it; whether a member's shadow turns with it (`rotWithShape`) survives too.
|
||
#[test]
|
||
fn rotated_group_and_shadow_rotation_round_trip() {
|
||
use wordcraft_doc::effects::{Shadow, ShapeEffects};
|
||
let member = |rot_with_shape: bool| InlineObject::Shape {
|
||
kind: ShapeKind::Rectangle,
|
||
w: 60.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float { rot: 20.0, ..Default::default() },
|
||
story: None,
|
||
freeform: None,
|
||
effects: ShapeEffects { shadow: Some(Shadow { rot_with_shape, ..Default::default() }), ..Default::default() },
|
||
extra: Default::default(),
|
||
};
|
||
let group = InlineObject::Group {
|
||
w: 120.0,
|
||
h: 40.0,
|
||
float: Float { wrap: Wrap::Square, rot: 135.0, flip_h: true, ..Default::default() },
|
||
ch_w: 120.0,
|
||
ch_h: 40.0,
|
||
children: vec![
|
||
wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: member(true) },
|
||
wordcraft_doc::para::GroupChild { x: 60.0, y: 0.0, obj: member(false) },
|
||
],
|
||
canvas: None,
|
||
};
|
||
let mut p = Paragraph::with_text("g", CharProps::default());
|
||
p.insert_object(1, group, &CharProps::default()).unwrap();
|
||
let bytes = wordcraft_docx::write(&doc_with(vec![p])).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<wpg:grpSpPr><a:xfrm rot="8100000" flipH="1">"#), "{xml}");
|
||
assert!(xml.contains(r#"rotWithShape="1""#) && xml.contains(r#"rotWithShape="0""#), "{xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let Some(InlineObject::Group { float, children, .. }) = paras(&r)[0].objects.first() else { panic!("{:?}", paras(&r)[0].objects) };
|
||
assert_eq!((float.rot, float.flip_h, float.flip_v), (135.0, true, false));
|
||
let got: Vec<(f32, Option<bool>)> = children
|
||
.iter()
|
||
.map(|c| match &c.obj {
|
||
InlineObject::Shape { float, effects, .. } => (float.rot, effects.shadow.map(|s| s.rot_with_shape)),
|
||
o => panic!("{o:?}"),
|
||
})
|
||
.collect();
|
||
assert_eq!(got, [(20.0, Some(true)), (20.0, Some(false))]);
|
||
}
|
||
|
||
#[test]
|
||
fn wrap_polygons_round_trip() {
|
||
use wordcraft_doc::wrap::{WrapPolygon, shape_outline};
|
||
let mut d = Document::new();
|
||
let shape = |kind, float| InlineObject::Shape {
|
||
kind,
|
||
w: 80.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float,
|
||
story: None,
|
||
effects: Default::default(),
|
||
freeform: None,
|
||
extra: Default::default(),
|
||
};
|
||
// A hand-edited polygon, including points outside the frame.
|
||
let poly = WrapPolygon::new(true, [(-300, 0), (21_600, 1200), (18_000, 21_900), (0, 21_600)]).map(Arc::new);
|
||
let edited = Float { wrap: Wrap::Tight, v_rel: Anchor::Paragraph, wrap_polygon: poly.clone(), ..Default::default() };
|
||
// None: Through wrapping needs one, so the ellipse's own outline is written.
|
||
let derived = Float { wrap: Wrap::Through, ..Default::default() };
|
||
let mut p = Paragraph::with_text("wrapped ", CharProps::default());
|
||
for o in [shape(ShapeKind::Rectangle, edited.clone()), shape(ShapeKind::Ellipse, derived)] {
|
||
let end = p.len();
|
||
p.insert_object(end, o, &CharProps::default()).unwrap();
|
||
}
|
||
d.body = vec![para_block(p)];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<wp:wrapPolygon edited="1"><wp:start x="-300" y="0"/><wp:lineTo x="21600" y="1200"/>"#), "{xml}");
|
||
assert!(xml.contains(r#"<wp:lineTo x="-300" y="0"/></wp:wrapPolygon>"#), "closed: {xml}");
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got = paras(&r)[0];
|
||
let floats: Vec<Float> = got.objects.iter().filter_map(|o| o.frame().map(|(_, _, f)| f.clone())).collect();
|
||
assert_eq!(floats[0], edited);
|
||
let ellipse = WrapPolygon::from_unit(false, &shape_outline(ShapeKind::Ellipse, 80.0, 40.0).unwrap());
|
||
assert_eq!(floats[1].wrap, Wrap::Through);
|
||
assert_eq!(floats[1].wrap_polygon.as_deref(), ellipse.as_ref());
|
||
}
|
||
|
||
/// Enclosed characters (#297) are written as Word stores them — an `eq \o\ac(○,字)` field with no
|
||
/// result, the symbol and the text in runs of their own sizes — and read back with their style,
|
||
/// whether the field's size is set on the run or comes from the styles.
|
||
#[test]
|
||
fn enclosed_characters_round_trip_in_words_structure() {
|
||
use wordcraft_doc::eq::{EncloseShape, EncloseStyle, Enclosure};
|
||
let mut p = Paragraph::new();
|
||
let cases = [
|
||
(EncloseShape::Circle, EncloseStyle::Shrink, Some(11.0)),
|
||
(EncloseShape::Triangle, EncloseStyle::Enlarge, Some(11.0)),
|
||
(EncloseShape::Square, EncloseStyle::Shrink, None),
|
||
(EncloseShape::Diamond, EncloseStyle::Enlarge, None),
|
||
];
|
||
for (shape, style, size) in cases {
|
||
let e = Enclosure { shape, style, text: "字".into() };
|
||
let off = p.len();
|
||
p.insert_object(
|
||
off,
|
||
InlineObject::Field { instr: e.instr(), result: "字".into(), locked: false, code: false },
|
||
&CharProps { size, ..Default::default() },
|
||
)
|
||
.unwrap();
|
||
}
|
||
let doc = doc_with(vec![p]);
|
||
let bytes = wordcraft_docx::write(&doc).unwrap();
|
||
let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"<w:instrText xml:space="preserve"> eq \o\ac(○</w:instrText>"#), "{xml}");
|
||
assert!(!xml.contains("separate") && !xml.contains("enlarge"), "{xml}");
|
||
// Shrink text at 11 pt: the character at 7.5 pt (half-points 15), raised.
|
||
assert!(xml.contains(r#"<w:sz w:val="15"/>"#), "{xml}");
|
||
let back = wordcraft_docx::read(&bytes).unwrap();
|
||
let got: Vec<Enclosure> = paras(&back)[0]
|
||
.objects
|
||
.iter()
|
||
.filter_map(|o| if let InlineObject::Field { instr, result, .. } = o { Enclosure::parse(instr).filter(|_| result == "字") } else { None })
|
||
.collect();
|
||
let want: Vec<Enclosure> = cases.iter().map(|(shape, style, _)| Enclosure { shape: *shape, style: *style, text: "字".into() }).collect();
|
||
assert_eq!(got, want);
|
||
}
|
||
|
||
#[test]
|
||
fn ruby_phonetic_guide_round_trips_as_w_ruby() {
|
||
use wordcraft_doc::para::RubyAlign;
|
||
let mut p = Paragraph::with_text("Read daily.", CharProps::default());
|
||
let bold = CharProps { bold: Some(true), ..Default::default() };
|
||
let ruby = InlineObject::Ruby {
|
||
base: "漢字".into(),
|
||
ruby: "かんじ".into(),
|
||
align: RubyAlign::DistributeSpace,
|
||
size: 5.5,
|
||
raise: 10.0,
|
||
base_size: 11.0,
|
||
lang: "ja-JP".into(),
|
||
props: Box::new(CharProps { font: Some("Noto Sans CJK JP".into()), ..Default::default() }),
|
||
};
|
||
p.insert_object(5, ruby.clone(), &bold).unwrap();
|
||
let d = doc_with(vec![p]);
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
for part in [
|
||
r#"<w:rubyAlign w:val="distributeSpace"/><w:hps w:val="11"/><w:hpsRaise w:val="20"/><w:hpsBaseText w:val="22"/><w:lid w:val="ja-JP"/>"#,
|
||
"<w:rt><w:r>",
|
||
">かんじ</w:t>",
|
||
"<w:rubyBase><w:r><w:rPr><w:b/>",
|
||
">漢字</w:t>",
|
||
] {
|
||
assert!(xml.contains(part), "missing {part}: {xml}");
|
||
}
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let q = paras(&r)[0];
|
||
assert_eq!(q.plain_text(), "Read 漢字 daily.");
|
||
assert_eq!(q.objects, vec![ruby]);
|
||
assert_eq!(q.props_of_char(5).bold, Some(true));
|
||
}
|
||
|
||
/// #354: the sides text wraps on (`@wrapText`) are read and written for Square, Tight and
|
||
/// Through; both sides is the default.
|
||
#[test]
|
||
fn wrap_text_sides_round_trip() {
|
||
use wordcraft_doc::para::WrapText;
|
||
let mut d = Document::new();
|
||
let shape = |float| InlineObject::Shape {
|
||
kind: ShapeKind::Rectangle,
|
||
w: 80.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float,
|
||
story: None,
|
||
effects: Default::default(),
|
||
freeform: None,
|
||
extra: Default::default(),
|
||
};
|
||
let sides =
|
||
[(Wrap::Square, WrapText::Left), (Wrap::Tight, WrapText::Right), (Wrap::Through, WrapText::Largest), (Wrap::Square, WrapText::BothSides)];
|
||
let mut p = Paragraph::with_text("wrapped ", CharProps::default());
|
||
for (wrap, side) in sides {
|
||
let end = p.len();
|
||
p.insert_object(end, shape(Float { wrap, wrap_text: side, v_rel: Anchor::Paragraph, ..Default::default() }), &CharProps::default()).unwrap();
|
||
}
|
||
d.body = vec![para_block(p)];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
for tag in [
|
||
r#"<wp:wrapSquare wrapText="left"/>"#,
|
||
r#"<wp:wrapTight wrapText="right">"#,
|
||
r#"<wp:wrapThrough wrapText="largest">"#,
|
||
r#"<wp:wrapSquare wrapText="bothSides"/>"#,
|
||
] {
|
||
assert!(xml.contains(tag), "{tag}: {xml}");
|
||
}
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let got: Vec<_> = paras(&r)[0].objects.iter().filter_map(|o| o.frame().map(|(_, _, f)| (f.wrap, f.wrap_text))).collect();
|
||
assert_eq!(got, sides);
|
||
// A value outside the schema is no side (read as both sides).
|
||
assert_eq!(WrapText::from_ooxml("middle"), None);
|
||
}
|
||
|
||
#[test]
|
||
fn alt_text_title_and_decorative_round_trip_for_every_object() {
|
||
use wordcraft_doc::para::AltText;
|
||
let mut d = Document::new();
|
||
let key = d.add_media(tiny_png(), "png");
|
||
let pic = InlineObject::Image {
|
||
media: key,
|
||
w: 100.0,
|
||
h: 50.0,
|
||
alt: "A kiln at dusk".into(),
|
||
float: Float { alt: AltText { title: "Kiln".into(), ..Default::default() }, ..Default::default() },
|
||
crop: [0.0; 4],
|
||
ole: None,
|
||
};
|
||
let shape = |alt: AltText| InlineObject::Shape {
|
||
kind: ShapeKind::Ellipse,
|
||
w: 80.0,
|
||
h: 40.0,
|
||
fill: Some(Rgb(1, 2, 3)),
|
||
stroke: None,
|
||
stroke_width: 0.0,
|
||
float: Float { alt, ..Default::default() },
|
||
story: None,
|
||
effects: Default::default(),
|
||
freeform: None,
|
||
extra: Default::default(),
|
||
};
|
||
let described = shape(AltText { text: "Process flow & \"steps\"".into(), ..Default::default() });
|
||
let decorative = shape(AltText { decorative: true, ..Default::default() });
|
||
let group = InlineObject::Group {
|
||
w: 120.0,
|
||
h: 60.0,
|
||
float: Float { alt: AltText { text: "Two circles".into(), ..Default::default() }, ..Default::default() },
|
||
ch_w: 120.0,
|
||
ch_h: 60.0,
|
||
children: vec![wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: shape(AltText { text: "Left circle".into(), ..Default::default() }) }],
|
||
canvas: None,
|
||
};
|
||
let mut p = Paragraph::with_text("objects ", CharProps::default());
|
||
for o in [pic, described, decorative, group] {
|
||
let end = p.len();
|
||
p.insert_object(end, o, &CharProps::default()).unwrap();
|
||
}
|
||
let mut t = Table::new(2, 2, 300.0);
|
||
t.props.caption = Some("Prices".into());
|
||
t.props.description = Some("Prices by year".into());
|
||
d.body = vec![para_block(p), Arc::new(Block::Table(t))];
|
||
let bytes = wordcraft_docx::write(&d).expect("write");
|
||
let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
|
||
let mut xml = String::new();
|
||
std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
|
||
assert!(xml.contains(r#"{C183D7F6-B498-43B3-948B-1728B52AA6E4}"><adec:decorative xmlns:adec="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/>"#), "{xml}");
|
||
assert!(
|
||
xml.contains(r#"<w:tblLook "#) && xml.contains(r#"<w:tblCaption w:val="Prices"/><w:tblDescription w:val="Prices by year"/></w:tblPr>"#),
|
||
"{xml}"
|
||
);
|
||
let r = wordcraft_docx::read(&bytes).expect("read");
|
||
let objs = ¶s(&r)[0].objects;
|
||
let alts: Vec<_> =
|
||
objs.iter().map(|o| (o.alt_text().to_string(), o.frame().map(|f| f.2.alt.title.clone()).unwrap_or_default(), o.is_decorative())).collect();
|
||
assert_eq!(
|
||
alts,
|
||
[
|
||
("A kiln at dusk".into(), "Kiln".into(), false),
|
||
("Process flow & \"steps\"".into(), String::new(), false),
|
||
(String::new(), String::new(), true),
|
||
("Two circles".into(), String::new(), false),
|
||
]
|
||
);
|
||
let InlineObject::Group { children, .. } = &objs[3] else { panic!("{objs:?}") };
|
||
assert_eq!(children[0].obj.alt_text(), "Left circle");
|
||
let Some(Block::Table(t)) = r.body.iter().map(|b| &**b).find(|b| matches!(b, Block::Table(_))) else { panic!() };
|
||
assert_eq!((t.props.caption.as_deref(), t.props.description.as_deref()), (Some("Prices"), Some("Prices by year")));
|
||
}
|
||
|
||
/// WordArt's warp (`a:prstTxWarp` with its adjust value) and connectors glued to shapes
|
||
/// (`a:stCxn`/`a:endCxn`, with arrowheads) come back as saved; a shape no connector is glued to
|
||
/// loses its drawing id, and hostile values are reduced.
|
||
#[test]
|
||
fn warps_and_glued_connectors_round_trip() {
|
||
use wordcraft_doc::connector::{ConnEnd, ShapeExtra};
|
||
use wordcraft_doc::wordart::TextWarp;
|
||
let mut d = Document::new();
|
||
let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Bent", CharProps::default()))]);
|
||
let float = |x: f32| Float { wrap: Wrap::InFrontOfText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x, y: 10.0, ..Default::default() };
|
||
let shape = |kind, story, extra| InlineObject::Shape {
|
||
kind,
|
||
w: 72.0,
|
||
h: 36.0,
|
||
fill: None,
|
||
stroke: Some(Rgb(0, 0, 0)),
|
||
stroke_width: 1.0,
|
||
float: float(0.0),
|
||
story,
|
||
freeform: None,
|
||
effects: Default::default(),
|
||
extra,
|
||
};
|
||
let mut warp = TextWarp::new("textArchUp").unwrap();
|
||
warp.set_adj("adj", 9_000_000);
|
||
let art = shape(ShapeKind::TextBox, Some(story), ShapeExtra { id: 5, warp: Some(warp), ..Default::default() });
|
||
let target = shape(ShapeKind::Ellipse, None, ShapeExtra { id: 7, ..Default::default() });
|
||
let lonely = shape(ShapeKind::Rectangle, None, ShapeExtra { id: 9, ..Default::default() });
|
||
let link = ShapeExtra { start: Some(ConnEnd { id: 5, site: 3 }), end: Some(ConnEnd { id: 7, site: 2 }), arrow_end: true, ..Default::default() };
|
||
let mut conn = shape(ShapeKind::ElbowConnector, None, link);
|
||
if let InlineObject::Shape { float: f, .. } = &mut conn {
|
||
*f = Float { flip_v: true, ..float(80.0) };
|
||
}
|
||
let mut p = Paragraph::with_text("", CharProps::default());
|
||
for o in [art.clone(), conn.clone(), target.clone(), lonely] {
|
||
let end = p.len();
|
||
p.insert_object(end, o, &CharProps::default()).unwrap();
|
||
}
|
||
d.body = vec![para_block(p)];
|
||
let r = rt(&d);
|
||
let got = ¶s(&r)[0].objects;
|
||
// The glued-to shapes keep their ids, the connector its ends, arrowhead and flip.
|
||
let extra = |o: &InlineObject| match o {
|
||
InlineObject::Shape { extra, .. } => extra.clone(),
|
||
_ => panic!("{o:?}"),
|
||
};
|
||
assert_eq!(extra(&got[0]), extra(&art));
|
||
assert_eq!(extra(&got[1]), extra(&conn));
|
||
assert!(matches!(&got[1], InlineObject::Shape { kind: ShapeKind::ElbowConnector, float, .. } if float.flip_v));
|
||
assert_eq!(extra(&got[2]), extra(&target));
|
||
assert_eq!(extra(&got[3]).id, 0, "nothing is glued to it");
|
||
|
||
// Hostile: an unknown warp, a huge adjust value, a glue to a missing shape.
|
||
let xml = wordcraft_docx::write(&r).unwrap();
|
||
let mut pkg = zip::ZipArchive::new(std::io::Cursor::new(xml)).unwrap();
|
||
let mut doc_xml = String::new();
|
||
std::io::Read::read_to_string(&mut pkg.by_name("word/document.xml").unwrap(), &mut doc_xml).unwrap();
|
||
let doc_xml = doc_xml
|
||
.replace("prst=\"textArchUp\"", "prst=\"textNotAWarp\"")
|
||
.replace("a:stCxn id=\"5\" idx=\"3\"", "a:stCxn id=\"404\" idx=\"99999999999\"");
|
||
let bytes = replace_part(&wordcraft_docx::write(&r).unwrap(), "word/document.xml", doc_xml.as_bytes());
|
||
let h = wordcraft_docx::read(&bytes).unwrap();
|
||
let got = ¶s(&h)[0].objects;
|
||
assert_eq!(extra(&got[0]).warp, None);
|
||
assert_eq!(extra(&got[1]).start, Some(ConnEnd { id: 404, site: wordcraft_doc::connector::MAX_SITE }));
|
||
}
|
||
|
||
/// `zip` with part `name` replaced by `data`.
|
||
fn replace_part(zip_bytes: &[u8], name: &str, data: &[u8]) -> Vec<u8> {
|
||
let mut src = zip::ZipArchive::new(std::io::Cursor::new(zip_bytes)).unwrap();
|
||
let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
|
||
for i in 0..src.len() {
|
||
let mut f = src.by_index(i).unwrap();
|
||
let n = f.name().to_string();
|
||
out.start_file(n.as_str(), zip::write::SimpleFileOptions::default()).unwrap();
|
||
if n == name {
|
||
std::io::Write::write_all(&mut out, data).unwrap();
|
||
} else {
|
||
std::io::copy(&mut f, &mut out).unwrap();
|
||
}
|
||
}
|
||
out.finish().unwrap().into_inner()
|
||
}
|