adminandClaude Fable 5
c8f22b091f
Chẩn đoán trên file thật (Word xuất): tiêu đề 2 dòng bị cắt thành 41 run per-word/per-char xen run rỗng kích thước 0, cỡ 22.5pt + 20pt trộn nhau, bbox chữ có dấu (Ạ, Ợ) tụt thấp hơn hẳn chữ thường. UI (main.js): - clusterTextLines: gom run thành DÒNG theo GIAO DỌC ≥50% chiều cao nhỏ (miễn nhiễm dấu tiếng Việt) + tách cột theo hở ngang; gắn run rỗng vào dòng chứa nó. Overlay vẽ 1 khung/DÒNG (file thật: 231 ô vụn → 18 khung); chọn/kéo/xoá/đổi thuộc tính tác động CẢ DÒNG (batch ops, editSelRuns) - paragraphLines mới trên nền cluster: dòng kề nhau (hở ≤1.3× chiều cao), giao ngang ≥30%, cỡ chữ ≤1.8× (tiêu đề 22.5/20pt vẫn 1 đoạn), khoá nhịp ±35% - Đúp LUÔN mở ô sửa CẢ ĐOẠN, mỗi dòng gốc = 1 dòng textarea (giữ và sửa được cả xuống dòng); đúp trúng KHE giữa các từ vẫn mở (hit-test theo điểm trên overlay); click/chọn chữ trong ô sửa di chuyển con trỏ, KHÔNG thoát edit (stopPropagation + guard .edit-inline ở onEditStageClick); ô che kín chữ cũ, line-height đúng nhịp dòng, scrollIntoView Engine (edit.rs ReflowText): - TỰ NỞ danh sách run: mọi text object có tâm trong union bbox (+2pt) của các run được đưa đều bị thay — không bao giờ sót run rỗng/lệch bbox → hết cảnh chữ mới chồng chữ cũ - Phát hiện khối CĂN GIỮA (tâm mọi dòng ≈ tâm khối, có dòng thụt trái) → dòng mới đặt x = tâm khối − w/2 (đo hmtx) — tiêu đề căn giữa giữ căn giữa Kiểm chứng với file thật (cục bộ): 39 run tiêu đề xoá sạch 0 mảnh sót, 2 dòng mới căn giữa lệch tâm trang <5pt, extract sạch chữ cũ; grouping đúng khi đúp mọi từ của cả 2 dòng lẫn header 8pt per-char. Test: 2 test hồi quy mới (nở indices bắt run giữa bị sót; giữ căn giữa đo bằng fixture tự căn) → edit 19/19, toàn bộ engine 75/75 ngoài qpdf-fixture. Docs: 12 (mục vá theo phản hồi), 13 (E34–E38). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HgnbPwSoRGNH7LHsDUmRpk
911 lines
31 KiB
Rust
911 lines
31 KiB
Rust
//! Round-trip test cho chỉnh sửa nội dung (Phase 4 — moat chính): liệt kê
|
||
//! object, sửa text (gồm tiếng Việt), xoá, di chuyển, thêm chữ/ảnh. Đường GHI
|
||
//! file rủi ro nhất nên thao tác rồi đọc lại để so khớp.
|
||
//!
|
||
//! Lưu ý bẫy mutex PDFium (đã ghi memory): mọi assert chạy SAU khi ff_engine
|
||
//! đã trả về (doc đã drop), nên panic assert không poison mutex toàn cục.
|
||
|
||
use std::path::PathBuf;
|
||
|
||
use ff_engine::{EditOp, ObjectKind};
|
||
|
||
fn workspace_root() -> PathBuf {
|
||
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||
.join("..")
|
||
.join("..")
|
||
.canonicalize()
|
||
.expect("workspace root")
|
||
}
|
||
|
||
fn pdfium() -> pdfium_render::prelude::Pdfium {
|
||
if std::env::var("FOFREEXIT_PDFIUM_PATH").is_err() {
|
||
std::env::set_var("FOFREEXIT_PDFIUM_PATH", workspace_root());
|
||
}
|
||
ff_engine::bind_pdfium().expect("nạp PDFium")
|
||
}
|
||
|
||
fn sample() -> PathBuf {
|
||
workspace_root().join("corpus").join("sample-multipage.pdf")
|
||
}
|
||
|
||
fn tmp(name: &str) -> PathBuf {
|
||
let p = std::env::temp_dir().join(name);
|
||
let _ = std::fs::remove_file(&p);
|
||
p
|
||
}
|
||
|
||
/// Index của text object đầu tiên trên trang 0 có nội dung chứa `needle`.
|
||
fn find_text_index(pdf: &pdfium_render::prelude::Pdfium, input: &std::path::Path, needle: &str) -> u16 {
|
||
let objs = ff_engine::list_objects(pdf, input, 0, None).expect("list_objects");
|
||
objs.into_iter()
|
||
.find(|o| o.kind == ObjectKind::Text && o.text.as_deref().map(|t| t.contains(needle)).unwrap_or(false))
|
||
.unwrap_or_else(|| panic!("không tìm thấy text object chứa {needle:?}"))
|
||
.index
|
||
}
|
||
|
||
#[test]
|
||
fn list_objects_finds_page_text() {
|
||
let pdf = pdfium();
|
||
let objs = ff_engine::list_objects(&pdf, &sample(), 0, None).expect("list_objects");
|
||
assert!(!objs.is_empty(), "trang 0 phải có object");
|
||
let has_text = objs
|
||
.iter()
|
||
.any(|o| o.kind == ObjectKind::Text && o.text.as_deref().map(|t| t.contains("Page one") || t.contains("FoFreeXit")).unwrap_or(false));
|
||
assert!(has_text, "phải thấy text object của trang 1: {objs:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn set_text_replaces_run_content() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_settext.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "Edited line ABC".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits SetText");
|
||
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("Edited line ABC"), "phải có text mới: {text:?}");
|
||
assert!(!text.contains("Page one content alpha"), "text cũ phải biến mất: {text:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn set_text_vietnamese_round_trips() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_vi.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
let vi = "Sửa: nội dung Tiếng Việt";
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: vi.into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits SetText VI");
|
||
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("Tiếng Việt"), "tiếng Việt phải đúng dấu: {text:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn delete_object_reduces_count() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_delete.pdf");
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list").len();
|
||
assert!(before >= 1);
|
||
|
||
ff_engine::apply_edits(&pdf, &input, 0, &[EditOp::Delete { index: 0 }], &out, None)
|
||
.expect("apply_edits Delete");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out").len();
|
||
assert_eq!(after, before - 1, "xoá 1 object phải giảm đúng 1");
|
||
}
|
||
|
||
#[test]
|
||
fn transform_translate_moves_object() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_move.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list");
|
||
let orig_left = before.iter().find(|o| o.index == idx).expect("obj").rect.left;
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::Transform { index: idx, dx: 50.0, dy: 0.0, sx: 1.0, sy: 1.0 }],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits Transform");
|
||
|
||
// Object đã dịch giữ nguyên thứ tự index (không xoá/thêm) → so cùng index.
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let new_left = after.iter().find(|o| o.index == idx).expect("obj out").rect.left;
|
||
assert!((new_left - (orig_left + 50.0)).abs() < 2.0, "left phải dịch ~+50: {orig_left} -> {new_left}");
|
||
}
|
||
|
||
#[test]
|
||
fn add_text_appears_in_extract() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_addtext.pdf");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::AddText {
|
||
x: 100.0,
|
||
y: 100.0,
|
||
text: "ADDEDXYZ".into(),
|
||
font_size: 14.0,
|
||
color: [10, 20, 30, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits AddText");
|
||
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("ADDEDXYZ"), "text thêm mới phải xuất hiện: {text:?}");
|
||
}
|
||
|
||
/// CHUẨN FOXIT (iteration 2): sửa text ASCII trên font base-14 (Helvetica,
|
||
/// không nhúng) phải GIỮ NGUYÊN BaseFont — không đổi font. Text mới cố ý dùng
|
||
/// ký tự ngoài text cũ để không "ăn may" qua luật charset-subset.
|
||
#[test]
|
||
fn set_text_keeps_original_font() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_keepfont.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list");
|
||
let font_before = before
|
||
.iter()
|
||
.find(|o| o.index == idx)
|
||
.and_then(|o| o.font_name.clone())
|
||
.expect("font gốc");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "Fixed by editor 2026 JQXZ!".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits SetText");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let edited = after
|
||
.iter()
|
||
.find(|o| o.text.as_deref().map(|t| t.contains("JQXZ")).unwrap_or(false))
|
||
.expect("run đã sửa");
|
||
assert_eq!(
|
||
edited.font_name.as_deref(),
|
||
Some(font_before.as_str()),
|
||
"sửa text ASCII phải GIỮ NGUYÊN font (chuẩn Foxit)"
|
||
);
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("Fixed by editor"), "text mới phải có mặt: {text:?}");
|
||
}
|
||
|
||
/// Tiếng Việt trên font base-14 (KHÔNG có glyph Việt ở bất kỳ đâu để giữ):
|
||
/// phải thay bằng font hệ thống CÙNG HỌ metric-compatible (Helvetica→Arial/
|
||
/// LiberationSans), tuyệt đối không rơi bừa về font generic.
|
||
#[test]
|
||
fn vietnamese_on_base14_uses_matched_family() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_vnmatch.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "Thay thế hoàn chỉnh".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits VI");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let edited = after
|
||
.iter()
|
||
.find(|o| o.text.as_deref().map(|t| t.contains("hoàn chỉnh")).unwrap_or(false))
|
||
.expect("run đã sửa");
|
||
let font = edited.font_name.clone().unwrap_or_default();
|
||
#[cfg(not(any(windows, target_os = "macos")))]
|
||
assert!(
|
||
font.contains("Liberation"),
|
||
"Helvetica+VI phải match LiberationSans (metric-compatible), được {font:?}"
|
||
);
|
||
#[cfg(windows)]
|
||
assert!(font.to_lowercase().contains("arial"), "Helvetica+VI phải match Arial, được {font:?}");
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("hoàn chỉnh"), "tiếng Việt đúng dấu: {text:?}");
|
||
}
|
||
|
||
/// Case quan trọng nhất với tài liệu Việt thực tế: font NHÚNG đầy đủ glyph →
|
||
/// sửa sang nội dung Việt hoàn toàn khác phải GIỮ NGUYÊN font nhúng (sửa tại
|
||
/// chỗ, không tạo lại bằng font khác).
|
||
#[test]
|
||
fn set_text_preserves_embedded_font_vietnamese() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let step1 = tmp("ff_edit_emb1.pdf");
|
||
let step2 = tmp("ff_edit_emb2.pdf");
|
||
|
||
// B1: tạo run với font nhúng FULL (AddText nhúng nguyên font hệ thống).
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::AddText {
|
||
x: 60.0,
|
||
y: 300.0,
|
||
text: "Chào FoFreeXit".into(),
|
||
font_size: 18.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
}],
|
||
&step1,
|
||
None,
|
||
)
|
||
.expect("add embedded run");
|
||
let idx = find_text_index(&pdf, &step1, "Chào");
|
||
let mid = ff_engine::list_objects(&pdf, &step1, 0, None).expect("list mid");
|
||
let run = mid.iter().find(|o| o.index == idx).expect("run");
|
||
assert_eq!(run.font_embedded, Some(true), "fixture phải là font nhúng");
|
||
let font_before = run.font_name.clone().expect("tên font nhúng");
|
||
|
||
// B2: sửa sang câu Việt khác hẳn → phải giữ nguyên font nhúng.
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&step1,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "Đã kiểm định — sửa giữ font nhúng".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&step2,
|
||
None,
|
||
)
|
||
.expect("edit embedded run");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &step2, 0, None).expect("list out");
|
||
let edited = after
|
||
.iter()
|
||
.find(|o| o.text.as_deref().map(|t| t.contains("kiểm định")).unwrap_or(false))
|
||
.expect("run đã sửa");
|
||
assert_eq!(
|
||
edited.font_name.as_deref(),
|
||
Some(font_before.as_str()),
|
||
"font NHÚNG phải được giữ nguyên khi sửa tiếng Việt"
|
||
);
|
||
let text = ff_engine::extract_text(&pdf, &step2, 0, None).expect("extract");
|
||
assert!(text.contains("sửa giữ font nhúng"), "text round-trip: {text:?}");
|
||
}
|
||
|
||
/// Đổi CỠ CHỮ (không đổi nội dung) phải giữ nguyên font + text, cỡ mới đúng
|
||
/// theo nghĩa hiển thị và vị trí neo (left) không trôi.
|
||
#[test]
|
||
fn font_size_change_keeps_font_and_anchors() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_size.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list");
|
||
let orig = before.iter().find(|o| o.index == idx).expect("obj").clone();
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: orig.text.clone().unwrap_or_default(),
|
||
font_size: Some(30.0),
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits size");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let got = after.iter().find(|o| o.index == idx).expect("obj out");
|
||
assert_eq!(got.font_name, orig.font_name, "đổi cỡ không được đổi font");
|
||
assert_eq!(got.text, orig.text, "đổi cỡ không được đổi nội dung");
|
||
let sz = got.font_size.expect("size");
|
||
assert!((sz - 30.0).abs() < 0.5, "cỡ hiển thị phải ≈30, được {sz}");
|
||
assert!(
|
||
(got.rect.left - orig.rect.left).abs() < 2.0,
|
||
"điểm neo trái không được trôi: {} -> {}",
|
||
orig.rect.left,
|
||
got.rect.left
|
||
);
|
||
}
|
||
|
||
/// Hồi quy bug phóng đại kép: text có matrix scale (Tf nhỏ × matrix lớn) —
|
||
/// đặt cỡ hiển thị 20pt phải ra đúng ~20pt, không nhân đôi theo matrix.
|
||
#[test]
|
||
fn font_size_change_respects_matrix_scale() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let step1 = tmp("ff_edit_mtx1.pdf");
|
||
let step2 = tmp("ff_edit_mtx2.pdf");
|
||
let step3 = tmp("ff_edit_mtx3.pdf");
|
||
|
||
// Tạo run 16pt rồi scale ×2 qua Transform → cỡ hiển thị 32pt, matrix scale 2.
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::AddText {
|
||
x: 80.0,
|
||
y: 200.0,
|
||
text: "MATRIXCASE".into(),
|
||
font_size: 16.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
}],
|
||
&step1,
|
||
None,
|
||
)
|
||
.expect("add");
|
||
let idx = find_text_index(&pdf, &step1, "MATRIXCASE");
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&step1,
|
||
0,
|
||
&[EditOp::Transform { index: idx, dx: 0.0, dy: 0.0, sx: 2.0, sy: 2.0 }],
|
||
&step2,
|
||
None,
|
||
)
|
||
.expect("scale");
|
||
let mid = ff_engine::list_objects(&pdf, &step2, 0, None).expect("list mid");
|
||
let scaled = mid.iter().find(|o| o.index == idx).and_then(|o| o.font_size).expect("size mid");
|
||
assert!((scaled - 32.0).abs() < 1.0, "sau scale ×2 phải ~32pt, được {scaled}");
|
||
|
||
// Đặt cỡ hiển thị 20 — phải ra ~20 (bug cũ: tạo Tf=20 rồi nhân matrix 2 → 40).
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&step2,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "MATRIXCASE".into(),
|
||
font_size: Some(20.0),
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
}],
|
||
&step3,
|
||
None,
|
||
)
|
||
.expect("resize");
|
||
let fin = ff_engine::list_objects(&pdf, &step3, 0, None).expect("list fin");
|
||
let got = fin.iter().find(|o| o.index == idx).and_then(|o| o.font_size).expect("size fin");
|
||
assert!((got - 20.0).abs() < 0.5, "cỡ hiển thị phải ≈20, được {got}");
|
||
}
|
||
|
||
/// Ép ĐẬM qua override: font phải đổi sang biến thể đậm (khác font gốc) nhưng
|
||
/// nội dung (kể cả tiếng Việt) round-trip nguyên vẹn.
|
||
#[test]
|
||
fn bold_override_substitutes_font_and_keeps_text() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_bold.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list");
|
||
let font_before = before
|
||
.iter()
|
||
.find(|o| o.index == idx)
|
||
.and_then(|o| o.font_name.clone())
|
||
.expect("font gốc");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::SetText {
|
||
index: idx,
|
||
text: "Chữ đậm kiểm thử".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: Some(true),
|
||
italic: None,
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits bold");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let edited = after
|
||
.iter()
|
||
.find(|o| o.text.as_deref().map(|t| t.contains("đậm")).unwrap_or(false))
|
||
.expect("run đã sửa");
|
||
assert_ne!(
|
||
edited.font_name.as_deref(),
|
||
Some(font_before.as_str()),
|
||
"ép đậm phải chuyển sang biến thể font khác"
|
||
);
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
assert!(text.contains("Chữ đậm kiểm thử"), "text round-trip: {text:?}");
|
||
}
|
||
|
||
/// Luồng UI "sửa cả dòng": 1 batch = SetText(run đầu, text gộp) + Delete(các
|
||
/// run còn lại). Chốt hành vi: text mới có mặt, các run kia biến mất, tổng
|
||
/// object giảm đúng số run bị gộp.
|
||
#[test]
|
||
fn line_merge_batch_set_text_plus_delete() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let step1 = tmp("ff_edit_line1.pdf");
|
||
let step2 = tmp("ff_edit_line2.pdf");
|
||
|
||
// Dựng "1 dòng bị cắt làm 2 run" bằng 2 AddText cạnh nhau.
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[
|
||
EditOp::AddText {
|
||
x: 60.0,
|
||
y: 260.0,
|
||
text: "Nửa đầu".into(),
|
||
font_size: 14.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
},
|
||
EditOp::AddText {
|
||
x: 130.0,
|
||
y: 260.0,
|
||
text: "nửa sau".into(),
|
||
font_size: 14.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
},
|
||
],
|
||
&step1,
|
||
None,
|
||
)
|
||
.expect("dựng 2 run");
|
||
|
||
let objs = ff_engine::list_objects(&pdf, &step1, 0, None).expect("list");
|
||
let first = find_text_index(&pdf, &step1, "Nửa đầu");
|
||
let second = find_text_index(&pdf, &step1, "nửa sau");
|
||
let count_before = objs.len();
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&step1,
|
||
0,
|
||
&[
|
||
EditOp::SetText {
|
||
index: first,
|
||
text: "Cả dòng đã gộp và sửa".into(),
|
||
font_size: None,
|
||
color: None,
|
||
font_family: None,
|
||
bold: None,
|
||
italic: None,
|
||
},
|
||
EditOp::Delete { index: second },
|
||
],
|
||
&step2,
|
||
None,
|
||
)
|
||
.expect("batch gộp dòng");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &step2, 0, None).expect("list out");
|
||
assert_eq!(after.len(), count_before - 1, "gộp 2 run còn 1 → tổng giảm 1");
|
||
let text = ff_engine::extract_text(&pdf, &step2, 0, None).expect("extract");
|
||
assert!(text.contains("Cả dòng đã gộp và sửa"), "text gộp phải có: {text:?}");
|
||
assert!(!text.contains("nửa sau"), "run bị gộp phải biến mất: {text:?}");
|
||
}
|
||
|
||
/// Dựng "đoạn văn" 3 dòng bằng font nhúng (AddText) tại x=60, baseline cách 15pt.
|
||
fn make_paragraph_fixture(pdf: &pdfium_render::prelude::Pdfium, out: &std::path::Path) {
|
||
let mk = |x: f32, y: f32, s: &str| EditOp::AddText {
|
||
x,
|
||
y,
|
||
text: s.into(),
|
||
font_size: 12.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
};
|
||
ff_engine::apply_edits(
|
||
pdf,
|
||
&sample(),
|
||
0,
|
||
&[
|
||
mk(60.0, 500.0, "Dòng một của đoạn văn mẫu"),
|
||
mk(60.0, 485.0, "dòng hai nối tiếp nội dung"),
|
||
mk(60.0, 470.0, "dòng ba kết thúc đoạn."),
|
||
],
|
||
out,
|
||
None,
|
||
)
|
||
.expect("dựng đoạn 3 dòng");
|
||
}
|
||
|
||
/// Index (và ObjectInfo) các run thuộc đoạn fixture (baseline 470–500).
|
||
fn paragraph_runs(pdf: &pdfium_render::prelude::Pdfium, path: &std::path::Path) -> Vec<ff_engine::ObjectInfo> {
|
||
ff_engine::list_objects(pdf, path, 0, None)
|
||
.expect("list")
|
||
.into_iter()
|
||
.filter(|o| {
|
||
o.kind == ObjectKind::Text && o.rect.bottom > 455.0 && o.rect.bottom < 505.0 && o.rect.left > 50.0
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// REFLOW (iteration 3): text dài hơn hẳn → tự bẻ thành NHIỀU dòng hơn, mọi
|
||
/// dòng nằm trong bề rộng khối, GIỮ NGUYÊN font nhúng + baseline spacing 15pt.
|
||
#[test]
|
||
fn reflow_wraps_and_keeps_embedded_font() {
|
||
let pdf = pdfium();
|
||
let fx = tmp("ff_reflow_fx.pdf");
|
||
let out = tmp("ff_reflow_out.pdf");
|
||
make_paragraph_fixture(&pdf, &fx);
|
||
let runs = paragraph_runs(&pdf, &fx);
|
||
assert_eq!(runs.len(), 3, "fixture phải có 3 dòng");
|
||
let font_before = runs[0].font_name.clone().expect("font fixture");
|
||
let left = runs.iter().map(|r| r.rect.left).fold(f32::INFINITY, f32::min);
|
||
let right = runs.iter().map(|r| r.rect.right).fold(f32::NEG_INFINITY, f32::max);
|
||
let width = right - left;
|
||
|
||
let long_text = "Nội dung hoàn toàn mới và dài hơn hẳn bản gốc, đủ nhiều từ tiếng Việt \
|
||
để buộc thuật toán reflow phải bẻ lại thành nhiều dòng khác nhau trong đúng bề rộng \
|
||
của khối đoạn văn ban đầu, giữ nguyên phông chữ nhúng và khoảng cách dòng.";
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&fx,
|
||
0,
|
||
&[EditOp::ReflowText { indices: runs.iter().map(|r| r.index).collect(), text: long_text.into() }],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("reflow");
|
||
|
||
// Run mới = mọi text object chứa mảnh của text dài (reflow kéo dài xuống dưới
|
||
// ngoài cửa sổ baseline của fixture nên không dùng paragraph_runs).
|
||
let new_runs: Vec<_> = ff_engine::list_objects(&pdf, &out, 0, None)
|
||
.expect("list out")
|
||
.into_iter()
|
||
.filter(|o| {
|
||
o.kind == ObjectKind::Text
|
||
&& o.text.as_deref().map(|t| long_text.contains(t.trim()) && !t.trim().is_empty()).unwrap_or(false)
|
||
})
|
||
.collect();
|
||
assert!(new_runs.len() > 3, "text dài phải bẻ thành >3 dòng, được {}", new_runs.len());
|
||
for r in &new_runs {
|
||
assert_eq!(r.font_name.as_deref(), Some(font_before.as_str()), "reflow phải giữ font nhúng");
|
||
assert!(r.rect.left >= left - 2.0, "dòng không được tràn trái");
|
||
assert!(r.rect.right <= left + width + width * 0.05 + 3.0, "dòng không được tràn phải: right={} limit={}", r.rect.right, left + width);
|
||
}
|
||
// Baseline cách đều 15pt.
|
||
let mut bottoms: Vec<f32> = new_runs.iter().map(|r| r.rect.bottom).collect();
|
||
bottoms.sort_by(|a, b| b.partial_cmp(a).unwrap());
|
||
for w in bottoms.windows(2) {
|
||
let d = w[0] - w[1];
|
||
assert!((d - 15.0).abs() < 2.0, "khoảng baseline phải ~15pt, được {d}");
|
||
}
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
let norm = text.split_whitespace().collect::<Vec<_>>().join(" ");
|
||
assert!(norm.contains("thuật toán reflow"), "nội dung round-trip: {norm:?}");
|
||
assert!(!norm.contains("Dòng một của đoạn"), "text cũ phải biến mất");
|
||
}
|
||
|
||
/// `\n` trong text reflow = ngắt dòng cứng (đoạn mới).
|
||
#[test]
|
||
fn reflow_hard_break_creates_new_line() {
|
||
let pdf = pdfium();
|
||
let fx = tmp("ff_reflow_hb_fx.pdf");
|
||
let out = tmp("ff_reflow_hb_out.pdf");
|
||
make_paragraph_fixture(&pdf, &fx);
|
||
let runs = paragraph_runs(&pdf, &fx);
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&fx,
|
||
0,
|
||
&[EditOp::ReflowText {
|
||
indices: runs.iter().map(|r| r.index).collect(),
|
||
text: "Đoạn một ngắn.\nĐoạn hai riêng.".into(),
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("reflow hard break");
|
||
|
||
let new_runs: Vec<_> = ff_engine::list_objects(&pdf, &out, 0, None)
|
||
.expect("list out")
|
||
.into_iter()
|
||
.filter(|o| o.text.as_deref().map(|t| t.contains("Đoạn")).unwrap_or(false))
|
||
.collect();
|
||
assert_eq!(new_runs.len(), 2, "2 đoạn = 2 dòng riêng");
|
||
let d = (new_runs[0].rect.bottom - new_runs[1].rect.bottom).abs();
|
||
assert!((d - 15.0).abs() < 2.0, "2 dòng cách đúng nhịp baseline: {d}");
|
||
}
|
||
|
||
/// Reflow trên font base-14 (Helvetica, không nhúng) + text ASCII: các dòng
|
||
/// mới dùng font CHUẨN PDF — BaseFont vẫn là Helvetica, file không phình.
|
||
#[test]
|
||
fn reflow_base14_ascii_keeps_standard_font() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_reflow_b14.pdf");
|
||
let idx = find_text_index(&pdf, &input, "Page one");
|
||
|
||
let long_ascii = "This replacement paragraph is intentionally much longer than the \
|
||
original single line so the reflow engine must wrap it into several lines while keeping \
|
||
the declared standard Helvetica base font untouched.";
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::ReflowText { indices: vec![idx], text: long_ascii.into() }],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("reflow base14");
|
||
|
||
let new_runs: Vec<_> = ff_engine::list_objects(&pdf, &out, 0, None)
|
||
.expect("list out")
|
||
.into_iter()
|
||
.filter(|o| o.text.as_deref().map(|t| long_ascii.contains(t.trim()) && !t.trim().is_empty()).unwrap_or(false))
|
||
.collect();
|
||
assert!(new_runs.len() >= 2, "text dài phải bẻ ≥2 dòng, được {}", new_runs.len());
|
||
for r in &new_runs {
|
||
let f = r.font_name.clone().unwrap_or_default();
|
||
assert!(f.contains("Helvetica"), "BaseFont phải giữ Helvetica chuẩn, được {f:?}");
|
||
}
|
||
// Extract chèn ngắt dòng tại điểm wrap → chuẩn hoá khoảng trắng trước khi so.
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
let norm = text.split_whitespace().collect::<Vec<_>>().join(" ");
|
||
assert!(norm.contains("standard Helvetica base font untouched"), "round-trip: {norm:?}");
|
||
}
|
||
|
||
/// Engine tự NỞ danh sách run theo bbox khối: dòng bị cắt làm 3 run, UI chỉ
|
||
/// gửi run ĐẦU + CUỐI (sót run giữa — như run rỗng/lệch bbox của Word) —
|
||
/// run giữa vẫn bị thay sạch, không còn chữ cũ đè dưới chữ mới.
|
||
#[test]
|
||
fn reflow_expands_indices_to_cover_block() {
|
||
let pdf = pdfium();
|
||
let fx = tmp("ff_reflow_exp_fx.pdf");
|
||
let out = tmp("ff_reflow_exp_out.pdf");
|
||
let mk = |x: f32, s: &str| EditOp::AddText {
|
||
x,
|
||
y: 400.0,
|
||
text: s.into(),
|
||
font_size: 14.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
};
|
||
// 1 dòng thị giác bị cắt thành 3 run sát nhau (kiểu Word).
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&sample(),
|
||
0,
|
||
&[mk(60.0, "Mảnh một"), mk(125.0, "mảnh hai"), mk(188.0, "mảnh ba.")],
|
||
&fx,
|
||
None,
|
||
)
|
||
.expect("fixture 3 mảnh");
|
||
let first = find_text_index(&pdf, &fx, "Mảnh một");
|
||
let third = find_text_index(&pdf, &fx, "mảnh ba");
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&fx,
|
||
0,
|
||
&[EditOp::ReflowText { indices: vec![first, third], text: "Dòng đã thay hoàn toàn".into() }],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("reflow partial");
|
||
|
||
let text = ff_engine::extract_text(&pdf, &out, 0, None).expect("extract");
|
||
let norm = text.split_whitespace().collect::<Vec<_>>().join(" ");
|
||
assert!(norm.contains("Dòng đã thay hoàn toàn"), "text mới: {norm:?}");
|
||
assert!(!norm.contains("mảnh hai"), "run GIỮA bị sót phải được nở vào và xoá: {norm:?}");
|
||
assert!(!norm.contains("Mảnh một"), "run đã đưa phải bị thay: {norm:?}");
|
||
}
|
||
|
||
/// Khối gốc CĂN GIỮA (dòng ngắn thụt vào, tâm trùng nhau) → các dòng mới cũng
|
||
/// đặt căn giữa theo tâm khối (không dồn hết về lề trái).
|
||
#[test]
|
||
fn reflow_preserves_centered_alignment() {
|
||
let pdf = pdfium();
|
||
let probe = tmp("ff_center_probe.pdf");
|
||
let fx = tmp("ff_center_fx.pdf");
|
||
let out = tmp("ff_center_out.pdf");
|
||
let mk = |x: f32, y: f32, s: &str| EditOp::AddText {
|
||
x,
|
||
y,
|
||
text: s.into(),
|
||
font_size: 16.0,
|
||
color: [0, 0, 0, 255],
|
||
font_family: None,
|
||
bold: false,
|
||
italic: false,
|
||
};
|
||
// Đo bề rộng thật 2 dòng để dựng fixture căn giữa quanh tâm 300.
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&sample(),
|
||
0,
|
||
&[mk(10.0, 500.0, "TIÊU ĐỀ DÀI Ở DÒNG TRÊN"), mk(10.0, 460.0, "DÒNG DƯỚI NGẮN")],
|
||
&probe,
|
||
None,
|
||
)
|
||
.expect("probe");
|
||
let objs = ff_engine::list_objects(&pdf, &probe, 0, None).expect("list probe");
|
||
let w = |needle: &str| {
|
||
let o = objs
|
||
.iter()
|
||
.find(|o| o.text.as_deref().map(|t| t.contains(needle)).unwrap_or(false))
|
||
.expect(needle);
|
||
o.rect.right - o.rect.left
|
||
};
|
||
let (w1, w2) = (w("DÒNG TRÊN"), w("DÒNG DƯỚI"));
|
||
let cx = 300.0;
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&sample(),
|
||
0,
|
||
&[
|
||
mk(cx - w1 / 2.0, 500.0, "TIÊU ĐỀ DÀI Ở DÒNG TRÊN"),
|
||
mk(cx - w2 / 2.0, 480.0, "DÒNG DƯỚI NGẮN"),
|
||
],
|
||
&fx,
|
||
None,
|
||
)
|
||
.expect("fixture centered");
|
||
let idxs: Vec<u16> = ff_engine::list_objects(&pdf, &fx, 0, None)
|
||
.expect("list fx")
|
||
.into_iter()
|
||
.filter(|o| o.text.as_deref().map(|t| t.contains("DÒNG")).unwrap_or(false))
|
||
.map(|o| o.index)
|
||
.collect();
|
||
assert_eq!(idxs.len(), 2);
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&fx,
|
||
0,
|
||
&[EditOp::ReflowText {
|
||
indices: idxs,
|
||
text: "TIÊU ĐỀ MỚI DÀI HƠN CHÚT\nNGẮN".into(),
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("reflow centered");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
let mut checked = 0;
|
||
for o in &after {
|
||
let Some(t) = &o.text else { continue };
|
||
if t.contains("TIÊU ĐỀ MỚI") || t.trim() == "NGẮN" {
|
||
let c = (o.rect.left + o.rect.right) / 2.0;
|
||
assert!((c - cx).abs() < 6.0, "dòng mới phải căn giữa quanh {cx}: center={c} text={t:?}");
|
||
checked += 1;
|
||
}
|
||
}
|
||
assert_eq!(checked, 2, "phải kiểm được 2 dòng mới");
|
||
}
|
||
|
||
#[test]
|
||
fn add_image_adds_image_object() {
|
||
let pdf = pdfium();
|
||
let input = sample();
|
||
let out = tmp("ff_edit_addimg.pdf");
|
||
|
||
// Tạo 1 PNG đỏ 24x24 làm fixture.
|
||
let png = tmp("ff_edit_fixture.png");
|
||
let mut img = image::RgbImage::new(24, 24);
|
||
for p in img.pixels_mut() {
|
||
*p = image::Rgb([220, 30, 30]);
|
||
}
|
||
img.save(&png).expect("save png");
|
||
|
||
let before = ff_engine::list_objects(&pdf, &input, 0, None).expect("list").len();
|
||
|
||
ff_engine::apply_edits(
|
||
&pdf,
|
||
&input,
|
||
0,
|
||
&[EditOp::AddImage {
|
||
x: 50.0,
|
||
y: 50.0,
|
||
width_pt: 80.0,
|
||
height_pt: 60.0,
|
||
image_path: png.to_string_lossy().into_owned(),
|
||
}],
|
||
&out,
|
||
None,
|
||
)
|
||
.expect("apply_edits AddImage");
|
||
|
||
let after = ff_engine::list_objects(&pdf, &out, 0, None).expect("list out");
|
||
assert_eq!(after.len(), before + 1, "thêm ảnh phải tăng 1 object");
|
||
assert!(after.iter().any(|o| o.kind == ObjectKind::Image), "phải có object kind Image");
|
||
}
|