use crate::{Error, PagePlan, PageRange, Pdf, PdfOpenOptions, Result};
use std::io::{BufReader, Read, Seek};
use std::path::PathBuf;
fn open_failure_source(error: &Error) -> &Error {
error
.open_failure()
.map_or(error, |(source, _diagnostics)| source)
}
#[derive(Debug, Clone)]
pub struct InputSpec {
pub path: PathBuf,
pub password: Option<Vec<u8>>,
pub range: PageRange,
}
impl InputSpec {
pub fn new(path: impl Into<PathBuf>, password: Option<Vec<u8>>, range: PageRange) -> Self {
Self {
path: path.into(),
password,
range,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CombinedPage {
pub source_index: usize,
pub page: super::page_plan::SelectedPage,
}
#[derive(Debug, Clone)]
pub struct CombinedPlan {
per_input: Vec<PagePlan>,
flat: Vec<CombinedPage>,
}
impl CombinedPlan {
pub fn build<R: Read + Seek>(inputs: Vec<(&mut Pdf<R>, PageRange)>) -> Result<Self> {
if inputs.is_empty() {
return Err(Error::Unsupported(
"at least one input document is required; got an empty input list".into(),
));
}
let mut per_input = Vec::with_capacity(inputs.len());
let mut flat = Vec::new();
for (source_index, (pdf, range)) in inputs.into_iter().enumerate() {
let plan = PagePlan::build(pdf, &range)
.map_err(|e| Error::Unsupported(format!("input {source_index}: {e}")))?;
for page in plan.pages() {
flat.push(CombinedPage {
source_index,
page: page.clone(),
});
}
per_input.push(plan);
}
Ok(Self { per_input, flat })
}
pub fn from_specs(specs: Vec<InputSpec>) -> Result<Self> {
if specs.is_empty() {
return Err(Error::Unsupported(
"at least one input document is required; got an empty input list".into(),
));
}
let mut opened: Vec<(Pdf<BufReader<std::fs::File>>, PageRange)> =
Vec::with_capacity(specs.len());
for (i, spec) in specs.iter().enumerate() {
let file = std::fs::File::open(&spec.path).map_err(|e| {
Error::Io(std::io::Error::new(
e.kind(),
format!("input {i}: cannot open '{}': {e}", spec.path.display()),
))
})?;
let reader = BufReader::new(file);
let opts = PdfOpenOptions {
password: spec.password.clone().unwrap_or_default(),
..PdfOpenOptions::default()
};
let pdf =
Pdf::open_with_options(reader, opts).map_err(|e| {
match open_failure_source(&e) {
Error::Encrypted(_) | Error::Io(_) => e,
_ => Error::Unsupported(format!(
"input {i} ('{}'): {e}",
spec.path.display()
)),
}
})?;
opened.push((pdf, spec.range.clone()));
}
let mut per_input = Vec::with_capacity(opened.len());
let mut flat = Vec::new();
for (source_index, (ref mut pdf, ref range)) in opened.iter_mut().enumerate() {
let plan = PagePlan::build(pdf, range)
.map_err(|e| Error::Unsupported(format!("input {source_index}: {e}")))?;
for page in plan.pages() {
flat.push(CombinedPage {
source_index,
page: page.clone(),
});
}
per_input.push(plan);
}
Ok(Self { per_input, flat })
}
pub fn base_index(&self) -> usize {
0
}
pub fn per_input_plans(&self) -> &[PagePlan] {
&self.per_input
}
pub fn flat_pages(&self) -> &[CombinedPage] {
&self.flat
}
pub fn total_page_count(&self) -> usize {
self.flat.len()
}
pub fn input_count(&self) -> usize {
self.per_input.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ObjectRef;
use crate::Pdf;
use std::io::Cursor;
fn build_n_page_pdf(n: u32) -> Vec<u8> {
assert!(n >= 1, "need at least 1 page");
let mut pdf: Vec<u8> = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
let kids: String = (3u32..=2 + n).map(|i| format!("{i} 0 R ")).collect();
let pages_obj = format!("2 0 obj\n<< /Type /Pages /Kids [{kids}] /Count {n} >>\nendobj\n");
pdf.extend_from_slice(pages_obj.as_bytes());
let mut page_offsets: Vec<u64> = Vec::new();
for i in 3u32..=2 + n {
let off = pdf.len() as u64;
page_offsets.push(off);
let page_obj = format!(
"{i} 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n"
);
pdf.extend_from_slice(page_obj.as_bytes());
}
let xref_start = pdf.len() as u64;
let total = 2 + n as usize + 1;
let mut xref = format!("xref\n0 {total}\n0000000000 65535 f \n");
xref.push_str(&format!("{:010} 00000 n \n", off1));
xref.push_str(&format!("{:010} 00000 n \n", off2));
for off in &page_offsets {
xref.push_str(&format!("{:010} 00000 n \n", off));
}
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn open(bytes: Vec<u8>) -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(bytes)).expect("PDF should parse")
}
#[test]
fn single_input_all_pages() {
let mut pdf = open(build_n_page_pdf(3));
let range = PageRange::parse("").unwrap();
let plan = CombinedPlan::build(vec![(&mut pdf, range)]).unwrap();
assert_eq!(plan.input_count(), 1);
assert_eq!(plan.total_page_count(), 3);
assert_eq!(plan.base_index(), 0);
let flat = plan.flat_pages();
assert_eq!(flat[0].source_index, 0);
assert_eq!(flat[0].page.index_1based, 1);
assert_eq!(flat[1].page.index_1based, 2);
assert_eq!(flat[2].page.index_1based, 3);
}
#[test]
fn two_inputs_concatenate_in_order() {
let mut pdf_a = open(build_n_page_pdf(3)); let mut pdf_b = open(build_n_page_pdf(2));
let range_a = PageRange::parse("1-3").unwrap();
let range_b = PageRange::parse("1-2").unwrap();
let plan = CombinedPlan::build(vec![(&mut pdf_a, range_a), (&mut pdf_b, range_b)]).unwrap();
assert_eq!(plan.input_count(), 2);
assert_eq!(plan.total_page_count(), 5);
let flat = plan.flat_pages();
assert_eq!(flat[0].source_index, 0);
assert_eq!(flat[1].source_index, 0);
assert_eq!(flat[2].source_index, 0);
assert_eq!(flat[3].source_index, 1);
assert_eq!(flat[4].source_index, 1);
}
#[test]
fn per_input_plans_are_accessible() {
let mut pdf_a = open(build_n_page_pdf(4));
let mut pdf_b = open(build_n_page_pdf(2));
let range_a = PageRange::parse("2,4").unwrap();
let range_b = PageRange::parse("").unwrap();
let plan = CombinedPlan::build(vec![(&mut pdf_a, range_a), (&mut pdf_b, range_b)]).unwrap();
let plans = plan.per_input_plans();
assert_eq!(plans.len(), 2);
assert_eq!(plans[0].len(), 2); assert_eq!(plans[1].len(), 2); assert_eq!(plans[0].pages()[0].index_1based, 2);
assert_eq!(plans[0].pages()[1].index_1based, 4);
}
#[test]
fn base_index_is_always_zero() {
let mut pdf_a = open(build_n_page_pdf(2));
let mut pdf_b = open(build_n_page_pdf(3));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("").unwrap()),
(&mut pdf_b, PageRange::parse("").unwrap()),
])
.unwrap();
assert_eq!(plan.base_index(), 0);
}
#[test]
fn single_input_with_range_subset() {
let mut pdf = open(build_n_page_pdf(5));
let range = PageRange::parse("2,4").unwrap();
let plan = CombinedPlan::build(vec![(&mut pdf, range)]).unwrap();
assert_eq!(plan.total_page_count(), 2);
let flat = plan.flat_pages();
assert_eq!(flat[0].page.index_1based, 2);
assert_eq!(flat[0].page.page_ref, ObjectRef::new(4, 0));
assert_eq!(flat[1].page.index_1based, 4);
assert_eq!(flat[1].page.page_ref, ObjectRef::new(6, 0));
}
#[test]
fn three_inputs_concatenation_order() {
let mut pdf_a = open(build_n_page_pdf(2));
let mut pdf_b = open(build_n_page_pdf(3));
let mut pdf_c = open(build_n_page_pdf(1));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("").unwrap()),
(&mut pdf_b, PageRange::parse("1,3").unwrap()),
(&mut pdf_c, PageRange::parse("").unwrap()),
])
.unwrap();
assert_eq!(plan.total_page_count(), 5);
let flat = plan.flat_pages();
assert!(flat[0..2].iter().all(|p| p.source_index == 0));
assert!(flat[2..4].iter().all(|p| p.source_index == 1));
assert_eq!(flat[4].source_index, 2);
assert_eq!(flat[2].page.index_1based, 1);
assert_eq!(flat[3].page.index_1based, 3);
}
#[test]
fn flat_pages_match_per_input_plans() {
let mut pdf_a = open(build_n_page_pdf(3));
let mut pdf_b = open(build_n_page_pdf(2));
let plan = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("1,3").unwrap()),
(&mut pdf_b, PageRange::parse("2").unwrap()),
])
.unwrap();
let flat = plan.flat_pages();
let plans = plan.per_input_plans();
assert_eq!(flat[0].page, plans[0].pages()[0]);
assert_eq!(flat[1].page, plans[0].pages()[1]);
assert_eq!(flat[2].page, plans[1].pages()[0]);
}
#[test]
fn empty_inputs_is_error() {
let inputs: Vec<(&mut Pdf<Cursor<Vec<u8>>>, PageRange)> = vec![];
let err = CombinedPlan::build(inputs).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("at least one input"),
"expected actionable message, got: {msg}"
);
}
#[test]
fn out_of_range_page_in_second_input_is_error() {
let mut pdf_a = open(build_n_page_pdf(3));
let mut pdf_b = open(build_n_page_pdf(2));
let err = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("1").unwrap()),
(&mut pdf_b, PageRange::parse("5").unwrap()), ])
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("input 1"),
"expected error attributed to input 1, got: {msg}"
);
assert!(
msg.contains("out of range"),
"expected 'out of range' in error message, got: {msg}"
);
}
#[test]
fn out_of_range_page_in_first_input_is_error() {
let mut pdf_a = open(build_n_page_pdf(2));
let err = CombinedPlan::build(vec![
(&mut pdf_a, PageRange::parse("10").unwrap()), ])
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("input 0"),
"expected error attributed to input 0, got: {msg}"
);
}
#[test]
fn input_spec_password_is_forwarded_to_open_options() {
let spec = InputSpec::new(
"test.pdf",
Some(b"secret".to_vec()),
PageRange::parse("").unwrap(),
);
assert_eq!(spec.password, Some(b"secret".to_vec()));
let spec_no_pw = InputSpec::new("test.pdf", None, PageRange::parse("").unwrap());
assert_eq!(spec_no_pw.password, None);
}
#[test]
fn from_specs_nonexistent_file_is_actionable_error() {
let spec = InputSpec::new(
"/nonexistent/path/to/file.pdf",
None,
PageRange::parse("").unwrap(),
);
let err = CombinedPlan::from_specs(vec![spec]).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("input 0"),
"expected error attributed to input 0, got: {msg}"
);
}
#[test]
fn from_specs_empty_is_error() {
let err = CombinedPlan::from_specs(vec![]).unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("at least one input"),
"expected actionable message, got: {msg}"
);
}
#[test]
fn from_specs_nonexistent_file_preserves_io_error_variant() {
let spec = InputSpec::new(
"/nonexistent/path/to/file.pdf",
None,
PageRange::parse("").unwrap(),
);
let err = CombinedPlan::from_specs(vec![spec]).unwrap_err();
assert!(
matches!(err, Error::Io(_)),
"expected Error::Io, got: {err:?}"
);
}
#[test]
fn from_specs_attributes_parse_failures_to_the_input() {
let directory = tempfile::tempdir().expect("temporary directory");
let input = directory.path().join("malformed.pdf");
std::fs::write(&input, b"not a PDF").expect("write malformed fixture");
let error = CombinedPlan::from_specs(vec![InputSpec::new(
&input,
None,
PageRange::parse("").expect("all pages range"),
)])
.expect_err("a malformed input must fail to open");
assert!(matches!(error, Error::Unsupported(message)
if message.contains("input 0")
&& message.contains("malformed.pdf")));
}
#[test]
fn from_specs_preserves_encrypted_authentication_after_open_diagnostics() {
let mut bytes = encrypted_v1_owner_password_fixture();
let size = bytes
.windows(b"/Size 3".len())
.position(|window| window == b"/Size 3")
.expect("encrypted fixture should contain a trailer size");
bytes[size + b"/Size ".len()] = b'2';
let directory = tempfile::tempdir().expect("temporary directory");
let input = directory.path().join("encrypted.pdf");
std::fs::write(&input, bytes).expect("write encrypted fixture");
let error = CombinedPlan::from_specs(vec![InputSpec::new(
&input,
Some(b"wrong".to_vec()),
PageRange::parse("").expect("all pages range"),
)])
.expect_err("wrong password must fail");
let (source, diagnostics) = error
.open_failure()
.expect("repair diagnostics must stay attached to auth failure");
assert!(matches!(
source,
Error::Encrypted(crate::EncryptedError::BadPassword)
));
assert!(!diagnostics.entries().is_empty());
}
#[test]
fn from_specs_two_files_concatenate_in_order() {
use std::io::Write;
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let dir = std::env::temp_dir().join(format!(
"flpdf_test_combine_{}_{}",
std::process::id(),
nanos
));
std::fs::create_dir_all(&dir).unwrap();
let path_a = dir.join("a.pdf");
let path_b = dir.join("b.pdf");
std::fs::File::create(&path_a)
.unwrap()
.write_all(&build_n_page_pdf(3))
.unwrap();
std::fs::File::create(&path_b)
.unwrap()
.write_all(&build_n_page_pdf(2))
.unwrap();
let specs = vec![
InputSpec::new(&path_a, None, PageRange::parse("1,3").unwrap()),
InputSpec::new(&path_b, None, PageRange::parse("").unwrap()),
];
let plan = CombinedPlan::from_specs(specs).unwrap();
assert_eq!(plan.input_count(), 2);
assert_eq!(plan.total_page_count(), 4);
assert_eq!(plan.base_index(), 0);
let flat = plan.flat_pages();
assert_eq!(flat[0].source_index, 0);
assert_eq!(flat[0].page.index_1based, 1);
assert_eq!(flat[1].source_index, 0);
assert_eq!(flat[1].page.index_1based, 3);
assert_eq!(flat[2].source_index, 1);
assert_eq!(flat[2].page.index_1based, 1);
assert_eq!(flat[3].source_index, 1);
assert_eq!(flat[3].page.index_1based, 2);
let _ = std::fs::remove_dir_all(&dir);
}
fn encrypted_v1_owner_password_fixture() -> Vec<u8> {
let mut bytes = b"%PDF-1.7\n".to_vec();
let obj1_offset = bytes.len();
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let obj2_offset = bytes.len();
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 >>\nendobj\n");
let xref_offset = bytes.len();
let trailer = b"trailer\n<< /Size 3 /Root 1 0 R /Encrypt << /Filter /Standard /V 1 /R 2 /Length 40 /P -3904 /O <94e8094419662a774442fb072e3d9f19e9d130ec09a4d0061e78fe920f7ab62f> /U <13f520c882d052bf57b416b747c13979bded7ea31240fe41928852aca3894c49> >> /ID [<000102030405060708090a0b0c0d0e0f><000102030405060708090a0b0c0d0e0f>] >>\nstartxref\n";
bytes.extend_from_slice(
format!(
"xref\n0 3\n0000000000 65535 f \n{obj1_offset:010} 00000 n \n{obj2_offset:010} 00000 n \n"
)
.as_bytes(),
);
bytes.extend_from_slice(trailer);
bytes.extend_from_slice(xref_offset.to_string().as_bytes());
bytes.extend_from_slice(b"\n%%EOF\n");
bytes
}
}