1. 1//! Creating a file from scratch (docs/design/72-openxml-documents.md,
2. 2//! "Creating from scratch"): each built-in blank is a valid, empty,
3. 3//! deterministic package, and the anchor-free ops fill a new file in one
4. 4//! call, checked by a re-read like every edit.
5. 5
6. 6#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
7. 7
8. 8use std::collections::BTreeMap;
9. 9use std::io::Cursor;
10. 10
11. 11use vak_ooxml::blank::{DECK_LAYOUTS, DOCUMENT_STYLES, WORKBOOK_SHEET, blank};
12. 12use vak_ooxml::edit::{self, CellValue, EditContext, OfficeOp, TextValue};
13. 13use vak_ooxml::read::{self, UnitKind};
14. 14use vak_ooxml::{Format, FormatKind, Limits, Package, Vocabulary, fixtures, review};
15. 15
16. 16fn format(extension: &str) -> Format {
17. 17 Format::from_extension(extension).unwrap()
18. 18}
19. 19
20. 20fn clean() -> EditContext {
21. 21 EditContext {
22. 22 author: "Vakyartha".into(),
23. 23 date: "2026-09-27T10:00:00Z".into(),
24. 24 tracked: false,
25. 25 }
26. 26}
27. 27
28. 28fn create(extension: &str, ops: Vec<OfficeOp>) -> Result<edit::Applied, edit::EditError> {
29. 29 let target = format(extension);
30. 30 edit::apply(
31. 31 &blank(target).unwrap(),
32. 32 &ops,
33. 33 &clean(),
34. 34 Limits::default(),
35. 35 Some(target),
36. 36 )
37. 37}
38. 38
39. 39fn part(bytes: &[u8], name: &str) -> String {
40. 40 let mut package = Package::open(Cursor::new(bytes.to_vec()), Limits::default()).unwrap();
41. 41 String::from_utf8(package.read_part(name).unwrap()).unwrap()
42. 42}
43. 43
44. 44fn paragraph(text: &str, style: Option<&str>) -> OfficeOp {
45. 45 OfficeOp::AddParagraph {
46. 46 text: text.into(),
47. 47 style: style.map(str::to_string),
48. 48 after: None,
49. 49 }
50. 50}
51. 51
52. 52fn text(value: &str) -> CellValue {
53. 53 CellValue::Text(value.into())
54. 54}
55. 55
56. 56#[test]
57. 57fn each_blank_is_an_empty_deterministic_package_of_its_format() {
58. 58 for extension in ["docx", "xlsx", "pptx"] {
59. 59 let bytes = blank(format(extension)).unwrap();
60. 60 assert_eq!(bytes, blank(format(extension)).unwrap(), "{extension}");
61. 61 let document = read::read(Cursor::new(bytes), Limits::default()).unwrap();
62. 62 assert_eq!(document.inspection.format, format(extension), "{extension}");
63. 63 assert!(document.inspection.flags().is_empty(), "{extension}");
64. 64 match extension {
65. 65 "xlsx" => {
66. 66 assert!(document.units.is_empty(), "{:?}", document.units);
67. 67 assert_eq!(document.sections.len(), 1);
68. 68 assert_eq!(document.sections[0].anchor, format!("{WORKBOOK_SHEET}!"));
69. 69 }
70. 70 _ => assert!(
71. 71 document.units.is_empty(),
72. 72 "{extension}: {:?}",
73. 73 document.units
74. 74 ),
75. 75 }
76. 76 }
77. 77}
78. 78
79. 79#[test]
80. 80fn a_blank_is_refused_for_macro_enabled_names_and_visio() {
81. 81 for extension in ["docm", "xlsm", "pptm", "xlam", "ppam"] {
82. 82 let error = blank(format(extension)).unwrap_err();
83. 83 assert!(
84. 84 error.contains("never makes a macro-enabled file"),
85. 85 "{error}"
86. 86 );
87. 87 }
88. 88 let error = blank(format("vsdx")).unwrap_err();
89. 89 assert!(error.contains("Visio"), "{error}");
90. 90}
91. 91
92. 92#[test]
93. 93fn a_word_document_is_written_from_scratch_in_one_call() {
94. 94 let applied = create(
95. 95 "docx",
96. 96 vec![
97. 97 OfficeOp::SetTitle {
98. 98 title: "Q3 review".into(),
99. 99 },
100. 100 paragraph("Q3 review", Some("Title")),
101. 101 paragraph("Prepared for the leadership team", Some("Subtitle")),
102. 102 paragraph("Summary", Some("Heading 1")),
103. 103 paragraph("Revenue grew 12% on the quarter.", None),
104. 104 paragraph("Close the Pune office", Some("List Number")),
105. 105 paragraph("Hire two engineers", Some("List Number")),
106. 106 paragraph("Next steps", Some("Heading 2")),
107. 107 paragraph("Draft the budget", Some("List Number")),
108. 108 paragraph("Review it in October", Some("List Number")),
109. 109 paragraph("Travel is paused", Some("List Bullet")),
110. 110 OfficeOp::AddTable {
111. 111 rows: vec![
112. 112 vec![text("Region"), text("Revenue")],
113. 113 vec![text("North"), CellValue::Number(120.0)],
114. 114 vec![text("South"), CellValue::Number(95.5)],
115. 115 ],
116. 116 after: None,
117. 117 header: None,
118. 118 },
119. 119 paragraph("Figures are unaudited.", Some("Quote")),
120. 120 ],
121. 121 )
122. 122 .unwrap();
123. 123 let document = &applied.document;
124. 124 assert_eq!(document.title.as_deref(), Some("Q3 review"));
125. 125 let texts: Vec<&str> = document
126. 126 .units
127. 127 .iter()
128. 128 .map(|unit| unit.text.as_str())
129. 129 .collect();
130. 130 assert_eq!(
131. 131 texts,
132. 132 [
133. 133 "Q3 review",
134. 134 "Prepared for the leadership team",
135. 135 "Summary",
136. 136 "Revenue grew 12% on the quarter.",
137. 137 "Close the Pune office",
138. 138 "Hire two engineers",
139. 139 "Next steps",
140. 140 "Draft the budget",
141. 141 "Review it in October",
142. 142 "Travel is paused",
143. 143 "Region | Revenue",
144. 144 "North | 120",
145. 145 "South | 95.5",
146. 146 "Figures are unaudited.",
147. 147 ]
148. 148 );
149. 149 let headings: Vec<(&str, u8)> = document
150. 150 .sections
151. 151 .iter()
152. 152 .map(|section| (section.title.as_str(), section.level))
153. 153 .collect();
154. 154 assert_eq!(
155. 155 headings,
156. 156 [("Q3 review", 1), ("Summary", 1), ("Next steps", 2)]
157. 157 );
158. 158 assert_eq!(document.units[10].kind, UnitKind::TableRow);
159. 159 assert_eq!(document.units[10].anchor, "tbl@1/r1");
160. 160 let stat = |name: &str| {
161. 161 document
162. 162 .stats
163. 163 .iter()
164. 164 .find(|(stat, _)| stat == name)
165. 165 .map(|(_, count)| *count)
166. 166 };
167. 167 assert_eq!(stat("tracked changes"), Some(0), "a new document is clean");
168. 168 assert_eq!(stat("tables"), Some(1));
169. 169
170. 170 // Each numbered list starts at 1: each is its own copy of the list
171. 171 // definition, without the original's style link, and the second item
172. 172 // of each list continues its own list.
173. 173 let body = part(&applied.bytes, "word/document.xml");
174. 174 let numbering = part(&applied.bytes, "word/numbering.xml");
175. 175 assert!(
176. 176 numbering.contains(r#"<w:num w:numId="3"><w:abstractNumId w:val="2"/></w:num>"#),
177. 177 "{numbering}"
178. 178 );
179. 179 assert!(
180. 180 numbering.contains(r#"<w:num w:numId="4"><w:abstractNumId w:val="3"/></w:num>"#),
181. 181 "{numbering}"
182. 182 );
183. 183 assert_eq!(
184. 184 numbering
185. 185 .matches(r#"<w:pStyle w:val="ListNumber"/>"#)
186. 186 .count(),
187. 187 1,
188. 188 "{numbering}"
189. 189 );
190. 190 assert!(
191. 191 numbering
192. 192 .find(r#"<w:abstractNum w:abstractNumId="3">"#)
193. 193 .unwrap()
194. 194 < numbering.find(r#"<w:num w:numId="1">"#).unwrap(),
195. 195 "definitions come before instances: {numbering}"
196. 196 );
197. 197 assert_eq!(body.matches(r#"<w:numId w:val="3"/>"#).count(), 2, "{body}");
198. 198 assert_eq!(body.matches(r#"<w:numId w:val="4"/>"#).count(), 2, "{body}");
199. 199 assert!(
200. 200 !body.contains(r#"<w:pStyle w:val="ListBullet"/><w:numPr>"#),
201. 201 "bullets need no list instance"
202. 202 );
203. 203 // The header row repeats on each page and is bold; cells span the text
204. 204 // width of an A4 page with 2.54 cm margins.
205. 205 assert!(body.contains("<w:tblHeader/>"), "{body}");
206. 206 assert!(
207. 207 body.contains(r#"<w:gridCol w:w="4513"/><w:gridCol w:w="4513"/>"#),
208. 208 "{body}"
209. 209 );
210. 210 assert!(
211. 211 !body.contains("<w:ins "),
212. 212 "nothing is tracked in a new document"
213. 213 );
214. 214 // Every op minted anchors a later op could name.
215. 215 assert!(
216. 216 applied
217. 217 .results
218. 218 .iter()
219. 219 .all(|result| result.check.starts_with("passed"))
220. 220 );
221. 221 assert_eq!(
222. 222 applied.results[11].created.len(),
223. 223 6,
224. 224 "{:?}",
225. 225 applied.results[11]
226. 226 );
227. 227}
228. 228
229. 229#[test]
230. 230fn every_style_a_blank_document_offers_can_be_used_by_name() {
231. 231 let ops = DOCUMENT_STYLES
232. 232 .iter()
233. 233 .map(|style| paragraph(&format!("In {style}"), Some(style)))
234. 234 .collect();
235. 235 let applied = create("docx", ops).unwrap();
236. 236 assert_eq!(applied.document.units.len(), DOCUMENT_STYLES.len());
237. 237}
238. 238
239. 239#[test]
240. 240fn a_table_added_to_an_existing_document_is_a_tracked_insertion() {
241. 241 let context = EditContext {
242. 242 tracked: true,
243. 243 ..clean()
244. 244 };
245. 245 let applied = edit::apply(
246. 246 &fixtures::docx(),
247. 247 &[OfficeOp::AddTable {
248. 248 rows: vec![
249. 249 vec![text("Owner"), text("Due")],
250. 250 vec![text("Mira"), text("Friday")],
251. 251 ],
252. 252 after: Some("p@1".into()),
253. 253 header: None,
254. 254 }],
255. 255 &context,
256. 256 Limits::default(),
257. 257 None,
258. 258 )
259. 259 .unwrap();
260. 260 let body = part(&applied.bytes, "word/document.xml");
261. 261 assert!(
262. 262 body.contains(r#"<w:trPr><w:tblHeader/><w:ins w:id="#),
263. 263 "{body}"
264. 264 );
265. 265 let row = applied
266. 266 .document
267. 267 .units
268. 268 .iter()
269. 269 .find(|unit| unit.text.contains("Friday"))
270. 270 .unwrap();
271. 271 assert!(
272. 272 row.text.contains("[inserted by Vakyartha: Friday]"),
273. 273 "{}",
274. 274 row.text
275. 275 );
276. 276 assert_eq!(
277. 277 row.anchor, "tbl@1/r2",
278. 278 "the new table comes before the fixture's own"
279. 279 );
280. 280
281. 281 // A table is never nested in another table's cell.
282. 282 let fixture = read::read(Cursor::new(fixtures::docx()), Limits::default()).unwrap();
283. 283 let cell = fixture
284. 284 .units
285. 285 .iter()
286. 286 .find(|unit| !unit.row_cells.is_empty())
287. 287 .map(|unit| unit.row_cells[0][0].0.clone())
288. 288 .unwrap();
289. 289 let inside = edit::apply(
290. 290 &fixtures::docx(),
291. 291 &[OfficeOp::AddTable {
292. 292 rows: vec![vec![text("x")]],
293. 293 after: Some(cell),
294. 294 header: None,
295. 295 }],
296. 296 &context,
297. 297 Limits::default(),
298. 298 None,
299. 299 )
300. 300 .unwrap_err();
301. 301 assert!(inside.message.contains("is inside a table"), "{inside}");
302. 302}
303. 303
304. 304#[test]
305. 305fn a_workbook_is_built_from_scratch_with_names_formats_and_widths() {
306. 306 let cells: BTreeMap<String, CellValue> = [
307. 307 ("A1", text("Item")),
308. 308 ("B1", text("Q3")),
309. 309 ("C1", text("Q4")),
310. 310 ("A2", text("Rent")),
311. 311 ("B2", CellValue::Number(1200.0)),
312. 312 ("C2", CellValue::Number(1250.5)),
313. 313 ("A3", text("Total")),
314. 314 ("B3", text("=SUM(B2:B2)")),
315. 315 ("C3", text("=SUM(C2:C2)")),
316. 316 ]
317. 317 .into_iter()
318. 318 .map(|(address, value)| (address.to_string(), value))
319. 319 .collect();
320. 320 let applied = create(
321. 321 "xlsx",
322. 322 vec![
323. 323 OfficeOp::RenameSheet {
324. 324 sheet: WORKBOOK_SHEET.into(),
325. 325 name: "Budget".into(),
326. 326 },
327. 327 OfficeOp::SetCells {
328. 328 sheet: "Budget".into(),
329. 329 cells,
330. 330 },
331. 331 OfficeOp::FormatCells {
332. 332 sheet: "Budget".into(),
333. 333 range: "A1:C1".into(),
334. 334 bold: Some(true),
335. 335 italic: None,
336. 336 number_format: None,
337. 337 fill: Some("#D9E2F3".into()),
338. 338 wrap: None,
339. 339 },
340. 340 OfficeOp::FormatCells {
341. 341 sheet: "Budget".into(),
342. 342 range: "B2:C3".into(),
343. 343 bold: None,
344. 344 italic: None,
345. 345 number_format: Some("#,##0.00".into()),
346. 346 fill: None,
347. 347 wrap: None,
348. 348 },
349. 349 OfficeOp::FormatCells {
350. 350 sheet: "Budget".into(),
351. 351 range: "A3:C3".into(),
352. 352 bold: Some(true),
353. 353 italic: None,
354. 354 number_format: None,
355. 355 fill: None,
356. 356 wrap: None,
357. 357 },
358. 358 OfficeOp::FormatCells {
359. 359 sheet: "Budget".into(),
360. 360 range: "D2".into(),
361. 361 bold: None,
362. 362 italic: None,
363. 363 number_format: Some("0.0%".into()),
364. 364 fill: None,
365. 365 wrap: None,
366. 366 },
367. 367 OfficeOp::SetColumnWidths {
368. 368 sheet: "Budget".into(),
369. 369 widths: [
370. 370 ("A".to_string(), 28.0),
371. 371 ("B".to_string(), 14.0),
372. 372 ("C".to_string(), 14.0),
373. 373 ]
374. 374 .into_iter()
375. 375 .collect(),
376. 376 },
377. 377 OfficeOp::AddSheet {
378. 378 name: "Notes".into(),
379. 379 },
380. 380 ],
381. 381 )
382. 382 .unwrap();
383. 383 let sections: Vec<&str> = applied
384. 384 .document
385. 385 .sections
386. 386 .iter()
387. 387 .map(|section| section.anchor.as_str())
388. 388 .collect();
389. 389 assert_eq!(sections, ["Budget!", "Notes!"]);
390. 390 let lines = applied.document.lines().join("\n");
391. 391 assert!(lines.contains("B2: 1200"), "{lines}");
392. 392 assert!(
393. 393 lines.contains("B3: =SUM(B2:B2) [not calculated yet]"),
394. 394 "{lines}"
395. 395 );
396. 396 let styles = part(&applied.bytes, "xl/styles.xml");
397. 397 // #,##0.00 is built in (id 4); 0.0% is declared once, as the first
398. 398 // custom format.
399. 399 assert!(styles.contains(r#"numFmtId="4""#), "{styles}");
400. 400 assert!(
401. 401 styles.contains(
402. 402 r#"<numFmts count="1"><numFmt numFmtId="164" formatCode="0.0%"/></numFmts><fonts"#
403. 403 ),
404. 404 "{styles}"
405. 405 );
406. 406 assert!(styles.contains(r#"<fgColor rgb="FFD9E2F3"/>"#), "{styles}");
407. 407 // B3 is both a total (bold) and a number (#,##0.00): the second format
408. 408 // kept the first.
409. 409 let sheet = part(&applied.bytes, "xl/worksheets/sheet1.xml");
410. 410 assert!(
411. 411 sheet.contains(r#"<cols><col min="1" max="1" width="28" customWidth="1"/>"#),
412. 412 "{sheet}"
413. 413 );
414. 414 let style_of = |cell: &str| {
415. 415 let start = sheet.find(&format!(r#"r="{cell}""#)).unwrap();
416. 416 let tag = &sheet[start..start + sheet[start..].find('>').unwrap()];
417. 417 tag.split("s=\"")
418. 418 .nth(1)
419. 419 .unwrap()
420. 420 .split('"')
421. 421 .next()
422. 422 .unwrap()
423. 423 .to_string()
424. 424 };
425. 425 let b3 = style_of("B3");
426. 426 assert_ne!(b3, style_of("B2"), "B3 is bold as well");
427. 427 assert_ne!(b3, style_of("A3"), "B3 has the number format as well");
428. 428 assert!(
429. 429 applied
430. 430 .results
431. 431 .iter()
432. 432 .all(|result| result.check.starts_with("passed"))
433. 433 );
434. 434}
435. 435
436. 436#[test]
437. 437fn a_sheet_is_not_renamed_while_anything_names_it() {
438. 438 let error = create(
439. 439 "xlsx",
440. 440 vec![
441. 441 OfficeOp::SetCells {
442. 442 sheet: WORKBOOK_SHEET.into(),
443. 443 cells: [
444. 444 ("A1".to_string(), CellValue::Number(2.0)),
445. 445 ("A2".to_string(), text("=Sheet1!A1*2")),
446. 446 ]
447. 447 .into_iter()
448. 448 .collect(),
449. 449 },
450. 450 OfficeOp::RenameSheet {
451. 451 sheet: WORKBOOK_SHEET.into(),
452. 452 name: "Budget".into(),
453. 453 },
454. 454 ],
455. 455 )
456. 456 .unwrap_err();
457. 457 assert_eq!(error.op, Some((1, "rename_sheet")));
458. 458 assert!(
459. 459 error.message.contains("xl/worksheets/sheet1.xml"),
460. 460 "{error}"
461. 461 );
462. 462
463. 463 let error = create(
464. 464 "xlsx",
465. 465 vec![OfficeOp::RenameSheet {
466. 466 sheet: "Missing".into(),
467. 467 name: "Budget".into(),
468. 468 }],
469. 469 )
470. 470 .unwrap_err();
471. 471 assert!(error.message.contains("sheets: Sheet1"), "{error}");
472. 472}
473. 473
474. 474#[test]
475. 475fn a_deck_is_built_from_the_blanks_layouts_with_speaker_notes() {
476. 476 let slide = |layout: &str, placeholders: &[(&str, TextValue)], notes: Option<&str>| {
477. 477 OfficeOp::AddSlideFromLayout {
478. 478 layout: layout.into(),
479. 479 after: None,
480. 480 placeholders: placeholders
481. 481 .iter()
482. 482 .map(|(key, value)| (key.to_string(), value.clone()))
483. 483 .collect(),
484. 484 notes: notes.map(str::to_string),
485. 485 }
486. 486 };
487. 487 let one = |text: &str| TextValue::One(text.into());
488. 488 let lines =
489. 489 |items: &[&str]| TextValue::Lines(items.iter().map(|item| item.to_string()).collect());
490. 490 let applied = create(
491. 491 "pptx",
492. 492 vec![
493. 493 slide(
494. 494 "Title Slide",
495. 495 &[
496. 496 ("title", one("Launch plan")),
497. 497 ("subtitle", one("October 2026")),
498. 498 ],
499. 499 None,
500. 500 ),
501. 501 slide(
502. 502 "Title and Content",
503. 503 &[
504. 504 ("title", one("Goals")),
505. 505 ("body", lines(&["Ship v1", "Sign ten customers"])),
506. 506 ],
507. 507 Some("Keep this short.\nPause for questions."),
508. 508 ),
509. 509 slide(
510. 510 "Section Header",
511. 511 &[("title", one("Timeline")), ("body", one("Q4 milestones"))],
512. 512 None,
513. 513 ),
514. 514 slide(
515. 515 "Two Content",
516. 516 &[
517. 517 ("title", one("Trade-offs")),
518. 518 ("idx:1", lines(&["Faster"])),
519. 519 ("idx:2", lines(&["Riskier"])),
520. 520 ],
521. 521 None,
522. 522 ),
523. 523 slide("Title Only", &[("title", one("Questions?"))], None),
524. 524 slide("Blank", &[], None),
525. 525 OfficeOp::SetTitle {
526. 526 title: "Launch plan".into(),
527. 527 },
528. 528 ],
529. 529 )
530. 530 .unwrap();
531. 531 let document = &applied.document;
532. 532 let titles: Vec<&str> = document
533. 533 .sections
534. 534 .iter()
535. 535 .map(|section| section.title.as_str())
536. 536 .collect();
537. 537 assert_eq!(
538. 538 titles,
539. 539 [
540. 540 "Slide 1: Launch plan",
541. 541 "Slide 2: Goals",
542. 542 "Slide 3: Timeline",
543. 543 "Slide 4: Trade-offs",
544. 544 "Slide 5: Questions?",
545. 545 "Slide 6: Slide 6",
546. 546 ]
547. 547 );
548. 548 let text = document.lines().join("\n");
549. 549 assert!(
550. 550 text.contains("[slide:257/notes] Keep this short. ¶ Pause for questions."),
551. 551 "{text}"
552. 552 );
553. 553 assert!(text.contains("Ship v1 ¶ Sign ten customers"), "{text}");
554. 554 // A text placeholder keeps its type; a content placeholder has none.
555. 555 assert!(
556. 556 part(&applied.bytes, "ppt/slides/slide3.xml").contains(r#"<p:ph type="body" idx="1"/>"#)
557. 557 );
558. 558 assert!(part(&applied.bytes, "ppt/slides/slide2.xml").contains(r#"<p:ph idx="1"/>"#));
559. 559 let notes_rels = part(&applied.bytes, "ppt/notesSlides/_rels/notesSlide1.xml.rels");
560. 560 assert!(
561. 561 notes_rels.contains("../notesMasters/notesMaster1.xml"),
562. 562 "{notes_rels}"
563. 563 );
564. 564 assert!(notes_rels.contains("../slides/slide2.xml"), "{notes_rels}");
565. 565 assert!(
566. 566 part(&applied.bytes, "[Content_Types].xml")
567. 567 .contains(r#"<Override PartName="/ppt/notesSlides/notesSlide1.xml""#)
568. 568 );
569. 569 assert_eq!(DECK_LAYOUTS.len(), 6);
570. 570
571. 571 // set_notes gives a slide without notes its notes page.
572. 572 let with_notes = edit::apply(
573. 573 &applied.bytes,
574. 574 &[OfficeOp::SetNotes {
575. 575 anchor: "slide:256".into(),
576. 576 text: "Welcome everyone.".into(),
577. 577 }],
578. 578 &clean(),
579. 579 Limits::default(),
580. 580 None,
581. 581 )
582. 582 .unwrap();
583. 583 assert!(
584. 584 with_notes
585. 585 .document
586. 586 .lines()
587. 587 .join("\n")
588. 588 .contains("[slide:256/notes] Welcome everyone.")
589. 589 );
590. 590}
591. 591
592. 592#[test]
593. 593fn a_template_name_makes_a_template_from_the_blank() {
594. 594 for (extension, kind) in [
595. 595 ("dotx", FormatKind::Template),
596. 596 ("potx", FormatKind::Template),
597. 597 ("ppsx", FormatKind::Slideshow),
598. 598 ] {
599. 599 let op = match format(extension).vocabulary {
600. 600 Vocabulary::Word => paragraph("Letterhead", Some("Title")),
601. 601 _ => OfficeOp::AddSlideFromLayout {
602. 602 layout: "Title Slide".into(),
603. 603 after: None,
604. 604 placeholders: BTreeMap::new(),
605. 605 notes: None,
606. 606 },
607. 607 };
608. 608 let applied = create(extension, vec![op]).unwrap();
609. 609 assert_eq!(applied.document.inspection.format.kind, kind, "{extension}");
610. 610 }
611. 611}
612. 612
613. 613#[test]
614. 614fn a_from_scratch_draft_is_offered_change_by_change() {
615. 615 let source = blank(format("docx")).unwrap();
616. 616 let ops = vec![
617. 617 paragraph("Summary", Some("Heading 1")),
618. 618 OfficeOp::AddTable {
619. 619 rows: vec![vec![text("A"), text("B")]],
620. 620 after: None,
621. 621 header: None,
622. 622 },
623. 623 // Written against a read of the first draft: after the table's
624. 624 // second cell paragraph, which op 2 minted.
625. 625 OfficeOp::AddParagraph {
626. 626 text: "In the cell".into(),
627. 627 style: None,
628. 628 after: Some("p:1A000003".into()),
629. 629 },
630. 630 paragraph("Closing line", None),
631. 631 ];
632. 632 let full = edit::apply(&source, &ops, &clean(), Limits::default(), None).unwrap();
633. 633 let offered = review::choices(
634. 634 &source,
635. 635 &ops,
636. 636 &clean(),
637. 637 Limits::default(),
638. 638 None,
639. 639 &full.document,
640. 640 )
641. 641 .unwrap();
642. 642 let requires: Vec<Vec<String>> = offered
643. 643 .iter()
644. 644 .map(|choice| choice.requires.clone())
645. 645 .collect();
646. 646 assert_eq!(requires, [vec![], vec![], vec!["1".to_string()], vec![]]);
647. 647 assert_eq!(offered[0].label, "New paragraph: Summary");
648. 648 assert_eq!(offered[1].label, "New table, 1 row by 2 columns");
649. 649
650. 650 // Leaving the heading out still puts the cell paragraph in the table's
651. 651 // second cell: the replay remaps the anchors it mints.
652. 652 let narrowed = review::narrow(
653. 653 &source,
654. 654 &ops,
655. 655 &["1".into(), "2".into(), "3".into()],
656. 656 &clean(),
657. 657 Limits::default(),
658. 658 None,
659. 659 &full.document,
660. 660 )
661. 661 .unwrap();
662. 662 let kept = narrowed.document.lines().join("\n");
663. 663 assert!(!kept.contains("Summary"), "{kept}");
664. 664 assert!(
665. 665 kept.contains("[p:1A000002] B [p:1A000003] In the cell"),
666. 666 "{kept}"
667. 667 );
668. 668
669. 669 let excel_source = blank(format("xlsx")).unwrap();
670. 670 let excel_ops = vec![
671. 671 OfficeOp::RenameSheet {
672. 672 sheet: "Sheet1".into(),
673. 673 name: "Budget".into(),
674. 674 },
675. 675 OfficeOp::SetCells {
676. 676 sheet: "Budget".into(),
677. 677 cells: [("A1".to_string(), text("Rent"))].into_iter().collect(),
678. 678 },
679. 679 ];
680. 680 let excel = edit::apply(&excel_source, &excel_ops, &clean(), Limits::default(), None).unwrap();
681. 681 let offered = review::choices(
682. 682 &excel_source,
683. 683 &excel_ops,
684. 684 &clean(),
685. 685 Limits::default(),
686. 686 None,
687. 687 &excel.document,
688. 688 )
689. 689 .unwrap();
690. 690 assert_eq!(
691. 691 offered[1].requires,
692. 692 ["0"],
693. 693 "a cell on the renamed sheet needs the rename"
694. 694 );
695. 695}
696. 696