use super::acroform_field_prune::DEFAULT_MAX_ACROFORM_DEPTH;
use super::resource_pruning::{should_remove_unreferenced_resources, RemoveUnreferencedResources};
use crate::page_extract::{append_selection_kids, null_copied_removed_pages, target_pages_root};
use crate::page_label_document_helper::{merge_adjacent_ranges, LabelRange};
use crate::pages::page_refs;
use crate::pdf_string::{new_unicode_string, utf8_value};
use crate::writer::reachability::sweep_unreachable_objects_except;
use crate::{
AcroFormDocumentHelper, Error, ObjectHandle, ObjectRef, PageDocumentHelper, PageObjectHelper,
Pdf, Result,
};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek};
pub struct MergeInput<'a, R: Read + Seek + 'static> {
pub source: &'a mut Pdf<R>,
pub pages: Vec<usize>,
}
fn wire_primary_catalog<RS: Read + Seek, RT: Read + Seek>(
source: &mut Pdf<RS>,
target: &mut Pdf<RT>,
source_id: u64,
) -> Result<()> {
let Some(source_catalog_ref) = source.root_ref() else {
return Ok(()); };
let source_catalog_handle = source.get_object_handle(source_catalog_ref);
let source_catalog = source.resolve_handle(&source_catalog_handle)?;
if source_catalog.try_as_dictionary()?.is_none() {
return Ok(()); }
let Some(target_catalog_ref) = target.root_ref() else {
return Ok(()); };
let target_catalog_handle = target.get_object_handle(target_catalog_ref);
let target_catalog = target.resolve_handle(&target_catalog_handle)?;
if target_catalog.try_as_dictionary()?.is_none() {
return Ok(()); }
for key in source_catalog.try_get_keys()? {
if key == b"/Pages" {
continue;
}
let value = source_catalog.try_get_key(&key)?;
let copied = target.copy_foreign_value(source_id, &value)?;
target_catalog.replace_key(&key, copied)?;
}
target.mark_object_handle_dirty(&target_catalog)?;
Ok(())
}
fn wire_primary_trailer<RS: Read + Seek, RT: Read + Seek>(
source: &mut Pdf<RS>,
target: &mut Pdf<RT>,
source_id: u64,
) -> Result<()> {
let source_trailer = source.trailer();
let target_trailer = target.trailer();
let Some(root_ref) = target.root_ref() else {
return Ok(());
};
for key in source_trailer.try_get_keys()? {
if matches!(
key.as_slice(),
b"/Root"
| b"/Size"
| b"/Prev"
| b"/Encrypt"
| b"/Type"
| b"/W"
| b"/Index"
| b"/XRefStm"
| b"/Length"
| b"/Filter"
| b"/DecodeParms"
| b"/F"
| b"/FFilter"
| b"/FDecodeParms"
) {
continue;
}
let value = source_trailer.try_get_key(&key)?;
let copied = target.copy_foreign_value(source_id, &value)?;
target_trailer.replace_key(&key, copied)?;
}
target_trailer.replace_key(b"/Root", target.get_object_handle(root_ref))?;
Ok(())
}
pub(crate) fn unique_field_name(base: &[u8], used: &BTreeSet<Vec<u8>>) -> Vec<u8> {
if !used.contains(base) {
return base.to_vec();
}
for n in 1u32.. {
let mut candidate = base.to_vec();
candidate.extend_from_slice(format!("+{n}").as_bytes());
if !used.contains(&candidate) {
return candidate;
}
}
unreachable!("u32 candidate space exhausted") }
struct KeptField {
target_ref: ObjectRef,
partial_name: Option<Vec<u8>>,
is_primary: bool,
}
#[derive(Default)]
struct PrimaryAcroForm {
has_dr: bool,
has_da: bool,
had_fields_array: bool,
original_field_names: BTreeSet<Vec<u8>>,
}
fn discover_primary_acroform<R: Read + Seek>(source: &mut Pdf<R>) -> Result<PrimaryAcroForm> {
let mut out = PrimaryAcroForm {
had_fields_array: source.acroform()?.has_fields_array()?,
..Default::default()
};
let Some(root_ref) = source.root_ref() else {
return Ok(out); };
let root_handle = source.get_object_handle(root_ref);
let root = source.resolve_handle(&root_handle)?;
if root.try_as_dictionary()?.is_none() {
return Ok(out); }
let acroform = source.resolve_handle(&root.try_get_key(b"/AcroForm")?)?;
if acroform.try_as_dictionary()?.is_some() {
out.has_dr = !acroform.try_get_key(b"/DR")?.is_null();
out.has_da = !acroform.try_get_key(b"/DA")?.is_null();
}
Ok(out)
}
pub(crate) fn source_top_level_field_names<R: Read + Seek>(
source: &mut Pdf<R>,
) -> Result<Vec<(ObjectRef, Option<Vec<u8>>)>> {
let top_fields = source.acroform()?.top_level_fields()?;
let mut out = Vec::with_capacity(top_fields.len());
for field_ref in top_fields {
let field_handle = source.get_object_handle(field_ref);
let terminal = source
.resolve_handle_ref(&field_handle)?
.1
.unwrap_or(field_ref);
let name = resolve_field_partial_name(source, terminal)?;
out.push((terminal, name));
}
Ok(out)
}
fn resolve_field_partial_name<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<u8>>> {
let field_handle = source.get_object_handle(field_ref);
let field = source.resolve_handle(&field_handle)?;
if field.try_as_dictionary()?.is_none() {
return Ok(None); }
let t_value = field.try_get_key(b"/T")?;
if t_value.is_null() {
return Ok(None);
}
let resolved = source.resolve_handle(&t_value)?;
Ok(resolved.as_string().map(|raw| utf8_value(&raw)))
}
fn remove_target_acroform<R: Read + Seek>(target: &mut Pdf<R>) -> Result<()> {
let Some(catalog_ref) = target.root_ref() else {
return Ok(()); };
let catalog_handle = target.get_object_handle(catalog_ref);
let catalog = target.resolve_handle(&catalog_handle)?;
if catalog.try_as_dictionary()?.is_none() {
return Ok(()); }
catalog.remove_key(b"/AcroForm");
target.mark_object_handle_dirty(&catalog)?;
Ok(())
}
fn build_merged_acroform<R: Read + Seek>(
target: &mut Pdf<R>,
primary: &PrimaryAcroForm,
kept: &[KeptField],
) -> Result<()> {
if kept.is_empty() && !primary.has_dr && !primary.has_da {
if primary.had_fields_array {
remove_target_acroform(target)?;
}
return Ok(());
}
let acroform =
AcroFormDocumentHelper::new_for_field_tree(target)?.canonical_get_or_create_acroform()?;
if acroform.try_as_dictionary()?.is_none() {
return Ok(()); }
let mut used = primary.original_field_names.clone();
for field in kept {
if field.is_primary {
if let Some(name) = &field.partial_name {
used.insert(name.clone());
}
}
}
let mut fields = Vec::with_capacity(kept.len());
for field in kept {
if !field.is_primary {
if let Some(name) = &field.partial_name {
let unique = unique_field_name(name, &used);
used.insert(unique.clone());
if unique != *name {
rename_field(target, field.target_ref, unique)?;
}
}
}
fields.push(target.get_object_handle(field.target_ref));
}
acroform.replace_key(b"/Fields", ObjectHandle::array(fields))?;
target.mark_object_handle_dirty(&acroform)?;
Ok(())
}
fn rename_field<R: Read + Seek>(
target: &mut Pdf<R>,
field_ref: ObjectRef,
name: Vec<u8>,
) -> Result<()> {
let field_handle = target.get_object_handle(field_ref);
let field = target.resolve_handle(&field_handle)?;
if field.try_as_dictionary()?.is_none() {
return Ok(()); }
field.replace_key(b"/T", ObjectHandle::string(new_unicode_string(&name)))?;
target.mark_object_handle_dirty(&field)?;
Ok(())
}
fn field_kid_refs<R: Read + Seek>(
source: &mut Pdf<R>,
field_ref: ObjectRef,
) -> Result<Option<Vec<ObjectRef>>> {
let field_handle = source.get_object_handle(field_ref);
let field = source.resolve_handle(&field_handle)?;
if field.try_as_dictionary()?.is_none() {
return Ok(None); }
let kids_value = field.try_get_key(b"/Kids")?;
if kids_value.is_null() {
return Ok(None);
}
let resolved = source.resolve_handle(&kids_value)?;
let Some(items) = resolved.try_as_array()? else {
return Ok(Some(Vec::new())); };
let mut refs = Vec::with_capacity(items.len());
for item in items {
let (_, terminal_ref) = source.resolve_handle_ref(&item)?;
if let Some(r) = terminal_ref {
refs.push(r);
} }
Ok(Some(refs))
}
fn collect_retained_widget_refs<R: Read + Seek>(
source: &mut Pdf<R>,
selected_pages: &BTreeSet<ObjectRef>,
retained: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
for &page_ref in selected_pages {
let page_handle = source.get_object_handle(page_ref);
let page = source.resolve_handle(&page_handle)?;
if page.try_as_dictionary()?.is_none() {
continue; }
let annots_val = page.try_get_key(b"/Annots")?;
if annots_val.is_null() {
continue;
}
let concrete = source.resolve_handle(&annots_val)?;
let Some(elems) = concrete.try_as_array()? else {
continue; };
for elem in elems {
let (_, terminal_ref) = source.resolve_handle_ref(&elem)?;
if let Some(r) = terminal_ref {
retained.insert(r);
}
}
}
Ok(())
}
fn widget_page_ref<R: Read + Seek>(
source: &mut Pdf<R>,
widget_ref: ObjectRef,
) -> Result<Option<ObjectRef>> {
let widget_handle = source.get_object_handle(widget_ref);
let widget = source.resolve_handle(&widget_handle)?;
if widget.try_as_dictionary()?.is_none() {
return Ok(None); }
let p_value = widget.try_get_key(b"/P")?;
if p_value.is_null() {
return Ok(None);
}
let (_, last_ref) = source.resolve_handle_ref(&p_value)?;
Ok(last_ref)
}
#[allow(clippy::too_many_arguments)]
fn trim_field_kids<R: Read + Seek>(
source: &mut Pdf<R>,
target: &mut Pdf<Cursor<Vec<u8>>>,
field_ref: ObjectRef,
surviving_pages: &BTreeSet<ObjectRef>,
retained_widgets: &BTreeSet<ObjectRef>,
map: &BTreeMap<ObjectRef, ObjectRef>,
orphan_pages: &mut BTreeSet<ObjectRef>,
depth: usize,
visited: &mut BTreeSet<ObjectRef>,
) -> Result<Option<Vec<ObjectRef>>> {
if depth > DEFAULT_MAX_ACROFORM_DEPTH {
return Err(Error::Unsupported(format!(
"AcroForm field tree depth exceeds maximum of {DEFAULT_MAX_ACROFORM_DEPTH}"
)));
}
if !visited.insert(field_ref) {
return Ok(Some(Vec::new())); }
let Some(kids) = field_kid_refs(source, field_ref)? else {
return Ok(None); };
let mut survivors: Vec<ObjectRef> = Vec::with_capacity(kids.len());
for kid_ref in kids {
let kid_kind = trim_field_kids(
source,
target,
kid_ref,
surviving_pages,
retained_widgets,
map,
orphan_pages,
depth + 1,
visited,
)?; match kid_kind {
Some(sub_survivors) => {
if sub_survivors.is_empty() {
continue;
}
rewrite_field_kids(target, kid_ref, &sub_survivors, map)?;
survivors.push(kid_ref);
}
None => {
if retained_widgets.contains(&kid_ref) {
survivors.push(kid_ref);
} else {
match widget_page_ref(source, kid_ref)? {
Some(page_ref) if surviving_pages.contains(&page_ref) => {
survivors.push(kid_ref)
}
Some(page_ref) => {
orphan_pages.insert(page_ref);
}
None => {} }
}
}
}
}
Ok(Some(survivors))
}
fn rewrite_field_kids<R: Read + Seek>(
target: &mut Pdf<R>,
src_field_ref: ObjectRef,
survivors: &[ObjectRef],
map: &BTreeMap<ObjectRef, ObjectRef>,
) -> Result<()> {
let Some(target_field_ref) = map.get(&src_field_ref).copied() else {
return Ok(()); };
let field_handle = target.get_object_handle(target_field_ref);
let field = target.resolve_handle(&field_handle)?;
if field.try_as_dictionary()?.is_none() {
return Ok(()); }
let mut kids = Vec::with_capacity(survivors.len());
for src in survivors {
if let Some(&target_ref) = map.get(src) {
kids.push(target.get_object_handle(target_ref));
}
}
field.replace_key(b"/Kids", ObjectHandle::array(kids))?;
target.mark_object_handle_dirty(&field)?;
Ok(())
}
pub fn merge_documents<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
) -> Result<Pdf<Cursor<Vec<u8>>>> {
merge_documents_with_resource_mode(inputs, RemoveUnreferencedResources::No)
}
pub(crate) fn merge_documents_with_resource_mode<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
resource_mode: RemoveUnreferencedResources,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
merge_documents_with_resource_mode_and_preserve_primary(inputs, resource_mode, false)
}
pub(crate) fn merge_documents_with_resource_mode_and_preserve_primary<R: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
resource_mode: RemoveUnreferencedResources,
preserve_primary_unreferenced: bool,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
if inputs.is_empty() {
return Err(Error::Unsupported(
"merge requires at least one input".to_string(),
));
}
let remove_resources: Vec<bool> = inputs
.iter_mut()
.map(|input| match resource_mode {
RemoveUnreferencedResources::No => Ok(false),
RemoveUnreferencedResources::Yes => Ok(true),
RemoveUnreferencedResources::Auto => should_remove_unreferenced_resources(input.source),
})
.collect::<Result<_>>()?;
let mut target = Pdf::empty()?;
let pages_root_ref = target_pages_root(&mut target)?;
let mut kids: Vec<ObjectRef> = Vec::new();
let mut used: BTreeSet<ObjectRef> = BTreeSet::new();
let mut kept_fields: Vec<KeptField> = Vec::new();
let mut primary_acroform = PrimaryAcroForm::default();
let mut preserved_target_refs: BTreeSet<ObjectRef> = BTreeSet::new();
let total_selected: usize = inputs.iter().map(|i| i.pages.len()).sum();
let mut label_entries: Vec<(i64, LabelRange)> = Vec::with_capacity(total_selected);
let mut any_page_labels = false;
let mut out_pageno: i64 = 0;
for (input_index, input) in inputs.iter_mut().enumerate() {
let is_primary = input_index == 0;
if !is_primary && input.pages.is_empty() {
continue;
}
PageDocumentHelper::new(input.source).push_inherited_attributes_to_pages()?;
if !input.pages.is_empty() {
let mut src_labels = input.source.page_labels();
if src_labels.has_page_labels()? {
any_page_labels = true;
}
let src_indices: Vec<i64> = input.pages.iter().map(|&i| i as i64).collect();
label_entries.extend(src_labels.labels_for_selection(&src_indices, out_pageno)?);
out_pageno = out_pageno.saturating_add(input.pages.len() as i64);
}
if is_primary {
primary_acroform = discover_primary_acroform(input.source)?;
}
let source_fields = source_top_level_field_names(input.source)?;
if is_primary {
primary_acroform.original_field_names.extend(
source_fields
.iter()
.filter_map(|(_, name)| name.as_ref().cloned()),
);
}
let all = page_refs(input.source)?;
let mut selected: Vec<ObjectRef> = Vec::with_capacity(input.pages.len());
for &idx in &input.pages {
let page_ref = *all.get(idx).ok_or_else(|| {
Error::Unsupported(format!(
"page index {idx} out of range (input document has {} pages)",
all.len()
))
})?;
selected.push(page_ref);
}
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut unique: Vec<ObjectRef> = Vec::with_capacity(selected.len());
for &page_ref in &selected {
if seen.insert(page_ref) {
unique.push(page_ref);
}
}
if remove_resources[input_index] {
for &page_ref in &unique {
PageObjectHelper::new(page_ref, input.source).remove_unreferenced_resources()?;
}
}
let source_id = input.source.unique_id();
let mut copy_seed = target.take_foreign_object_map(source_id);
if is_primary {
let primary_catalog_ref = input
.source
.root_ref()
.expect("page_refs above already required a resolvable /Root");
let target_catalog_ref = target
.root_ref()
.expect("Pdf::empty always populates a root catalog");
let primary_catalog_handle = input.source.get_object_handle(primary_catalog_ref);
let primary_catalog = input.source.resolve_handle(&primary_catalog_handle)?;
let primary_pages_ref = primary_catalog
.try_get_key(b"/Pages")?
.object_ref()
.expect("page_refs above already required an indirect primary /Pages");
copy_seed.insert(primary_catalog_ref, target_catalog_ref);
copy_seed.insert(primary_pages_ref, pages_root_ref);
}
target.set_foreign_object_map(source_id, copy_seed);
for &page_ref in &unique {
let source_page = input.source.get_object_handle(page_ref);
let copied_page = target.copy_foreign_object(&source_page)?;
if copied_page.object_ref().is_none() {
return Err(Error::Missing("merged page missing from foreign copy map"));
}
}
let page_copy_map = target.foreign_object_map_snapshot(source_id);
if is_primary {
wire_primary_catalog(input.source, &mut target, source_id)?;
wire_primary_trailer(input.source, &mut target, source_id)?;
}
if is_primary && preserve_primary_unreferenced {
let target_catalog_ref = target
.root_ref()
.expect("Pdf::empty always populates a root catalog");
for object_ref in input.source.live_object_refs() {
let source_object = input.source.get_object_handle(object_ref);
if source_object.try_is_stream_of_type(b"ObjStm", b"")? {
continue;
}
let copied = target.copy_foreign_object(&source_object)?;
let Some(target_ref) = copied.object_ref() else {
continue; };
if target_ref != target_catalog_ref && target_ref != pages_root_ref {
preserved_target_refs.insert(target_ref);
}
}
}
let map = target.take_foreign_object_map(source_id);
null_copied_removed_pages(&mut target, &all, &seen, &map)?;
let pages_handle = target.get_object_handle(pages_root_ref);
for &src_ref in &unique {
let copied_page_ref = *map
.get(&src_ref)
.ok_or(Error::Missing("merged page missing from copy map"))?;
let page = target.get_object_handle(copied_page_ref);
target.resolve(&page)?;
page.replace_key(b"/Parent", pages_handle.clone())?;
target.mark_object_handle_dirty(&page)?;
}
let mut orphan_pages: BTreeSet<ObjectRef> = BTreeSet::new();
let mut retained_widgets: BTreeSet<ObjectRef> = BTreeSet::new();
collect_retained_widget_refs(input.source, &seen, &mut retained_widgets)?;
for (src_field_ref, partial_name) in source_fields {
if page_copy_map.contains_key(&src_field_ref) {
if let Some(&target_ref) = map.get(&src_field_ref) {
let mut visited: BTreeSet<ObjectRef> = BTreeSet::new();
let trimmed = trim_field_kids(
input.source,
&mut target,
src_field_ref,
&seen,
&retained_widgets,
&map,
&mut orphan_pages,
0,
&mut visited,
)?; if let Some(survivors) = trimmed {
if survivors.is_empty() {
continue;
}
rewrite_field_kids(&mut target, src_field_ref, &survivors, &map)?;
}
kept_fields.push(KeptField {
target_ref,
partial_name,
is_primary,
});
}
}
}
for src_page_ref in &orphan_pages {
if let Some(&new_ref) = map.get(src_page_ref) {
target.replace_object(new_ref, ObjectHandle::null())?;
}
}
append_selection_kids(&mut target, &selected, &map, &mut used, &mut kids)?;
}
let root = target.get_object_handle(pages_root_ref);
target.resolve(&root)?;
if root.try_as_dictionary()?.is_none() {
return Err(Error::Unsupported(
"target /Pages is not a dictionary".to_owned(),
));
}
let kid_handles = kids
.iter()
.map(|&kid| target.get_object_handle(kid))
.collect();
root.replace_key(b"/Kids", ObjectHandle::array(kid_handles))?;
root.replace_key(b"/Count", ObjectHandle::integer(kids.len() as i64))?;
target.mark_object_handle_dirty(&root)?;
build_merged_acroform(&mut target, &primary_acroform, &kept_fields)?;
if any_page_labels {
let folded = merge_adjacent_ranges(label_entries);
target.page_labels().write_reconstructed_labels(&folded)?;
}
sweep_unreachable_objects_except(&mut target, &preserved_target_refs)?;
Ok(target)
}
#[cfg(test)]
mod tests {
use super::{
collect_retained_widget_refs, field_kid_refs, merge_documents, rewrite_field_kids,
unique_field_name, widget_page_ref, MergeInput,
};
use crate::{ObjectHandle, ObjectRef, Pdf};
use std::collections::{BTreeMap, BTreeSet};
fn build_pdf(objects: &[(u32, &str)], root: u32) -> Vec<u8> {
let mut out: Vec<u8> = b"%PDF-1.7\n".to_vec();
let mut offsets: BTreeMap<u32, u64> = BTreeMap::new();
let max = objects.iter().map(|(number, _)| *number).max().unwrap_or(0);
for (number, body) in objects {
offsets.insert(*number, out.len() as u64);
out.extend_from_slice(format!("{number} 0 obj\n{body}\nendobj\n").as_bytes());
}
let xref_start = out.len() as u64;
let size = max + 1;
out.extend_from_slice(format!("xref\n0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for number in 1..=max {
match offsets.get(&number) {
Some(offset) => {
out.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes())
}
None => out.extend_from_slice(b"0000000000 65535 f \n"),
}
}
out.extend_from_slice(
format!(
"trailer\n<< /Size {size} /Root {root} 0 R >>\nstartxref\n{xref_start}\n%%EOF\n"
)
.as_bytes(),
);
out
}
fn used(names: &[&[u8]]) -> BTreeSet<Vec<u8>> {
names.iter().map(|n| n.to_vec()).collect()
}
#[test]
fn page_merge_production_route_has_no_legacy_borrowed_resolution() {
let production = include_str!("page_merge.rs")
.split_once("#[cfg(test)]")
.expect("page_merge test module marker")
.0;
assert_eq!(
production.matches("resolve_borrowed").count(),
0,
"page_merge production must use the canonical ObjectHandle resolver"
);
}
#[test]
fn unique_field_name_keeps_unused_base() {
assert_eq!(unique_field_name(b"name", &used(&[])), b"name".to_vec());
assert_eq!(
unique_field_name(b"name", &used(&[b"email"])),
b"name".to_vec()
);
}
#[test]
fn unique_field_name_appends_plus_one_on_collision() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name"])),
b"name+1".to_vec()
);
}
#[test]
fn unique_field_name_finds_first_unused_in_sequence() {
assert_eq!(
unique_field_name(b"name", &used(&[b"name", b"name+1"])),
b"name+2".to_vec()
);
}
#[test]
fn unique_field_name_reresolves_colliding_candidate() {
assert_eq!(
unique_field_name(b"name+1", &used(&[b"name", b"name+1"])),
b"name+1+1".to_vec()
);
}
fn resolved_handle<R: std::io::Read + std::io::Seek>(
pdf: &mut Pdf<R>,
object_ref: ObjectRef,
) -> ObjectHandle {
let handle = pdf.get_object_handle(object_ref);
pdf.resolve(&handle).expect("resolve object");
handle
}
#[test]
fn doc_level_page_root_is_null_boundary_without_contents_in_closure() {
let bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /OpenAction 4 0 R >>"),
(2, "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>"),
(3, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>"),
(
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 10 0 R >>",
),
(10, "<< /Length 4 >>\nstream\nDROP\nendstream"),
],
1,
);
let mut merge_source = Pdf::open_mem_owned(bytes.clone()).unwrap();
let mut inputs = [MergeInput {
source: &mut merge_source,
pages: vec![0],
}];
let mut merged = merge_documents(&mut inputs).unwrap();
let catalog_ref = merged.root_ref().unwrap();
let catalog = resolved_handle(&mut merged, catalog_ref);
assert!(
catalog.as_dictionary().is_some(),
"catalog must be a dictionary"
);
let open_action_ref = catalog
.get_key(b"/OpenAction")
.object_ref()
.expect("indirect /OpenAction carrier is retained");
assert!(
resolved_handle(&mut merged, open_action_ref).is_null(),
"the unselected page root is copied and nulled"
);
}
#[test]
fn merge_documents_reserves_unselected_primary_names_regardless_of_string_encoding() {
let primary_bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /AcroForm 6 0 R >>"),
(2, "<< /Type /Pages /Count 2 /Kids [3 0 R 4 0 R] >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [5 0 R] >>",
),
(
4,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [7 0 R] >>",
),
(
5,
"<< /Type /Annot /Subtype /Widget /FT /Tx /T (F) /Rect [0 0 10 10] /P 3 0 R >>",
),
(6, "<< /Fields [5 0 R 7 0 R] >>"),
(
7,
"<< /Type /Annot /Subtype /Widget /FT /Tx /T <FEFF0046002B0031> \
/Rect [0 0 10 10] /P 4 0 R >>",
),
],
1,
);
let secondary_bytes = build_pdf(
&[
(1, "<< /Type /Catalog /Pages 2 0 R /AcroForm 5 0 R >>"),
(2, "<< /Type /Pages /Count 1 /Kids [3 0 R] >>"),
(
3,
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Annots [4 0 R] >>",
),
(
4,
"<< /Type /Annot /Subtype /Widget /FT /Tx /T (F) /Rect [0 0 10 10] /P 3 0 R >>",
),
(5, "<< /Fields [4 0 R] >>"),
],
1,
);
let mut primary = Pdf::open_mem_owned(primary_bytes).unwrap();
let mut secondary = Pdf::open_mem_owned(secondary_bytes).unwrap();
let mut inputs = [
MergeInput {
source: &mut primary,
pages: vec![0],
},
MergeInput {
source: &mut secondary,
pages: vec![0],
},
];
let mut merged = merge_documents(&mut inputs).unwrap();
let catalog_ref = merged.root_ref().unwrap();
let catalog = resolved_handle(&mut merged, catalog_ref);
assert!(
catalog.as_dictionary().is_some(),
"catalog must be a dictionary"
);
let acroform_ref = catalog
.get_key(b"/AcroForm")
.object_ref()
.expect("/AcroForm");
let acroform = resolved_handle(&mut merged, acroform_ref);
assert!(
acroform.as_dictionary().is_some(),
"AcroForm must be a dictionary"
);
let fields = acroform
.get_key(b"/Fields")
.as_array()
.expect("/Fields array");
let names: Vec<Vec<u8>> = fields
.iter()
.map(|field| {
let field_ref = field.object_ref().expect("field is an indirect ref");
let field_dict = resolved_handle(&mut merged, field_ref);
assert!(
field_dict.as_dictionary().is_some(),
"field must be a dictionary"
);
let name = field_dict.get_key(b"/T");
merged.resolve(&name).expect("resolve /T");
name.as_string().expect("/T string")
})
.collect();
assert_eq!(
names,
vec![b"F".to_vec(), b"F+2".to_vec()],
"the secondary's colliding field must resolve to F+2, matching qpdf's \
getUTF8Value()-decoded collision index, not F+1 from an undecoded byte \
comparison against the UTF-16BE-encoded reservation"
);
}
#[test]
fn field_kid_and_widget_page_routes_use_resolved_handle_refs() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../tests/fixtures/compat/form-fields-and-annotations-p-and-inline.pdf");
let mut source = Pdf::open_mem_owned(std::fs::read(path).expect("fixture exists")).unwrap();
let kids = field_kid_refs(&mut source, ObjectRef::new(5, 0))
.expect("field kids")
.expect("non-terminal field");
assert_eq!(
kids,
vec![
ObjectRef::new(12, 0),
ObjectRef::new(13, 0),
ObjectRef::new(14, 0)
]
);
assert_eq!(
widget_page_ref(&mut source, ObjectRef::new(3, 0)).expect("widget page"),
Some(ObjectRef::new(10, 0))
);
let mut retained = BTreeSet::new();
collect_retained_widget_refs(
&mut source,
&BTreeSet::from([ObjectRef::new(10, 0)]),
&mut retained,
)
.expect("retained widgets");
assert!(retained.contains(&ObjectRef::new(12, 0)));
let mut target = Pdf::empty().expect("empty target");
let target_field = target
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("target field");
let target_kid = target
.make_indirect_object_handle(ObjectHandle::dictionary(Vec::new()))
.expect("target kid");
let target_field_ref = target_field.object_ref().expect("target field ref");
let target_kid_ref = target_kid.object_ref().expect("target kid ref");
let map = BTreeMap::from([
(ObjectRef::new(5, 0), target_field_ref),
(kids[0], target_kid_ref),
]);
rewrite_field_kids(&mut target, ObjectRef::new(5, 0), &[kids[0]], &map)
.expect("rewrite copied field kids");
target
.resolve(&target_field)
.expect("resolve rewritten field");
assert_eq!(
target_field
.try_get_key(b"/Kids")
.expect("kids key")
.as_array()
.expect("kids array")
.len(),
1
);
}
}