use crate::filters::decode_stream_data;
use crate::{Dictionary, Error, Object, ObjectRef, Pdf, Result, Stream};
use std::collections::BTreeSet;
use std::io::{Read, Seek};
pub const DEFAULT_MAX_PAGE_TREE_DEPTH: usize = 100;
pub fn page_refs<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<Vec<ObjectRef>> {
page_refs_with_max_depth(pdf, DEFAULT_MAX_PAGE_TREE_DEPTH)
}
pub fn page_refs_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Vec<ObjectRef>> {
let catalog_ref = pdf.root_ref().ok_or(Error::Missing("/Root"))?;
let catalog = pdf.resolve(catalog_ref)?;
let Object::Dictionary(catalog) = catalog else {
return Err(Error::Unsupported(format!(
"document catalog {catalog_ref} is not a dictionary"
)));
};
let pages_ref = catalog.get_ref("Pages").ok_or(Error::Missing("/Pages"))?;
let mut seen = BTreeSet::new();
let mut pages = Vec::new();
walk_page_tree(pdf, pages_ref, &mut seen, &mut pages, 0, max_depth)?;
Ok(pages)
}
pub fn page_content_bytes<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Vec<u8>> {
let page_obj = pdf.resolve(page_ref)?;
let Object::Dictionary(page_dict) = page_obj else {
return Err(Error::Unsupported(format!(
"object {page_ref} is not a dictionary, cannot extract /Contents"
)));
};
match page_dict.get("Type") {
Some(Object::Name(name)) if name.as_slice() == b"Page" => {}
Some(Object::Name(name)) => {
return Err(Error::Unsupported(format!(
"object {page_ref} has /Type /{}, expected /Page",
String::from_utf8_lossy(name)
)));
}
Some(_) => {
return Err(Error::Unsupported(format!(
"object {page_ref} has a non-name /Type entry"
)));
}
None => {
return Err(Error::Unsupported(format!(
"object {page_ref} has no /Type entry"
)));
}
}
let contents = match page_dict.get("Contents").cloned() {
None => return Ok(Vec::new()),
Some(c) => c,
};
let streams: Vec<Stream> = collect_content_streams(pdf, &contents, page_ref)?;
if streams.is_empty() {
return Ok(Vec::new());
}
let mut result: Vec<u8> = Vec::new();
for (i, stream) in streams.into_iter().enumerate() {
let decoded = decode_stream_data(&stream.dict, &stream.data)?;
if i > 0 {
result.push(b' ');
}
result.extend_from_slice(&decoded);
}
Ok(result)
}
fn collect_content_streams<R: Read + Seek>(
pdf: &mut Pdf<R>,
contents: &Object,
page_ref: ObjectRef,
) -> Result<Vec<Stream>> {
match contents {
Object::Stream(s) => Ok(vec![s.clone()]),
Object::Reference(r) => {
let resolved = pdf.resolve(*r)?;
match resolved {
Object::Stream(s) => Ok(vec![s]),
_ => Err(Error::Unsupported(format!(
"/Contents reference {r} on page {page_ref} does not resolve to a stream"
))),
}
}
Object::Array(elems) => {
let mut streams = Vec::with_capacity(elems.len());
for elem in elems {
match elem {
Object::Reference(r) => {
let resolved = pdf.resolve(*r)?;
match resolved {
Object::Stream(s) => streams.push(s),
_ => {
return Err(Error::Unsupported(format!(
"/Contents array element {r} on page {page_ref} does not resolve to a stream"
)));
}
}
}
Object::Stream(s) => streams.push(s.clone()),
other => {
let type_name = object_type_name(other);
return Err(Error::Unsupported(format!(
"/Contents array element of type {type_name} on page {page_ref} is not a stream or reference"
)));
}
}
}
Ok(streams)
}
other => Err(Error::Unsupported(format!(
"/Contents entry on page {page_ref} has unexpected type {}",
object_type_name(other)
))),
}
}
fn object_type_name(obj: &Object) -> &'static str {
match obj {
Object::Null => "null",
Object::Boolean(_) => "boolean",
Object::Integer(_) => "integer",
Object::Real(_) => "real",
Object::Name(_) => "name",
Object::String(_) => "string",
Object::Array(_) => "array",
Object::Dictionary(_) => "dictionary",
Object::Stream(_) => "stream",
Object::Reference(_) => "reference",
}
}
pub fn resolve_inherited_resources<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Option<Dictionary>> {
resolve_inherited_resources_with_max_depth(pdf, page_ref, DEFAULT_MAX_PAGE_TREE_DEPTH)
}
pub fn resolve_inherited_resources_with_max_depth<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
max_depth: usize,
) -> Result<Option<Dictionary>> {
let mut seen: BTreeSet<ObjectRef> = BTreeSet::new();
let mut current = page_ref;
let mut depth: usize = 0;
loop {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {max_depth} at {current}"
)));
}
if !seen.insert(current) {
return Ok(None);
}
let node_obj = pdf.resolve(current)?;
let Object::Dictionary(dict) = node_obj else {
return Ok(None);
};
if let Some(resources_val) = dict.get("Resources").cloned() {
match resources_val {
Object::Null => {}
Object::Dictionary(d) => return Ok(Some(d)),
Object::Reference(r) => {
let resolved = pdf.resolve(r)?;
match resolved {
Object::Null => {}
Object::Dictionary(d) => return Ok(Some(d)),
_ => {
return Err(Error::Unsupported(format!(
"/Resources reference {r} on node {current} does not resolve to a dictionary"
)));
}
}
}
_ => {
return Err(Error::Unsupported(format!(
"/Resources entry on node {current} has unexpected type"
)));
}
}
}
let parent_val = match dict.get("Parent").cloned() {
Some(Object::Null) | None => return Ok(None),
Some(v) => v,
};
match parent_val {
Object::Reference(r) => {
current = r;
depth += 1;
}
_ => return Ok(None),
}
}
}
fn walk_page_tree<R: Read + Seek>(
pdf: &mut Pdf<R>,
node: ObjectRef,
seen: &mut BTreeSet<ObjectRef>,
pages: &mut Vec<ObjectRef>,
depth: usize,
max_depth: usize,
) -> Result<()> {
if depth >= max_depth {
return Err(Error::Unsupported(format!(
"page tree depth exceeds maximum of {max_depth} at {node}"
)));
}
if !seen.insert(node) {
return Ok(());
}
let node_obj = pdf.resolve(node)?;
let Object::Dictionary(dict) = node_obj else {
return Ok(());
};
let node_type = dict
.get("Type")
.and_then(|value| match value {
Object::Name(value) => Some(value.clone()),
_ => None,
})
.unwrap_or_default();
if node_type.as_slice() == b"Pages" {
if let Some(Object::Array(kids)) = dict.get("Kids") {
for kid in kids {
if let Object::Reference(reference) = kid {
walk_page_tree(pdf, *reference, seen, pages, depth + 1, max_depth)?;
}
}
}
return Ok(());
}
if node_type.as_slice() == b"Page" {
pages.push(node);
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::filters::encode_stream_data;
use crate::Dictionary;
use std::io::Cursor;
fn build_pdf_with_contents(contents_entry: &str, extra_objects: &[(u32, &str)]) -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
let page_obj = if contents_entry.is_empty() {
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n".to_string()
} else {
format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents {contents_entry} >>\nendobj\n"
)
};
pdf.extend_from_slice(page_obj.as_bytes());
let mut extra_offsets: Vec<(u32, u64)> = Vec::new();
for (num, body) in extra_objects.iter() {
let off = pdf.len() as u64;
extra_offsets.push((*num, off));
pdf.extend_from_slice(body.as_bytes());
}
let xref_start = pdf.len() as u64;
let max_num = extra_offsets.iter().map(|(n, _)| *n).max().unwrap_or(3);
let total = max_num 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));
xref.push_str(&format!("{:010} 00000 n \n", off3));
for i in 4..=max_num {
if let Some((_, off)) = extra_offsets.iter().find(|(n, _)| *n == i) {
xref.push_str(&format!("{:010} 00000 n \n", off));
} else {
xref.push_str("0000000000 65535 f \n");
}
}
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 build_pdf_with_pages_node_as_obj3() -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn stream_object_bytes(num: u32, body: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(
format!("{num} 0 obj\n<< /Length {} >>\nstream\n", body.len()).as_bytes(),
);
out.extend_from_slice(body);
out.extend_from_slice(b"\nendstream\nendobj\n");
out
}
fn chained_filter_stream_object_bytes(num: u32, body: &[u8]) -> Vec<u8> {
let mut a85_dict = Dictionary::new();
a85_dict.insert("Filter", Object::Name(b"ASCII85Decode".to_vec()));
let after_a85 = encode_stream_data(&a85_dict, body).unwrap();
let mut flate_dict = Dictionary::new();
flate_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let encoded = encode_stream_data(&flate_dict, &after_a85).unwrap();
let mut out = Vec::new();
out.extend_from_slice(
format!(
"{num} 0 obj\n<< /Filter [ /FlateDecode /ASCII85Decode ] /Length {} >>\nstream\n",
encoded.len()
)
.as_bytes(),
);
out.extend_from_slice(&encoded);
out.extend_from_slice(b"\nendstream\nendobj\n");
out
}
fn build_pdf_with_binary_extras(
contents_entry: &str,
extra_objects: &[(u32, Vec<u8>)],
) -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
let page_obj = if contents_entry.is_empty() {
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n".to_string()
} else {
format!(
"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents {contents_entry} >>\nendobj\n"
)
};
pdf.extend_from_slice(page_obj.as_bytes());
let mut extra_offsets: Vec<(u32, u64)> = Vec::new();
for (num, body) in extra_objects.iter() {
let off = pdf.len() as u64;
extra_offsets.push((*num, off));
pdf.extend_from_slice(body);
}
let xref_start = pdf.len() as u64;
let max_num = extra_offsets.iter().map(|(n, _)| *n).max().unwrap_or(3);
let total = max_num 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));
xref.push_str(&format!("{:010} 00000 n \n", off3));
for i in 4..=max_num {
if let Some((_, off)) = extra_offsets.iter().find(|(n, _)| *n == i) {
xref.push_str(&format!("{:010} 00000 n \n", off));
} else {
xref.push_str("0000000000 65535 f \n");
}
}
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
}
#[test]
fn page_content_bytes_returns_empty_for_page_without_contents() {
let bytes = build_pdf_with_contents("", &[]);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let content = page_content_bytes(&mut pdf, page_ref).unwrap();
assert!(
content.is_empty(),
"expected empty Vec for page without /Contents"
);
}
#[test]
fn page_content_bytes_resolves_single_stream_reference() {
let body = b"BT /F1 12 Tf (Hello) Tj ET";
let stream_bytes = stream_object_bytes(4, body);
let bytes = build_pdf_with_binary_extras("4 0 R", &[(4, stream_bytes)]);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let content = page_content_bytes(&mut pdf, page_ref).unwrap();
assert_eq!(content, body);
}
#[test]
fn page_content_bytes_concatenates_array_of_refs_with_space_separator() {
let body1 = b"q 1 0 0 1 0 0 cm";
let body2 = b"BT /F1 12 Tf (World) Tj ET";
let stream_bytes1 = stream_object_bytes(4, body1);
let stream_bytes2 = stream_object_bytes(5, body2);
let bytes = build_pdf_with_binary_extras(
"[4 0 R 5 0 R]",
&[(4, stream_bytes1), (5, stream_bytes2)],
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let content = page_content_bytes(&mut pdf, page_ref).unwrap();
let mut expected = body1.to_vec();
expected.push(b' ');
expected.extend_from_slice(body2);
assert_eq!(content, expected);
}
#[test]
fn page_content_bytes_applies_chained_filters() {
let body = b"q 0.5 g 100 100 300 300 re f Q";
let stream_bytes = chained_filter_stream_object_bytes(4, body);
let bytes = build_pdf_with_binary_extras("4 0 R", &[(4, stream_bytes)]);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let content = page_content_bytes(&mut pdf, page_ref).unwrap();
assert_eq!(content, body);
}
#[test]
fn page_content_bytes_rejects_non_page_ref() {
let bytes = build_pdf_with_pages_node_as_obj3();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let result = page_content_bytes(&mut pdf, ObjectRef::new(3, 0));
assert!(result.is_err(), "expected error for non-Page ref, got Ok");
match result.unwrap_err() {
Error::Unsupported(_) => {}
err => panic!("expected Error::Unsupported, got {err:?}"),
}
}
#[test]
fn page_content_bytes_handles_direct_stream_in_contents() {
let base_bytes = build_pdf_with_contents("", &[]);
let mut pdf = Pdf::open(Cursor::new(base_bytes)).expect("PDF should parse");
let content_body = b"BT /F1 12 Tf (Direct) Tj ET";
let stream = Stream::new(Dictionary::new(), content_body.to_vec());
let mut page_dict = Dictionary::new();
page_dict.insert("Type", Object::Name(b"Page".to_vec()));
page_dict.insert("Contents", Object::Stream(stream));
pdf.set_object(ObjectRef::new(3, 0), Object::Dictionary(page_dict));
let content = page_content_bytes(&mut pdf, ObjectRef::new(3, 0)).unwrap();
assert_eq!(content, content_body);
}
fn build_pdf_page_has_direct_resources() -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << >> >> >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn build_pdf_resources_inherited_via_indirect_ref() -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 /Resources 4 0 R >>\nendobj\n",
);
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let off4 = pdf.len() as u64;
pdf.extend_from_slice(b"4 0 obj\n<< /Font << /F1 << /Type /Font >> >> >>\nendobj\n");
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 5\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3, off4,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn build_pdf_no_resources() -> Vec<u8> {
let mut pdf = 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;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn resolve_inherited_resources_page_has_direct_dict() {
let bytes = build_pdf_page_has_direct_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let result = resolve_inherited_resources(&mut pdf, page_ref).expect("should succeed");
let dict = result.expect("should find /Resources");
assert!(
dict.get("Font").is_some(),
"expected /Font key in resolved Resources dict"
);
}
#[test]
fn resolve_inherited_resources_from_parent_via_indirect_ref() {
let bytes = build_pdf_resources_inherited_via_indirect_ref();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let result = resolve_inherited_resources(&mut pdf, page_ref).expect("should succeed");
let dict = result.expect("should find inherited /Resources via indirect ref");
assert!(
dict.get("Font").is_some(),
"expected /Font key in inherited Resources dict"
);
}
#[test]
fn resolve_inherited_resources_none_when_absent() {
let bytes = build_pdf_no_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let page_ref = ObjectRef::new(3, 0);
let result =
resolve_inherited_resources(&mut pdf, page_ref).expect("should succeed with Ok(None)");
assert!(
result.is_none(),
"expected Ok(None) when no /Resources anywhere in the parent chain"
);
}
#[test]
fn resolve_inherited_resources_cycle_does_not_crash() {
let bytes = build_pdf_no_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let mut pages_dict = Dictionary::new();
pages_dict.insert("Type", Object::Name(b"Pages".to_vec()));
pages_dict.insert(
"Kids",
Object::Array(vec![Object::Reference(ObjectRef::new(3, 0))]),
);
pages_dict.insert("Count", Object::Integer(1));
pages_dict.insert("Parent", Object::Reference(ObjectRef::new(3, 0))); pdf.set_object(ObjectRef::new(2, 0), Object::Dictionary(pages_dict));
let page_ref = ObjectRef::new(3, 0);
let result = resolve_inherited_resources(&mut pdf, page_ref);
match result {
Ok(None) => {} Ok(Some(_)) => panic!("should not find resources in a cycle-only graph"),
Err(Error::Unsupported(_)) => {} Err(e) => panic!("unexpected error variant: {e:?}"),
}
}
#[test]
fn resolve_inherited_resources_null_falls_through_to_parent() {
let bytes = build_pdf_resources_inherited_via_indirect_ref();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let mut page_dict = Dictionary::new();
page_dict.insert("Type", Object::Name(b"Page".to_vec()));
page_dict.insert("Parent", Object::Reference(ObjectRef::new(2, 0)));
page_dict.insert(
"MediaBox",
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
]),
);
page_dict.insert("Resources", Object::Null);
pdf.set_object(ObjectRef::new(3, 0), Object::Dictionary(page_dict));
let page_ref = ObjectRef::new(3, 0);
let result =
resolve_inherited_resources(&mut pdf, page_ref).expect("null should be like absent");
let dict = result.expect("should inherit /Resources from parent despite null on page");
assert!(
dict.get("Font").is_some(),
"expected inherited /Font key when page's /Resources is null"
);
}
#[test]
fn resolve_inherited_resources_null_parent_terminates_chain() {
let bytes = build_pdf_no_resources();
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("PDF should parse");
let mut page_dict = Dictionary::new();
page_dict.insert("Type", Object::Name(b"Page".to_vec()));
page_dict.insert("Parent", Object::Null);
page_dict.insert(
"MediaBox",
Object::Array(vec![
Object::Integer(0),
Object::Integer(0),
Object::Integer(612),
Object::Integer(792),
]),
);
pdf.set_object(ObjectRef::new(3, 0), Object::Dictionary(page_dict));
let page_ref = ObjectRef::new(3, 0);
let result = resolve_inherited_resources(&mut pdf, page_ref)
.expect("null /Parent should be like absent");
assert!(
result.is_none(),
"expected Ok(None) when /Parent is null and no /Resources"
);
}
}