use super::page_merge::source_top_level_field_names;
#[cfg(test)]
use super::page_merge::{merge_documents_for_page_specs_into, MergeInput};
use super::page_plan::PagePlan;
use super::resource_pruning::{
shared_resource_finding_message, should_remove_unreferenced_resources_with_report,
RemoveUnreferencedResources,
};
use crate::form_field_object_helper::FormFieldObjectHelper;
#[cfg(test)]
use crate::page_label_document_helper::copy_raw_page_label_entries;
#[cfg(test)]
use crate::page_label_document_helper::LabelRange;
use crate::page_label_document_helper::{
merge_adjacent_raw_labels, merge_adjacent_raw_page_labels, record_primary_label_provenance,
RawPageLabelEntry,
};
use crate::pages::tree_rebuild::RebuildResult;
#[cfg(test)]
use crate::pdf::WriterObjectOrderKey;
use crate::qpdf_obj_gen::QpdfObjGen;
#[cfg(test)]
use crate::ObjectStreamMode;
use crate::{
AcroFormDocumentHelper, Error, Matrix, ObjectHandle, ObjectRef, PageDocumentHelper, PageInput,
PageObjectHelper, PageRange, Pdf, Result, UsageError,
};
use std::collections::{BTreeMap, BTreeSet};
#[cfg(test)]
use std::io::Cursor;
use std::io::{Read, Seek};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PageSpecInput {
pub(crate) source_index: usize,
pub(crate) range: PageRange,
}
fn select_single_source_pages<R: Read + Seek>(
source: &mut Pdf<R>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
) -> Result<Vec<super::page_plan::SelectedPage>> {
if specs.is_empty() {
return Err(Error::Unsupported(
"--pages: no page specifications were supplied".into(),
));
}
let mut plans = Vec::with_capacity(specs.len());
for (spec_index, spec) in specs.iter().enumerate() {
if spec.source_index != 0 {
return Err(Error::Unsupported(format!(
"--pages: single-source specification {spec_index} refers to source {}",
spec.source_index
)));
}
let source_name = source.input_source_description();
plans.push(
PagePlan::build(source, &spec.range)
.map_err(|error| page_spec_error(&source_name, 0, spec_index, error))?,
);
}
let mut selected = Vec::new();
let collate_values = collate_values_for_specs(collate, plans.len())?;
if plans.len() > 1 {
if let Some(values) = collate_values.as_deref() {
let mut cursors = vec![0usize; plans.len()];
loop {
let mut emitted = false;
for (plan_index, plan) in plans.iter().enumerate() {
let start = cursors[plan_index];
let end = start
.saturating_add(values[plan_index])
.min(plan.pages().len());
selected.extend(plan.pages()[start..end].iter().cloned());
emitted |= end > start;
cursors[plan_index] = end;
}
if !emitted {
break;
}
}
} else {
selected.extend(plans.iter().flat_map(|plan| plan.pages().iter().cloned()));
}
} else {
selected.extend(plans.iter().flat_map(|plan| plan.pages().iter().cloned()));
}
Ok(selected)
}
fn qpdf_page_range_error(source_name: &[u8], error: &Error) -> Option<Error> {
let message = error.raw_message()?;
let is_numeric_range = message.starts_with(b"error at * in numeric range ")
|| message.starts_with(b"error in numeric range ");
if !is_numeric_range {
return None;
}
let mut what = b"parsing numeric range for ".to_vec();
what.extend_from_slice(source_name);
what.extend_from_slice(b": ");
what.extend_from_slice(message);
Some(Error::SystemBytes(what))
}
fn page_spec_error(
source_name: &[u8],
source_index: usize,
spec_index: usize,
error: Error,
) -> Error {
qpdf_page_range_error(source_name, &error).unwrap_or_else(|| {
Error::Unsupported(format!(
"--pages: source {source_index} specification {spec_index}: {error}"
))
})
}
fn collate_values_for_specs(
collate: Option<&[usize]>,
spec_count: usize,
) -> Result<Option<Vec<usize>>> {
let Some(values) = collate else {
return Ok(None);
};
if values.is_empty() {
return Ok(None);
}
if values.len() != 1 && values.len() != spec_count {
return Err(Error::Usage(UsageError::new(
"--pages: if --collate has more than one value, it must have one value per page specification",
)));
}
if values.len() == 1 && spec_count > 1 {
return Ok(Some(vec![values[0]; spec_count]));
}
Ok(Some(values.to_vec()))
}
pub fn copy_duplicate_page_annotations<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
let mut first_occurrence: BTreeMap<ObjectRef, ObjectRef> = BTreeMap::new();
for page_refs in result.ref_map.values() {
let Some(&first_page) = page_refs.first() else {
continue; };
for &duplicate_page in page_refs.iter().skip(1) {
first_occurrence.insert(duplicate_page, first_page);
}
}
for &new_page in &result.new_kids {
let Some(&source_page_ref) = first_occurrence.get(&new_page) else {
continue;
};
let source_page = pdf.get_object_handle(source_page_ref);
let destination_page = pdf.get_object_handle(new_page);
destination_page.remove_key(b"/Annots");
PageObjectHelper::new(new_page, pdf).copy_annotations(source_page, Matrix::default())?;
}
Ok(())
}
fn prefixed_info_line(job: &super::QPDFJob, body: &[u8]) -> Vec<u8> {
let mut message = job.message_prefix_bytes().to_vec();
message.extend_from_slice(b": ");
message.extend_from_slice(body);
message
}
fn report_page_spec_diagnostics<R: Read + Seek>(
job: &super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
resource_mode: RemoveUnreferencedResources,
) -> Result<Vec<bool>> {
let source_names: Vec<Vec<u8>> = sources.iter().map(Pdf::input_source_description).collect();
let mut source_order: Vec<(usize, Vec<u8>)> = source_names
.iter()
.enumerate()
.map(|(index, name)| (index, job.page_spec_source_sort_key(index, name)))
.collect();
source_order.sort_by(|(left_index, left_name), (right_index, right_name)| {
left_name
.cmp(right_name)
.then_with(|| left_index.cmp(right_index))
});
let verbose = job.verbose();
let logger = job.logger();
let mut decisions = vec![false; sources.len()];
let mut decisions_by_source_id = BTreeMap::new();
for (source_index, _source_sort_key) in source_order {
let source_name = &source_names[source_index];
let source_id = sources[source_index].unique_id();
if let Some(&decision) = decisions_by_source_id.get(&source_id) {
decisions[source_index] = decision;
continue;
}
let decision = match resource_mode {
RemoveUnreferencedResources::No => false,
RemoveUnreferencedResources::Yes => true,
RemoveUnreferencedResources::Auto => {
if verbose {
let mut message = prefixed_info_line(job, source_name.as_slice());
message.extend_from_slice(b": checking for shared resources\n");
logger.info(message)?;
}
let should_remove = should_remove_unreferenced_resources_with_report(
&mut sources[source_index],
|finding| {
if verbose {
logger.info(shared_resource_finding_message(finding))
} else {
Ok(())
}
},
)?; if verbose && !should_remove {
logger.info(prefixed_info_line(job, b"no shared resources found\n"))?;
}
should_remove
}
};
decisions_by_source_id.insert(source_id, decision);
decisions[source_index] = decision;
}
if verbose {
logger.info(prefixed_info_line(
job,
b"removing unreferenced pages from primary input\n",
))?; for spec in specs {
let source_name = source_names.get(spec.source_index).ok_or_else(|| {
Error::Unsupported(format!(
"--pages: specification refers to missing source {}",
spec.source_index
))
})?;
let mut message = prefixed_info_line(job, b"adding pages from ");
message.extend_from_slice(source_name);
message.push(b'\n');
logger.info(message)?;
}
}
Ok(decisions)
}
fn handle_single_source_page_specs<R: Read + Seek>(
job: &mut super::QPDFJob,
source: &mut Pdf<R>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
) -> Result<(RebuildResult, RemoveUnreferencedResources)> {
crate::PageDocumentHelper::new(source).get_all_pages()?;
let selected = select_single_source_pages(source, specs, collate)?;
let remove_resources =
report_page_spec_diagnostics(job, std::slice::from_mut(source), specs, resource_mode)?;
let prune_mode = if remove_resources[0] {
resource_mode
} else {
RemoveUnreferencedResources::No
};
crate::PageDocumentHelper::new(source).push_inherited_attributes_to_pages()?;
let selected_refs: Vec<_> = selected.iter().map(|page| page.page_ref).collect();
let mut copy_duplicate_annotations =
|pdf: &mut Pdf<R>, source_page_ref: ObjectRef, new_page: ObjectRef| -> Result<()> {
let source_page = pdf.get_object_handle(source_page_ref);
let destination_page = pdf.get_object_handle(new_page);
destination_page.remove_key(b"/Annots");
PageObjectHelper::new(new_page, pdf).copy_annotations(source_page, Matrix::default())
};
let result = crate::pages::tree_rebuild::rebuild_page_tree_with_duplicate_hook(
source,
&selected_refs,
&mut copy_duplicate_annotations,
)?;
let mut labels = source.page_labels();
if labels.has_page_labels()? {
let src_indices: Vec<i64> = selected
.iter()
.map(|page| i64::from(page.index_1based) - 1)
.collect();
let entries = labels.labels_for_selection_raw(&src_indices, 0)?;
let folded = merge_adjacent_raw_labels(entries)?;
labels.write_reconstructed_labels_raw(&folded)?;
}
job.record_document_warnings(source);
Ok((result, prune_mode))
}
#[allow(clippy::too_many_arguments)]
fn handle_multi_source_page_specs_in_place<R: Read + Seek + 'static>(
job: &mut super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
) -> Result<(RebuildResult, RemoveUnreferencedResources)> {
if sources.is_empty() {
return Err(Error::Unsupported(
"--pages: a primary source document is required".into(),
));
}
if specs.is_empty() {
return Err(Error::Unsupported(
"--pages: no page specifications were supplied".into(),
));
}
let mut plans = Vec::with_capacity(specs.len());
for (spec_index, spec) in specs.iter().enumerate() {
let source = sources.get_mut(spec.source_index).ok_or_else(|| {
Error::Unsupported(format!(
"--pages: specification {spec_index} refers to missing source {}",
spec.source_index
))
})?;
let source_name = source.input_source_description();
PageDocumentHelper::new(source).get_all_pages()?;
let plan = PagePlan::build(source, &spec.range)
.map_err(|error| page_spec_error(&source_name, spec.source_index, spec_index, error))?;
plans.push(plan);
}
let collate_values = collate_values_for_specs(collate, plans.len())?;
let mut grouped_pages: Vec<Vec<usize>> = vec![Vec::new(); sources.len()];
let mut ordered_pages: Vec<OrderedPage> = Vec::new();
let mut append_page = |source_index: usize, page_index_1based: u32| {
let page_index = page_index_1based as usize - 1;
let group_index = grouped_pages[source_index].len();
grouped_pages[source_index].push(page_index);
ordered_pages.push((source_index, group_index));
};
if plans.len() > 1 {
if let Some(values) = collate_values.as_deref() {
let mut cursors = vec![0usize; plans.len()];
loop {
let mut emitted = false;
for (spec_index, plan) in plans.iter().enumerate() {
let start = cursors[spec_index];
let end = start
.saturating_add(values[spec_index])
.min(plan.pages().len());
for page in &plan.pages()[start..end] {
append_page(specs[spec_index].source_index, page.index_1based);
}
if end > start {
emitted = true;
}
cursors[spec_index] = end;
}
if !emitted {
break;
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
let remove_resources = report_page_spec_diagnostics(job, sources, specs, resource_mode)?;
let source_page_refs: Vec<Vec<ObjectRef>> = sources
.iter_mut()
.enumerate()
.map(|(source_index, source)| {
if source_index != 0 && grouped_pages[source_index].is_empty() {
Ok(Vec::new())
} else {
crate::pages::page_refs(source)
}
})
.collect::<Result<_>>()?;
let original_primary_pages = source_page_refs[0].clone();
let referenced_source_indices: BTreeSet<_> =
specs.iter().map(|spec| spec.source_index).collect();
let mut any_page_labels = false;
for source_index in referenced_source_indices {
any_page_labels |= sources[source_index].page_labels().has_page_labels()?;
}
let mut label_entries = Vec::new();
let mut current_pages = if !original_primary_pages.is_empty() || !ordered_pages.is_empty() {
PageDocumentHelper::new(&mut sources[0]).push_inherited_attributes_to_pages()?;
crate::pages::tree_rebuild::rebuild_page_tree(&mut sources[0], &original_primary_pages)?
.new_kids
} else {
Vec::new()
};
for page in &original_primary_pages {
PageDocumentHelper::new(&mut sources[0])
.remove_flattened_page_for_job(*page, &mut current_pages)?;
}
let primary_field_names = source_top_level_field_names(&mut sources[0])?
.into_iter()
.filter_map(|(_, name)| name)
.collect::<BTreeSet<_>>();
let mut seen_source_pages: Vec<BTreeSet<ObjectRef>> = vec![BTreeSet::new(); sources.len()];
let mut final_refs = Vec::with_capacity(ordered_pages.len());
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
let first_copy = seen_source_pages[source_index].insert(source_page_ref);
if first_copy && remove_resources[source_index] {
if source_index == 0 {
PageObjectHelper::new(source_page_ref, &mut sources[0])
.remove_unreferenced_resources()?;
} else {
PageObjectHelper::new(source_page_ref, &mut sources[source_index])
.remove_unreferenced_resources()?;
}
}
if any_page_labels {
let labels = sources[source_index]
.page_labels()
.labels_for_selection_raw(&[source_page_index as i64], output_index as i64)?;
if let Some((index, label)) = labels.into_iter().next() {
label_entries.push(RawPageLabelEntry {
index,
source_id: sources[source_index].unique_id(),
source_is_primary: source_index == 0,
label,
});
}
}
let page_ref = if source_index == 0 {
PageDocumentHelper::new(&mut sources[0]).append_flattened_page_for_job(
PageInput::<R>::Existing(source_page_ref),
&mut current_pages,
)? } else {
let (primary, secondary) = sources.split_at_mut(1);
PageDocumentHelper::new(&mut primary[0]).append_flattened_page_for_job(
PageInput::foreign(&mut secondary[source_index - 1], source_page_ref),
&mut current_pages,
)? };
final_refs.push(page_ref);
if source_index == 0 && !first_copy {
let source_page = sources[0].get_object_handle(source_page_ref);
PageObjectHelper::new(page_ref, &mut sources[0])
.fix_copied_annotations_with_field_tree_only(source_page, &primary_field_names)?;
} else if source_index != 0 {
let (primary, secondary) = sources.split_at_mut(1);
let source_page = secondary[source_index - 1].get_object_handle(source_page_ref);
PageObjectHelper::new(page_ref, &mut primary[0])
.fix_copied_annotations_from_with_field_tree_only(
source_page,
&mut secondary[source_index - 1],
&primary_field_names,
)?; }
}
if any_page_labels {
let folded = merge_adjacent_raw_page_labels(label_entries)?;
let copied = folded
.iter()
.map(|entry| Ok((entry.index, entry.label.shallow_copy()?)))
.collect::<Result<Vec<_>>>()?;
record_primary_label_provenance(&mut sources[0], &folded);
sources[0]
.page_labels()
.write_reconstructed_labels_raw(&copied)?;
}
let selected_primary_pages: BTreeSet<_> = ordered_pages
.iter()
.filter(|&&(source_index, _)| source_index == 0)
.map(|&(_, group_index)| source_page_refs[0][grouped_pages[0][group_index]])
.collect();
for page in &original_primary_pages {
if !selected_primary_pages.contains(page) {
sources[0].replace_object(*page, ObjectHandle::null())?;
}
}
prune_page_spec_acroform_fields(&mut sources[0], &final_refs)?;
let mut ref_map: BTreeMap<ObjectRef, Vec<ObjectRef>> = BTreeMap::new();
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
if source_index == 0 {
let source_page_ref = source_page_refs[0][grouped_pages[0][group_index]];
ref_map
.entry(source_page_ref)
.or_default()
.push(final_refs[output_index]);
}
}
let retained_primary: BTreeSet<_> = ref_map.keys().copied().collect();
let removed_page_objgens = original_primary_pages
.iter()
.filter(|page| !retained_primary.contains(page))
.filter_map(|page| QpdfObjGen::try_from_object_ref(*page).ok())
.collect();
let result = RebuildResult {
new_kids: final_refs,
ref_map,
removed_page_objgens,
};
let prune_mode = if remove_resources[0] {
resource_mode
} else {
RemoveUnreferencedResources::No
};
job.record_document_warnings(&sources[0]);
for source in sources.iter().skip(1) {
job.record_document_warnings(source);
}
Ok((result, prune_mode))
}
fn prune_page_spec_acroform_fields<R: Read + Seek>(
primary: &mut Pdf<R>,
selected_pages: &[ObjectRef],
) -> Result<()> {
let catalog = primary.root_handle()?;
if !catalog.try_has_key(b"/AcroForm")? {
return Ok(());
}
let acroform = catalog.try_get_key(b"/AcroForm")?;
acroform.try_dereference()?;
if !acroform.try_is_dictionary()? {
return Ok(());
}
let fields = acroform.try_get_key(b"/Fields")?;
if !fields.try_is_array()? {
return Ok(());
}
let replacement = ObjectHandle::array(Vec::new());
let replacement = if fields.is_indirect() {
primary.make_indirect_object_handle(replacement)?
} else {
replacement
};
let fields = collect_primary_fields(primary, selected_pages)?;
replacement.try_set_array_items(fields)?;
if replacement.try_array_len()?.unwrap_or_default() == 0 {
catalog.remove_key(b"/AcroForm");
} else {
acroform.replace_key(b"/Fields", replacement)?;
}
Ok(())
}
impl PageSpecInput {
#[must_use]
pub(crate) const fn new(source_index: usize, range: PageRange) -> Self {
Self {
source_index,
range,
}
}
}
#[cfg(test)]
fn merge_preserving_primary_into<R: Read + Seek, T: Read + Seek>(
inputs: &mut [MergeInput<'_, R>],
remove_resources: &[bool],
target: Pdf<T>,
object_stream_mode: ObjectStreamMode,
) -> Result<Pdf<T>> {
merge_documents_for_page_specs_into(inputs, remove_resources, true, target, object_stream_mode)
}
type OrderedPage = (usize, usize);
#[derive(Debug)]
#[cfg(test)]
struct PageSpecWriterProvenance {
order: BTreeMap<ObjectRef, WriterObjectOrderKey>,
next_original: ObjectRef,
page_allocations: Vec<Vec<ObjectRef>>,
}
#[cfg(test)]
fn restore_occurrence_writer_provenance<T: Read + Seek + 'static, R: Read + Seek + 'static>(
merged: &mut Pdf<T>,
sources: &mut [Pdf<R>],
source_page_refs: &[Vec<ObjectRef>],
grouped_pages: &[Vec<usize>],
ordered_pages: &[OrderedPage],
grouped_refs: &[ObjectRef],
offsets: &[usize],
) -> Result<Option<PageSpecWriterProvenance>> {
let Some(existing_order) = merged.writer_object_order.clone() else {
return Ok(None);
};
let mut page_allocations = Vec::with_capacity(ordered_pages.len());
let mut seen_pages: Vec<BTreeSet<ObjectRef>> = vec![BTreeSet::new(); sources.len()];
for &(source_index, group_index) in ordered_pages {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
let duplicate = !seen_pages[source_index].insert(source_page_ref);
let mut allocations = Vec::new();
if source_index != 0 && !duplicate {
let source_id = sources[source_index].unique_id();
if let Some((_, target_refs)) = merged
.foreign_page_copy_orders
.get(&source_id)
.and_then(|groups| {
groups
.iter()
.find(|(source_ref, _)| *source_ref == source_page_ref)
})
{
allocations.extend(target_refs.iter().copied());
} }
if duplicate {
allocations.push(grouped_refs[offsets[source_index] + group_index]);
}
page_allocations.push(allocations);
}
let Some(next_original) = page_allocations
.iter()
.flatten()
.map(|object_ref| merged.writer_original_object_ref(*object_ref))
.min()
else {
return Ok(None);
};
Ok(Some(PageSpecWriterProvenance {
order: existing_order,
next_original,
page_allocations,
}))
}
#[cfg(test)]
fn finalize_page_spec_writer_provenance<T: Read + Seek + 'static>(
merged: &mut Pdf<T>,
mut provenance: PageSpecWriterProvenance,
replay_allocations: &[Vec<ObjectRef>],
) -> Result<()> {
debug_assert_eq!(provenance.page_allocations.len(), replay_allocations.len());
for (page_allocations, replay_allocations) in
provenance.page_allocations.iter().zip(replay_allocations)
{
for &target_ref in page_allocations.iter().chain(replay_allocations) {
provenance.order.insert(
target_ref,
WriterObjectOrderKey::foreign_with_allocation_identity(
target_ref,
provenance.next_original,
),
);
provenance.next_original = ObjectRef::new(
provenance
.next_original
.number
.checked_add(1)
.ok_or_else(|| {
Error::Unsupported("page-selection provenance overflows u32".to_owned())
})?,
provenance.next_original.generation,
);
}
}
merged.set_writer_object_order(provenance.order);
Ok(())
}
#[cfg(test)]
type JobLabelEntry = (i64, LabelRange, bool);
fn collect_primary_fields<T: Read + Seek>(
merged: &mut Pdf<T>,
pages: &[ObjectRef],
) -> Result<Vec<ObjectHandle>> {
let mut field_identities = BTreeSet::<QpdfObjGen>::new();
let mut candidate_fields = Vec::new();
{
let mut acroform = AcroFormDocumentHelper::new_for_field_tree(merged)?;
for &page_ref in pages {
let widgets = acroform.get_widget_annotations_for_page(page_ref)?;
for widget in widgets {
let field = acroform.get_field_for_annotation_handle(widget)?;
if field.qpdf_obj_gen().is_some_and(QpdfObjGen::is_indirect) {
candidate_fields.push(field);
} }
}
}
for field in candidate_fields {
let (top_level, _) =
FormFieldObjectHelper::from_object_handle(field, merged).get_top_level_field()?;
if let Some(object_gen) = top_level.qpdf_obj_gen().filter(|gen| gen.is_indirect()) {
field_identities.insert(object_gen);
}
}
let primary_order = {
let mut acroform = AcroFormDocumentHelper::new_for_field_tree(merged)?;
acroform.top_level_field_handles()?
};
Ok(primary_order
.into_iter()
.filter(|field| {
field
.qpdf_obj_gen()
.is_some_and(|gen| gen.is_indirect() && field_identities.contains(&gen))
})
.collect())
}
#[cfg(test)]
fn replace_merged_fields<T: Read + Seek>(
merged: &mut Pdf<T>,
fields: Vec<ObjectHandle>,
had_fields_array: bool,
) -> Result<()> {
if !had_fields_array {
return Ok(());
}
let Some(root_ref) = merged.root_ref() else {
return Ok(());
};
let root = merged.get_object_handle(root_ref);
let acroform = root.try_get_key(b"/AcroForm")?;
acroform.try_dereference()?;
if !acroform.try_is_dictionary()? {
return Ok(());
}
let fields_holder = acroform.try_get_key(b"/Fields")?;
let replacement = ObjectHandle::array(fields);
let replacement = if fields_holder.is_indirect() {
merged.make_indirect_object_handle(replacement)?
} else {
replacement
};
acroform.replace_key(b"/Fields", replacement)?;
Ok(())
}
#[cfg(test)]
fn remove_empty_acroform_after_replay<T: Read + Seek>(
merged: &mut Pdf<T>,
had_fields_array: bool,
) -> Result<()> {
if !had_fields_array {
return Ok(());
}
let Some(root_ref) = merged.root_ref() else {
return Ok(());
};
let root = merged.get_object_handle(root_ref);
let acroform = root.try_get_key(b"/AcroForm")?;
acroform.try_dereference()?;
if !acroform.try_is_dictionary()? {
return Ok(());
}
let fields = acroform.try_get_key(b"/Fields")?;
fields.try_dereference()?;
if fields.try_array_len()?.is_some_and(|length| length == 0) {
root.remove_key(b"/AcroForm");
}
Ok(())
}
#[cfg(test)]
fn clear_grouped_foreign_fields_for_replay<T: Read + Seek>(merged: &mut Pdf<T>) -> Result<()> {
let Some(root_ref) = merged.root_ref() else {
return Ok(());
};
let root = merged.get_object_handle(root_ref);
let acroform = root.try_get_key(b"/AcroForm")?;
acroform.try_dereference()?;
if !acroform.try_is_dictionary()? {
return Ok(());
}
let fields = acroform.try_get_key(b"/Fields")?;
fields.try_dereference()?;
if !fields.try_is_array()? {
return Ok(());
}
acroform.replace_key(b"/Fields", ObjectHandle::array(Vec::new()))?;
Ok(())
}
#[cfg(test)]
fn set_annotation_page_refs<T: Read + Seek>(
merged: &mut Pdf<T>,
page_ref: ObjectRef,
first_output_page: ObjectRef,
) -> Result<()> {
let annotations = PageObjectHelper::new(page_ref, merged).get_annotation_handles(None)?;
let page = merged.get_object_handle(first_output_page);
for annotation in annotations {
if annotation.try_has_key(b"/P")? {
annotation.replace_key(b"/P", page.clone())?;
}
}
Ok(())
}
#[cfg(test)]
fn rebuild_acroform_in_final_page_order<R: Read + Seek + 'static, T: Read + Seek>(
merged: &mut Pdf<T>,
sources: &mut [Pdf<R>],
source_page_refs: &[Vec<ObjectRef>],
grouped_pages: &[Vec<usize>],
ordered_pages: &[OrderedPage],
final_refs: &[ObjectRef],
) -> Result<Vec<Vec<ObjectRef>>> {
debug_assert_eq!(ordered_pages.len(), final_refs.len());
let primary_field_names: BTreeSet<Vec<u8>> = match sources.first_mut() {
Some(primary) => source_top_level_field_names(primary)?
.into_iter()
.filter_map(|(_, name)| name)
.collect(),
None => BTreeSet::new(),
};
let mut first_output_for_source_page: Vec<BTreeMap<ObjectRef, ObjectRef>> =
vec![BTreeMap::new(); sources.len()];
let mut replay_allocations = Vec::with_capacity(ordered_pages.len());
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
first_output_for_source_page[source_index]
.entry(source_page_ref)
.or_insert(final_refs[output_index]);
}
let primary_first_pages: Vec<ObjectRef> = ordered_pages
.iter()
.enumerate()
.filter_map(|(output_index, &(source_index, group_index))| {
if source_index != 0 {
return None;
}
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
(first_output_for_source_page[source_index].get(&source_page_ref)
== Some(&final_refs[output_index]))
.then_some(final_refs[output_index])
})
.collect();
let had_fields_array = match sources.first_mut() {
Some(primary) => primary.acroform()?.has_fields_array()?,
None => false,
};
let primary_fields = collect_primary_fields(merged, &primary_first_pages)?;
replace_merged_fields(merged, primary_fields, had_fields_array)?;
if !had_fields_array {
clear_grouped_foreign_fields_for_replay(merged)?;
}
for (source_index, mappings) in first_output_for_source_page.iter().enumerate() {
if mappings.is_empty() {
continue;
}
let source_id = sources[source_index].unique_id();
let mut object_map = merged.take_foreign_object_map(source_id);
for (&source, &target) in mappings {
object_map.insert(QpdfObjGen::try_from_object_ref(source)?, target);
}
merged.set_foreign_object_map(source_id, object_map);
}
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source_page_ref = source_page_refs[source_index][source_page_index];
let first_output_page = first_output_for_source_page[source_index]
.get(&source_page_ref)
.copied()
.ok_or(Error::Missing("first output page for source page"))?;
let is_primary_first = source_index == 0 && first_output_page == final_refs[output_index];
if is_primary_first {
set_annotation_page_refs(merged, final_refs[output_index], first_output_page)?;
replay_allocations.push(Vec::new());
continue;
}
let destination_page = merged.get_object_handle(final_refs[output_index]);
destination_page.remove_key(b"/Annots");
let allocation_checkpoint = merged.allocation_checkpoint();
if source_index == 0 {
let source_page = merged.get_object_handle(first_output_page);
PageObjectHelper::new(final_refs[output_index], merged)
.copy_annotations_with_field_tree_only(
source_page,
Matrix::default(),
&primary_field_names,
)?; } else {
let source_page = sources[source_index].get_object_handle(source_page_ref);
let source = &mut sources[source_index];
let mut destination = PageObjectHelper::new(final_refs[output_index], merged);
destination.copy_annotations_from_with_field_tree_only(
source_page,
Matrix::default(),
source,
&primary_field_names,
)?; }
replay_allocations.push(merged.allocated_object_refs_after(allocation_checkpoint));
}
remove_empty_acroform_after_replay(merged, had_fields_array)?;
Ok(replay_allocations)
}
#[cfg(test)]
fn merge_job_label_ranges(ranges: Vec<JobLabelEntry>) -> Vec<JobLabelEntry> {
let mut out: Vec<JobLabelEntry> = Vec::with_capacity(ranges.len());
for (idx, range, prefix_present) in ranges {
if let Some((previous_idx, previous, previous_prefix_present)) = out.last() {
let expected_start = idx
.checked_sub(*previous_idx)
.and_then(|gap| previous.start.checked_add(gap));
if let Some(expected_start) = expected_start {
if previous.style == range.style
&& previous.prefix == range.prefix
&& *previous_prefix_present == prefix_present
&& range.start == expected_start
{
continue;
}
}
}
out.push((idx, range, prefix_present));
}
out
}
#[cfg(test)]
fn handle_page_specs<R: Read + Seek + 'static>(
job: &mut super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
preserve_unreferenced: bool,
) -> Result<Pdf<Cursor<Vec<u8>>>> {
handle_page_specs_into(
job,
sources,
specs,
collate,
resource_mode,
preserve_unreferenced,
Pdf::empty()?,
ObjectStreamMode::Preserve,
)
}
#[allow(clippy::too_many_arguments)]
#[cfg(test)]
fn handle_page_specs_into<R: Read + Seek + 'static, T: Read + Seek + 'static>(
job: &mut super::QPDFJob,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
preserve_unreferenced: bool,
target: Pdf<T>,
object_stream_mode: ObjectStreamMode,
) -> Result<Pdf<T>> {
if sources.is_empty() {
return Err(Error::Unsupported(
"--pages: a primary source document is required".into(),
));
}
if specs.is_empty() {
return Err(Error::Unsupported(
"--pages: no page specifications were supplied".into(),
));
}
let mut plans = Vec::with_capacity(specs.len());
for (spec_index, spec) in specs.iter().enumerate() {
let source = sources.get_mut(spec.source_index).ok_or_else(|| {
Error::Unsupported(format!(
"--pages: specification {spec_index} refers to missing source {}",
spec.source_index
))
})?;
let source_name = source.input_source_description();
crate::PageDocumentHelper::new(source).get_all_pages()?;
let plan = PagePlan::build(source, &spec.range)
.map_err(|error| page_spec_error(&source_name, spec.source_index, spec_index, error))?;
plans.push(plan);
}
let collate_values = collate_values_for_specs(collate, plans.len())?;
let mut grouped_pages: Vec<Vec<usize>> = vec![Vec::new(); sources.len()];
let mut ordered_pages: Vec<OrderedPage> = Vec::new();
let mut append_page = |source_index: usize, page_index_1based: u32| {
let page_index = page_index_1based as usize - 1;
let group_index = grouped_pages[source_index].len();
grouped_pages[source_index].push(page_index);
ordered_pages.push((source_index, group_index));
};
if plans.len() > 1 {
if let Some(values) = collate_values.as_deref() {
let mut cursors = vec![0usize; plans.len()];
loop {
let mut emitted = false;
for (spec_index, plan) in plans.iter().enumerate() {
let start = cursors[spec_index];
let end = start
.saturating_add(values[spec_index])
.min(plan.pages().len());
for page in &plan.pages()[start..end] {
append_page(specs[spec_index].source_index, page.index_1based);
}
if end > start {
emitted = true;
}
cursors[spec_index] = end;
}
if !emitted {
break;
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
} else {
for (spec_index, plan) in plans.iter().enumerate() {
for page in plan.pages() {
append_page(specs[spec_index].source_index, page.index_1based);
}
}
}
let remove_resources = report_page_spec_diagnostics(job, sources, specs, resource_mode)?;
let mut any_page_labels = false;
let referenced_source_indices: BTreeSet<_> =
specs.iter().map(|spec| spec.source_index).collect();
for source_index in referenced_source_indices {
any_page_labels |= sources[source_index].page_labels().has_page_labels()?;
}
let mut label_entries: Vec<RawPageLabelEntry> = Vec::new();
if any_page_labels {
label_entries.reserve(ordered_pages.len());
for (output_index, &(source_index, group_index)) in ordered_pages.iter().enumerate() {
let source_page_index = grouped_pages[source_index][group_index];
let source = &mut sources[source_index];
let source_id = source.unique_id();
let entries = source
.page_labels()
.labels_for_selection_raw(&[source_page_index as i64], output_index as i64)?;
if let Some((index, label)) = entries.into_iter().next() {
label_entries.push(RawPageLabelEntry {
index,
source_id,
source_is_primary: source_index == 0,
label,
});
}
}
}
let source_page_refs: Vec<Vec<ObjectRef>> = sources
.iter_mut()
.enumerate()
.map(|(source_index, source)| {
if source_index != 0 && grouped_pages[source_index].is_empty() {
Ok(Vec::new())
} else {
crate::pages::page_refs(source)
}
})
.collect::<Result<_>>()?;
let mut merge_inputs: Vec<MergeInput<'_, R>> = sources
.iter_mut()
.zip(grouped_pages.iter())
.map(|(source, pages)| MergeInput {
source,
pages: pages.clone(),
})
.collect();
let mut merged = if preserve_unreferenced {
merge_preserving_primary_into(
&mut merge_inputs,
&remove_resources,
target,
object_stream_mode,
)? } else {
merge_documents_for_page_specs_into(
&mut merge_inputs,
&remove_resources,
false,
target,
object_stream_mode,
)? };
drop(merge_inputs);
let grouped_refs = crate::pages::page_refs(&mut merged)?;
if grouped_refs.len() != ordered_pages.len() {
return Err(Error::Unsupported(format!(
"--pages: merge produced {} pages for {} selected pages",
grouped_refs.len(),
ordered_pages.len()
)));
}
let offsets: Vec<usize> = grouped_pages
.iter()
.scan(0usize, |offset, pages| {
let current = *offset;
*offset += pages.len();
Some(current)
})
.collect();
let occurrence_provenance = restore_occurrence_writer_provenance(
&mut merged,
sources,
&source_page_refs,
&grouped_pages,
&ordered_pages,
&grouped_refs,
&offsets,
)?; let final_refs: Vec<_> = ordered_pages
.iter()
.map(|&(source_index, group_index)| grouped_refs[offsets[source_index] + group_index])
.collect();
if final_refs != grouped_refs {
crate::pages::tree_rebuild::rebuild_page_tree(&mut merged, &final_refs)?;
}
let replay_allocations = rebuild_acroform_in_final_page_order(
&mut merged,
sources,
&source_page_refs,
&grouped_pages,
&ordered_pages,
&final_refs,
)?; if let Some(occurrence_provenance) = occurrence_provenance {
finalize_page_spec_writer_provenance(
&mut merged,
occurrence_provenance,
&replay_allocations,
)?; }
if any_page_labels {
let folded = merge_adjacent_raw_page_labels(label_entries)?;
let copied = copy_raw_page_label_entries(&mut merged, &folded)?;
record_primary_label_provenance(&mut merged, &folded);
merged
.page_labels()
.write_reconstructed_labels_raw(&copied)?;
}
if !crate::PageDocumentHelper::new(&mut merged)
.get_all_pages()?
.is_empty()
{
crate::PageDocumentHelper::new(&mut merged).push_inherited_attributes_to_pages()?;
}
for source in sources.iter() {
job.record_document_warnings(source);
}
job.record_document_warnings(&merged);
Ok(merged)
}
impl super::QPDFJob {
pub fn prune_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
mode: RemoveUnreferencedResources,
) -> Result<()> {
super::page_subset::prune_after_subset(pdf, mode)
}
pub fn prune_acroform_after_subset<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
) -> Result<()> {
super::acroform_field_prune::prune_acroform_after_subset(pdf, result)
}
pub fn complete_in_place_page_selection<R: Read + Seek>(
pdf: &mut Pdf<R>,
result: &RebuildResult,
prune_mode: RemoveUnreferencedResources,
) -> Result<()> {
super::outline_dest_remap::remap_outline_and_dests(pdf, result)?;
let objr_obj_targets = crate::drop_struct_elem_dangling_pg(pdf, result)?;
crate::drop_thread_bead_dangling_p(pdf, result)?;
crate::drop_objr_obj_annot_dangling_p(pdf, result, &objr_obj_targets)?;
super::page_subset::prune_after_subset(pdf, prune_mode)?;
super::acroform_field_prune::prune_acroform_after_subset(pdf, result)
}
pub(crate) fn handle_page_specs<R: Read + Seek + 'static>(
&mut self,
sources: &mut [Pdf<R>],
specs: &[PageSpecInput],
collate: Option<&[usize]>,
resource_mode: RemoveUnreferencedResources,
) -> Result<(RebuildResult, RemoveUnreferencedResources)> {
let keep_files_open = self.keep_files_open_for_page_specs(specs);
for (source_index, source) in sources.iter().enumerate().skip(1) {
if specs.iter().any(|spec| spec.source_index == source_index) {
source.set_input_source_stay_open(keep_files_open);
}
}
if sources.len() == 1 && specs.iter().all(|spec| spec.source_index == 0) {
let source = sources.first_mut().ok_or_else(|| {
Error::Unsupported("--pages: a primary source is required".to_owned())
})?;
return handle_single_source_page_specs(self, source, specs, collate, resource_mode);
}
handle_multi_source_page_specs_in_place(self, sources, specs, collate, resource_mode)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::job::QPDFJob;
use crate::page_label_document_helper::LabelStyle;
use crate::pipeline::{Pipeline, PipelineHandle, PipelineResult};
use crate::{ObjectHandle, ObjectStreamMode, PdfWriter, QPDFLogger};
use std::io::Cursor;
use std::sync::{Arc, Mutex};
struct RecordingInfoSink {
bytes: Arc<Mutex<Vec<u8>>>,
}
impl Pipeline for RecordingInfoSink {
fn identifier(&self) -> &str {
"page-spec info capture"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
self.bytes.lock().unwrap().extend_from_slice(data);
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
fn verbose_job() -> (QPDFJob, Arc<Mutex<Vec<u8>>>) {
let bytes = Arc::new(Mutex::new(Vec::new()));
let logger = QPDFLogger::create();
logger.set_info(Some(PipelineHandle::new(RecordingInfoSink {
bytes: Arc::clone(&bytes),
})));
logger.set_warn(Some(logger.discard()));
logger.set_error(Some(logger.discard()));
let mut job = QPDFJob::new();
job.set_logger(logger);
job.set_message_prefix("qpdf");
job.set_verbose(true);
(job, bytes)
}
#[test]
fn recording_info_sink_implements_the_pipeline_contract() {
let bytes = Arc::new(Mutex::new(Vec::new()));
let mut sink = RecordingInfoSink {
bytes: Arc::clone(&bytes),
};
assert_eq!(sink.identifier(), "page-spec info capture");
sink.write(b"probe\n").unwrap();
sink.finish().unwrap();
assert_eq!(&*bytes.lock().unwrap(), b"probe\n");
}
fn three_page_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/three-page.pdf").to_vec(),
)
.expect("open three-page fixture")
}
fn direct_root_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/direct-root-one-page.pdf").to_vec(),
)
.expect("open direct-root fixture")
}
fn direct_root_with_acroform_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut pdf = direct_root_pdf();
pdf.root_handle()
.expect("direct Catalog")
.replace_key(
b"/AcroForm",
ObjectHandle::dictionary(vec![(
b"/NeedAppearances".to_vec(),
ObjectHandle::boolean(true),
)]),
)
.expect("install direct AcroForm");
pdf
}
fn acroform_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/acroform-sig-widget.pdf").to_vec(),
)
.expect("open AcroForm fixture")
}
fn inherited_resources_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/inherited-resources-one-page.pdf")
.to_vec(),
)
.expect("open inherited-resources fixture")
}
fn link_annot_no_acroform_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/compat/link-annot-no-acroform.pdf").to_vec(),
)
.expect("open link-annot-no-acroform fixture")
}
#[test]
fn page_spec_report_reuses_one_decision_per_source_identity() {
let (job, output) = verbose_job();
let inherited = inherited_resources_pdf();
let mut duplicate_identity = three_page_pdf();
duplicate_identity.unique_id = inherited.unique_id;
let range = PageRange::parse_numrange("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [inherited, duplicate_identity];
let decisions = report_page_spec_diagnostics(
&job,
&mut sources,
&specs,
RemoveUnreferencedResources::Auto,
)
.expect("resource report");
assert_eq!(decisions, [true, true]);
let output = output.lock().unwrap().clone();
assert!(
output
.windows(b"found resources in non-leaf page node".len())
.any(|window| window == b"found resources in non-leaf page node"),
"verbose report must include the first finding: {output:?}"
);
assert_eq!(
output
.windows(b"checking for shared resources".len())
.filter(|window| window == b"checking for shared resources")
.count(),
1,
"a repeated source identity is preflighted once: {output:?}"
);
}
#[test]
fn page_spec_report_rejects_a_missing_source_after_reporting_preflight() {
let (job, _output) = verbose_job();
let mut source = three_page_pdf();
let specs = [PageSpecInput::new(
1,
PageRange::parse_numrange("1").expect("one-page range"),
)];
assert!(matches!(
report_page_spec_diagnostics(
&job,
std::slice::from_mut(&mut source),
&specs,
RemoveUnreferencedResources::Auto,
),
Err(Error::Unsupported(message))
if message == "--pages: specification refers to missing source 1"
));
}
#[test]
fn empty_primary_keeps_qpdf_map_key_separate_from_display_name() {
let mut job = QPDFJob::new();
let empty = job.create_empty_document().expect("empty primary");
let description = empty.input_source_description();
assert_eq!(description, b"empty PDF");
assert!(job.page_spec_source_sort_key(0, &description).is_empty());
assert_eq!(job.page_spec_source_sort_key(1, b"empty PDF"), b"empty PDF");
}
#[test]
fn page_spec_job_keeps_the_primary_document_as_multi_source_owner() {
let primary = three_page_pdf();
let secondary = inherited_resources_pdf();
let primary_root = primary.root_ref();
let range = PageRange::parse_numrange("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [primary, secondary];
let mut job = QPDFJob::new();
let (_result, _prune_mode) = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
)
.expect("multi-source page job");
assert_eq!(sources[0].root_ref(), primary_root);
assert_eq!(crate::pages::page_refs(&mut sources[0]).unwrap().len(), 2);
}
#[test]
fn page_spec_job_accepts_a_direct_root_primary_with_a_secondary_source() {
let primary = direct_root_pdf();
let secondary = three_page_pdf();
let range = PageRange::parse_numrange("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [primary, secondary];
let mut job = QPDFJob::new();
let mut merged = handle_page_specs_into(
&mut job,
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
Pdf::empty().expect("empty merge target"),
ObjectStreamMode::Preserve,
)
.expect("direct-root primary must not panic during page merge");
assert_eq!(crate::pages::page_refs(&mut merged).unwrap().len(), 2);
}
#[test]
fn page_spec_job_copies_catalog_values_from_a_direct_root_primary() {
let primary = direct_root_with_acroform_pdf();
let secondary = three_page_pdf();
let range = PageRange::parse_numrange("1").expect("one-page range");
let specs = [
PageSpecInput::new(0, range.clone()),
PageSpecInput::new(1, range),
];
let mut sources = [primary, secondary];
let mut job = QPDFJob::new();
let mut merged = handle_page_specs_into(
&mut job,
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
Pdf::empty().expect("empty merge target"),
ObjectStreamMode::Preserve,
)
.expect("direct-root Catalog values must be copied");
let catalog = merged.root_handle().expect("merged Catalog");
let acroform = catalog.try_get_key(b"/AcroForm").expect("copied /AcroForm");
assert!(acroform.try_is_dictionary().unwrap());
assert_eq!(
acroform
.try_get_key(b"/NeedAppearances")
.unwrap()
.as_boolean(),
Some(true)
);
}
fn labelled_pdf() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open_mem_owned(
include_bytes!("../../../../tests/fixtures/json-diff/direct-outlines.pdf").to_vec(),
)
.expect("open labelled fixture")
}
fn assemble_pdf(objects: &[&[u8]]) -> Vec<u8> {
use std::io::Write;
let mut bytes = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::with_capacity(objects.len());
for object in objects {
offsets.push(bytes.len());
bytes.extend_from_slice(object);
}
let start_xref = bytes.len();
let _ = writeln!(&mut bytes, "xref\n0 {}", objects.len() + 1);
bytes.extend_from_slice(b"0000000000 65535 f \n");
for &offset in &offsets {
let _ = writeln!(&mut bytes, "{offset:010} 00000 n ");
}
let _ = writeln!(
&mut bytes,
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{}\n%%EOF",
objects.len() + 1,
start_xref
);
bytes
}
fn raw_generation_orphan_pdf() -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = b"%PDF-1.4\n".to_vec();
let catalog_offset = bytes.len();
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let pages_offset = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n");
let page_offset = bytes.len();
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let orphan_offset = bytes.len();
bytes.extend_from_slice(b"5 65536 obj\n45\nendobj\n");
let xref_offset = bytes.len();
bytes.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
bytes.extend_from_slice(format!("{catalog_offset:010} 00000 n \n").as_bytes());
bytes.extend_from_slice(format!("{pages_offset:010} 00000 n \n").as_bytes());
bytes.extend_from_slice(format!("{page_offset:010} 00000 n \n").as_bytes());
bytes.extend_from_slice(b"0000000000 00000 f \n");
bytes.extend_from_slice(format!("{orphan_offset:010} 65536 n \n").as_bytes());
bytes.extend_from_slice(
format!("trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n{xref_offset}\n%%EOF\n")
.as_bytes(),
);
Pdf::open_mem_owned(bytes).expect("open raw-generation orphan fixture")
}
fn acroform_no_fields_array_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = assemble_pdf(&[
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/AcroForm << /NeedAppearances true >> >>\nendobj\n",
b"2 0 obj\n<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n",
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
]);
Pdf::open_mem_owned(bytes).expect("open AcroForm-no-fields-array fixture")
}
fn acroform_all_fields_on_page_two_pdf() -> Pdf<Cursor<Vec<u8>>> {
let bytes = assemble_pdf(&[
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/AcroForm << /Fields [5 0 R] /NeedAppearances true >> >>\nendobj\n",
b"2 0 obj\n<< /Type /Pages /Count 2 /Kids [3 0 R 4 0 R] >>\nendobj\n",
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
b"4 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
/Annots [5 0 R] >>\nendobj\n",
b"5 0 obj\n<< /Type /Annot /Subtype /Widget /FT /Tx /T (Orphan) \
/Rect [0 0 10 10] /P 4 0 R >>\nendobj\n",
]);
Pdf::open_mem_owned(bytes).expect("open AcroForm-orphan-field fixture")
}
fn selected_page_count(pdf: &mut Pdf<Cursor<Vec<u8>>>) -> usize {
crate::pages::page_refs(pdf)
.expect("read merged page tree")
.len()
}
fn selected_indices(
source: &mut Pdf<Cursor<Vec<u8>>>,
specs: &[PageSpecInput],
collate: Option<&[usize]>,
) -> Vec<u32> {
select_single_source_pages(source, specs, collate)
.expect("valid page specifications")
.into_iter()
.map(|page| page.index_1based)
.collect()
}
fn resolved_object(pdf: &mut Pdf<Cursor<Vec<u8>>>, object_ref: ObjectRef) -> ObjectHandle {
let object = pdf.get_object_handle(object_ref);
object.try_is_scalar().expect("resolve object handle");
object
}
fn resolved_key(owner: &ObjectHandle, key: &[u8]) -> ObjectHandle {
let value = owner.try_get_key(key).unwrap();
value.try_is_scalar().expect("resolve child handle");
value
}
fn pdf_without_root() -> Pdf<Cursor<Vec<u8>>> {
let mut pdf = Pdf::empty().expect("empty PDF");
pdf.trailer().remove_key(b"/Root");
assert!(pdf.root_ref().is_none());
pdf
}
#[test]
fn page_spec_error_keeps_non_range_errors_in_the_existing_context() {
let error = page_spec_error(b"input.pdf", 2, 3, Error::Missing("/Root"));
assert!(matches!(
error,
Error::Unsupported(message)
if message == "--pages: source 2 specification 3: missing required PDF entry: /Root"
));
let unrelated = Error::SystemBytes(b"not a numeric range error".to_vec());
assert!(qpdf_page_range_error(b"input.pdf", &unrelated).is_none());
}
#[test]
fn rebuild_acroform_ignores_a_missing_merged_root() {
let mut merged = pdf_without_root();
let mut sources: Vec<Pdf<Cursor<Vec<u8>>>> = Vec::new();
rebuild_acroform_in_final_page_order(&mut merged, &mut sources, &[], &[], &[], &[])
.expect("a missing merged root has no AcroForm to rebuild");
}
#[test]
fn replace_merged_fields_ignores_a_missing_merged_root_when_gated_open() {
let mut merged = pdf_without_root();
replace_merged_fields(&mut merged, Vec::new(), true)
.expect("a missing merged root has no AcroForm to rebuild, even past the gate");
remove_empty_acroform_after_replay(&mut merged, true)
.expect("a missing merged root has no AcroForm to remove");
}
#[test]
fn replace_merged_fields_defers_empty_acroform_removal_until_replay_finishes() {
let mut merged = acroform_pdf();
replace_merged_fields(&mut merged, Vec::new(), true)
.expect("an empty survivor list leaves the replay base in place");
let root_ref = merged.root_ref().expect("root");
assert!(
!resolved_object(&mut merged, root_ref)
.try_get_key(b"/AcroForm")
.unwrap()
.is_null(),
"qpdf keeps /AcroForm alive through foreign annotation replay"
);
remove_empty_acroform_after_replay(&mut merged, true)
.expect("final replay cleanup removes an empty /AcroForm");
assert!(
resolved_object(&mut merged, root_ref)
.try_get_key(b"/AcroForm")
.unwrap()
.is_null(),
"qpdf removes /AcroForm after the filtered field count reaches zero"
);
}
#[test]
fn rebuild_acroform_propagates_annotation_copy_errors() {
let mut merged = three_page_pdf();
let invalid_final_ref = ObjectRef::new(999, 0);
let mut sources = vec![three_page_pdf()];
let source_page_refs = sources
.iter_mut()
.map(crate::pages::page_refs)
.collect::<Result<Vec<_>>>()
.unwrap();
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&source_page_refs,
&[vec![0]],
&[(0, 0)],
&[invalid_final_ref],
)
.expect_err("an invalid destination page must escape the foreign copy route");
}
#[test]
fn rebuild_acroform_uses_foreign_copy_route_for_secondary_acroform() {
let mut merged = three_page_pdf();
let mut sources = vec![three_page_pdf(), acroform_pdf()];
let source_page_refs = sources
.iter_mut()
.map(crate::pages::page_refs)
.collect::<Result<Vec<_>>>()
.unwrap();
rebuild_acroform_in_final_page_order(
&mut merged,
&mut sources,
&source_page_refs,
&[vec![], vec![0]],
&[(1, 0)],
&[ObjectRef::new(3, 0)],
)
.expect("a secondary AcroForm page must use the foreign copy route");
}
#[test]
fn collect_primary_fields_ignores_direct_field_handles() {
let mut merged = three_page_pdf();
let page_ref = crate::pages::page_refs(&mut merged).unwrap()[0];
let page = merged.get_object_handle(page_ref);
let widget = ObjectHandle::dictionary(vec![
(b"Type".to_vec(), ObjectHandle::name(b"Annot".to_vec())),
(b"Subtype".to_vec(), ObjectHandle::name(b"Widget".to_vec())),
]);
page.replace_key(b"/Annots", ObjectHandle::array(vec![widget]))
.unwrap();
assert!(
collect_primary_fields(&mut merged, &[page_ref])
.unwrap()
.is_empty(),
"direct field handles have no stable top-level object identity"
);
}
#[test]
fn handle_page_specs_default_materializes_inherited_resources_like_qpdf() {
let mut sources = vec![inherited_resources_pdf()];
let specs = [PageSpecInput::new(
0,
PageRange::parse_numrange("1,1").unwrap(),
)];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge inherited-resources page");
let page_refs = crate::pages::page_refs(&mut merged).expect("read merged page tree");
assert_eq!(page_refs.len(), 2);
for page_ref in page_refs {
let page = resolved_object(&mut merged, page_ref);
assert!(
page.try_get_key(b"/Resources")
.unwrap()
.as_dictionary()
.is_some(),
"qpdf --pages default copies inherited /Resources directly onto the page"
);
}
}
#[test]
fn handle_page_specs_interleaves_duplicate_page_and_annotation_clone_allocation() {
let mut sources = vec![link_annot_no_acroform_pdf()];
let specs = [PageSpecInput::new(
0,
PageRange::parse_numrange("1,1,1").unwrap(),
)];
let mut job = QPDFJob::new();
let (_result, _prune_mode) = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
)
.expect("triple-duplicate single-source page job");
let pdf = &mut sources[0];
let page_refs = crate::pages::page_refs(pdf).expect("read merged page tree");
assert_eq!(page_refs.len(), 3);
let mut annot_refs = Vec::with_capacity(3);
for &page_ref in &page_refs {
let page = resolved_object(pdf, page_ref);
let annots = resolved_key(&page, b"/Annots");
let annot_array = annots.as_array().expect("/Annots is an array");
assert_eq!(annot_array.len(), 1);
let annot_ref = annot_array[0]
.object_ref()
.expect("annotation is an indirect reference");
annot_refs.push(annot_ref);
}
assert_eq!(
annot_refs.iter().collect::<BTreeSet<_>>().len(),
3,
"each duplicated page must get its own annotation clone: {annot_refs:?}"
);
for (page_ref, annot_ref) in page_refs.iter().skip(1).zip(annot_refs.iter().skip(1)) {
assert_eq!(
annot_ref.number,
page_ref.number + 1,
"annotation clone must be allocated immediately after its page clone, \
matching qpdf's interleaved order: pages={page_refs:?} annots={annot_refs:?}"
);
}
}
#[test]
fn handle_page_specs_preserve_unreferenced_keeps_raw_generation_objects() {
let mut sources = vec![raw_generation_orphan_pdf(), three_page_pdf()];
let raw_orphans = sources[0]
.canonical_live_object_handles()
.expect("enumerate raw-generation live objects");
assert!(
raw_orphans
.iter()
.any(|handle| { handle.qpdf_obj_gen() == Some(QpdfObjGen::new(5, 65_536)) }),
"canonical live handles must retain raw-generation source objects"
);
let mut allocated_raw = three_page_pdf();
allocated_raw
.replace_object(ObjectRef::new(9, 65_535), ObjectHandle::integer(45))
.expect("install document-allocated raw identity");
assert!(
allocated_raw
.canonical_live_object_handles()
.expect("enumerate allocated raw object")
.iter()
.any(|handle| { handle.qpdf_obj_gen() == Some(QpdfObjGen::new(9, 65_535)) }),
"canonical live handles must retain allocated raw identities"
);
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
PageSpecInput::new(1, PageRange::parse_numrange("1").unwrap()),
];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
true,
)
.expect("preserve-unreferenced page merge");
let mut writer = PdfWriter::new(&mut merged);
writer.set_static_id(true);
writer.set_object_stream_mode(ObjectStreamMode::Disable);
writer.set_preserve_unreferenced_objects(true);
writer.set_output_memory().expect("configure memory output");
writer.write().expect("preserve-unreferenced merge write");
let output = writer.get_buffer().expect("writer output");
assert_eq!(
output
.windows(b"\n45\n".len())
.filter(|window| *window == b"\n45\n")
.count(),
1,
"raw-generation primary orphan must be copied into the preserve target"
);
}
#[test]
fn handle_page_specs_skips_an_unused_secondary_source() {
let mut sources = vec![three_page_pdf(), pdf_without_root()];
let specs = [PageSpecInput::new(
0,
PageRange::parse_numrange("1").unwrap(),
)];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("an unused secondary source must not be read");
assert_eq!(selected_page_count(&mut merged), 1);
}
#[test]
fn qpdf_job_keeps_a_single_source_page_job_in_place() {
let mut sources = vec![three_page_pdf()];
let specs = [PageSpecInput::new(
0,
PageRange::parse_numrange("2").unwrap(),
)];
let mut job = QPDFJob::new();
let (result, _prune_mode) = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
)
.expect("single-source page job");
let pdf = &mut sources[0];
assert_eq!(result.new_kids.len(), 1);
assert_eq!(selected_page_count(pdf), 1);
assert!(pdf
.repair_diagnostics()
.entries()
.iter()
.all(|entry| !entry.message_string().contains("foreign object")));
}
#[test]
fn qpdf_job_in_place_page_job_copies_repeated_page_annotations() {
let mut sources = vec![acroform_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
];
let mut job = QPDFJob::new();
let (result, _prune_mode) = job
.handle_page_specs(
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
)
.expect("repeated single-source page job");
let pdf = &mut sources[0];
assert_eq!(result.new_kids.len(), 2);
assert_eq!(selected_page_count(pdf), 2);
}
#[test]
fn single_source_page_planner_reports_its_input_errors() {
let mut source = three_page_pdf();
assert!(select_single_source_pages(&mut source, &[], None).is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(
0,
PageRange::parse_numrange("1").unwrap()
)],
Some(&[1, 2]),
)
.is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(
1,
PageRange::parse_numrange("1").unwrap()
)],
None,
)
.is_err());
assert!(select_single_source_pages(
&mut source,
&[PageSpecInput::new(
0,
PageRange::parse_numrange("999").unwrap()
)],
None,
)
.is_err());
}
#[test]
fn collate_value_cardinality_matches_qpdf() {
assert_eq!(collate_values_for_specs(None, 2).unwrap(), None);
assert_eq!(collate_values_for_specs(Some(&[]), 2).unwrap(), None);
assert_eq!(
collate_values_for_specs(Some(&[2]), 2).unwrap(),
Some(vec![2, 2])
);
assert_eq!(
collate_values_for_specs(Some(&[2, 3]), 2).unwrap(),
Some(vec![2, 3])
);
assert!(collate_values_for_specs(Some(&[1, 2, 3]), 2).is_err());
}
#[test]
fn single_source_page_planner_applies_qpdf_collate_values_per_spec() {
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1-3").unwrap()),
PageSpecInput::new(0, PageRange::parse_numrange("1-3").unwrap()),
];
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[2, 1])),
vec![1, 2, 1, 3, 2, 3]
);
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[2])),
vec![1, 2, 1, 2, 3, 3]
);
let mut source = three_page_pdf();
assert!(selected_indices(&mut source, &specs, Some(&[0])).is_empty());
let mut source = three_page_pdf();
assert_eq!(
selected_indices(&mut source, &specs, Some(&[0, 1])),
vec![1, 2, 3]
);
let mut source = three_page_pdf();
let single_spec = [PageSpecInput::new(
0,
PageRange::parse_numrange("1").unwrap(),
)];
assert_eq!(
selected_indices(&mut source, &single_spec, Some(&[0])),
vec![1]
);
let mut source = three_page_pdf();
assert!(select_single_source_pages(&mut source, &specs, Some(&[1, 2, 3])).is_err());
}
#[test]
fn handle_page_specs_preserves_an_acroform_with_no_fields_array_across_sources() {
let mut sources = vec![acroform_no_fields_array_pdf(), three_page_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
PageSpecInput::new(1, PageRange::parse_numrange("1").unwrap()),
];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge across a fields-less-AcroForm primary and a secondary source");
let root_ref = merged.root_ref().expect("merged root");
let root = resolved_object(&mut merged, root_ref);
let acroform = resolved_key(&root, b"/AcroForm");
assert_eq!(
resolved_key(&acroform, b"/NeedAppearances").as_boolean(),
Some(true)
);
assert!(
acroform.try_get_key(b"/Fields").unwrap().is_null(),
"no /Fields array existed originally; the merge must not manufacture one"
);
}
#[test]
fn handle_page_specs_removes_acroform_when_the_only_field_page_is_unselected() {
let mut sources = vec![acroform_all_fields_on_page_two_pdf(), three_page_pdf()];
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
PageSpecInput::new(1, PageRange::parse_numrange("1").unwrap()),
];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("merge with the only AcroForm field on an unselected page");
let root_ref = merged.root_ref().expect("merged root");
assert!(
resolved_object(&mut merged, root_ref)
.try_get_key(b"/AcroForm")
.unwrap()
.is_null(),
"qpdf removes /AcroForm entirely once its filtered field count reaches zero"
);
}
#[test]
fn qpdf_job_owns_single_document_acroform_prune_boundary() {
let mut pdf = acroform_all_fields_on_page_two_pdf();
let original_pages = crate::pages::page_refs(&mut pdf).expect("original page refs");
let result = crate::pages::tree_rebuild::rebuild_page_tree(&mut pdf, &[original_pages[0]])
.expect("rebuild the selected page");
QPDFJob::prune_acroform_after_subset(&mut pdf, &result)
.expect("job-owned AcroForm pruning");
let root_ref = pdf.root_ref().expect("root");
assert!(
resolved_object(&mut pdf, root_ref)
.try_get_key(b"/AcroForm")
.unwrap()
.is_null(),
"the job boundary must remove an empty AcroForm after page selection"
);
}
#[test]
fn page_spec_input_constructor_keeps_source_and_range() {
let range = PageRange::parse_numrange("1-2").unwrap();
assert_eq!(PageSpecInput::new(3, range.clone()).source_index, 3);
assert_eq!(
PageSpecInput::new(3, range).range,
PageRange::parse_numrange("1-2").unwrap()
);
}
#[test]
fn handle_page_specs_rejects_invalid_job_inputs_and_selections() {
let mut no_sources: Vec<Pdf<Cursor<Vec<u8>>>> = Vec::new();
let spec = [PageSpecInput::new(
0,
PageRange::parse_numrange("1").unwrap(),
)];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut no_sources,
&spec,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&[],
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
let missing = [PageSpecInput::new(
1,
PageRange::parse_numrange("1").unwrap(),
)];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&missing,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
let mut sources = vec![three_page_pdf()];
let out_of_range = [PageSpecInput::new(
0,
PageRange::parse_numrange("99").unwrap(),
)];
assert!(handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&out_of_range,
None,
RemoveUnreferencedResources::Auto,
false,
)
.is_err());
}
#[test]
fn multi_source_handler_rejects_missing_sources_empty_specs_and_bad_source_indices() {
let mut no_sources: Vec<Pdf<Cursor<Vec<u8>>>> = Vec::new();
assert!(handle_multi_source_page_specs_in_place(
&mut QPDFJob::new(),
&mut no_sources,
&[],
None,
RemoveUnreferencedResources::Auto,
)
.is_err());
let mut sources = vec![three_page_pdf()];
assert!(handle_multi_source_page_specs_in_place(
&mut QPDFJob::new(),
&mut sources,
&[],
None,
RemoveUnreferencedResources::Auto,
)
.is_err());
let invalid_source = [PageSpecInput::new(
1,
PageRange::parse_numrange("1").expect("page range"),
)];
assert!(handle_multi_source_page_specs_in_place(
&mut QPDFJob::new(),
&mut sources,
&invalid_source,
None,
RemoveUnreferencedResources::Auto,
)
.is_err());
}
#[test]
fn multi_source_acroform_pruning_skips_a_non_dictionary_value() {
let mut pdf = three_page_pdf();
pdf.root_handle()
.expect("catalog")
.replace_key(b"/AcroForm", ObjectHandle::integer(1))
.expect("install malformed AcroForm");
prune_page_spec_acroform_fields(&mut pdf, &[])
.expect("qpdf skips field pruning without an AcroForm dictionary");
}
#[test]
fn handle_page_specs_accepts_an_empty_selection_like_qpdf() {
let mut sources = vec![three_page_pdf()];
let empty = [PageSpecInput::new(0, PageRange::empty())];
let mut merged = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&empty,
None,
RemoveUnreferencedResources::Auto,
false,
)
.expect("an empty page selection writes a 0-page document");
let page_refs = crate::pages::page_refs(&mut merged).expect("read the page tree");
assert!(page_refs.is_empty(), "got {page_refs:?}");
}
#[test]
fn handle_page_specs_restores_cross_source_order_and_collates() {
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let reversed = [
PageSpecInput::new(1, PageRange::parse_numrange("1").unwrap()),
PageSpecInput::new(0, PageRange::parse_numrange("1").unwrap()),
];
let mut reversed_output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&reversed,
None,
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
assert_eq!(selected_page_count(&mut reversed_output), 2);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let collated = [
PageSpecInput::new(0, PageRange::parse_numrange("1-2").unwrap()),
PageSpecInput::new(1, PageRange::parse_numrange("1-2").unwrap()),
];
let mut collated_output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&collated,
Some(&[1]),
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
assert_eq!(selected_page_count(&mut collated_output), 4);
}
#[test]
fn handle_page_specs_accepts_per_spec_and_zero_collate_values() {
let specs = [
PageSpecInput::new(0, PageRange::parse_numrange("1-3").unwrap()),
PageSpecInput::new(1, PageRange::parse_numrange("1-3").unwrap()),
];
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut per_spec = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[2, 3]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("per-spec collate values are valid");
assert_eq!(selected_page_count(&mut per_spec), 6);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut second_only = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[0, 1]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("zero collate value is valid");
assert_eq!(selected_page_count(&mut second_only), 3);
let mut sources = vec![three_page_pdf(), three_page_pdf()];
let mut empty = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
Some(&[0]),
RemoveUnreferencedResources::Auto,
false,
)
.expect("all-zero collate value is valid");
assert_eq!(selected_page_count(&mut empty), 0);
}
#[test]
fn handle_page_specs_reconstructs_qpdf_page_labels_with_empty_prefix() {
let mut sources = vec![labelled_pdf()];
let specs = [PageSpecInput::new(
0,
PageRange::parse_numrange("1-2").unwrap(),
)];
let mut output = handle_page_specs(
&mut QPDFJob::new(),
&mut sources,
&specs,
None,
RemoveUnreferencedResources::Auto,
false,
)
.unwrap();
let catalog_ref = output.root_ref().unwrap();
let catalog = resolved_object(&mut output, catalog_ref);
let page_labels = resolved_key(&catalog, b"/PageLabels");
let nums = resolved_key(&page_labels, b"/Nums")
.as_array()
.expect("merged PageLabels /Nums must be an array");
let first_label = nums.get(1).cloned().expect("first reconstructed label");
first_label
.try_is_scalar()
.expect("resolve first reconstructed label");
assert_eq!(
first_label.try_get_key(b"/P").unwrap().as_string(),
Some(Vec::new())
);
}
#[test]
fn merge_job_label_ranges_preserves_prefix_presence_and_checked_arithmetic() {
let decimal = |start| LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start,
};
let merged = merge_job_label_ranges(vec![(0, decimal(1), true), (1, decimal(2), true)]);
assert_eq!(merged.len(), 1);
let prefix_presence_mismatch =
merge_job_label_ranges(vec![(0, decimal(1), true), (1, decimal(2), false)]);
assert_eq!(prefix_presence_mismatch.len(), 2);
let underflow =
merge_job_label_ranges(vec![(1, decimal(1), false), (0, decimal(1), false)]);
assert_eq!(underflow.len(), 2);
let overflow =
merge_job_label_ranges(vec![(0, decimal(i64::MAX), false), (1, decimal(0), false)]);
assert_eq!(overflow.len(), 2);
}
}