use crate::name_number_tree::DEFAULT_MAX_TREE_DEPTH;
use crate::{Dictionary, Object, ObjectRef, Pdf, Result};
use std::io::{Read, Seek};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LabelStyle {
Decimal,
RomanUpper,
RomanLower,
AlphaUpper,
AlphaLower,
None,
}
impl LabelStyle {
pub fn from_name(name: &[u8]) -> Self {
match name {
b"D" => LabelStyle::Decimal,
b"R" => LabelStyle::RomanUpper,
b"r" => LabelStyle::RomanLower,
b"A" => LabelStyle::AlphaUpper,
b"a" => LabelStyle::AlphaLower,
_ => LabelStyle::None,
}
}
pub fn to_name(self) -> Option<&'static str> {
match self {
LabelStyle::Decimal => Some("D"),
LabelStyle::RomanUpper => Some("R"),
LabelStyle::RomanLower => Some("r"),
LabelStyle::AlphaUpper => Some("A"),
LabelStyle::AlphaLower => Some("a"),
LabelStyle::None => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LabelRange {
pub style: LabelStyle,
pub prefix: String,
pub start: i64,
}
impl LabelRange {
pub fn from_dict(dict: &Dictionary) -> Self {
let style = match dict.get("S") {
Some(Object::Name(bytes)) => LabelStyle::from_name(bytes),
_ => LabelStyle::None,
};
let prefix = match dict.get("P") {
Some(Object::String(bytes)) => crate::json_inspect::decode_pdf_text_string(bytes)
.unwrap_or_else(|| String::from_utf8_lossy(bytes).into_owned()),
_ => String::new(),
};
let start = match dict.get("St") {
Some(Object::Integer(n)) => *n,
_ => 1,
};
LabelRange {
style,
prefix,
start,
}
}
pub(crate) fn from_dict_resolved<R: Read + Seek>(
pdf: &mut Pdf<R>,
dict: &Dictionary,
) -> Result<Self> {
let style = match resolve_entry(pdf, dict.get("S"))? {
Some(Object::Name(bytes)) => LabelStyle::from_name(&bytes),
_ => LabelStyle::None,
};
let prefix = match resolve_entry(pdf, dict.get("P"))? {
Some(Object::String(bytes)) => crate::json_inspect::decode_pdf_text_string(&bytes)
.unwrap_or_else(|| String::from_utf8_lossy(&bytes).into_owned()),
_ => String::new(),
};
let start = match resolve_entry(pdf, dict.get("St"))? {
Some(Object::Integer(n)) => n,
_ => 1,
};
Ok(LabelRange {
style,
prefix,
start,
})
}
pub fn to_dict(&self) -> Dictionary {
let mut d = Dictionary::new();
if let Some(name) = self.style.to_name() {
d.insert("S", Object::Name(name.into()));
}
if !self.prefix.is_empty() {
d.insert("P", Object::String(self.prefix.clone().into_bytes()));
}
if self.start != 1 {
d.insert("St", Object::Integer(self.start));
}
d
}
pub fn format(&self, value: i64) -> String {
let mut s = self.prefix.clone();
match self.style {
LabelStyle::Decimal => s.push_str(&value.to_string()),
LabelStyle::RomanUpper => s.push_str(&to_roman(value, true)),
LabelStyle::RomanLower => s.push_str(&to_roman(value, false)),
LabelStyle::AlphaUpper => s.push_str(&to_alpha(value, true)),
LabelStyle::AlphaLower => s.push_str(&to_alpha(value, false)),
LabelStyle::None => {}
}
s
}
}
fn resolve_entry<R: Read + Seek>(
pdf: &mut Pdf<R>,
value: Option<&Object>,
) -> Result<Option<Object>> {
match value {
Some(Object::Reference(r)) => Ok(Some(pdf.resolve_borrowed(*r)?.clone())),
Some(o) => Ok(Some(o.clone())),
None => Ok(None),
}
}
const MAX_RENDERABLE_LABEL_VALUE: i64 = 100_000;
fn to_roman(value: i64, upper: bool) -> String {
if value <= 0 || value > MAX_RENDERABLE_LABEL_VALUE {
return String::new();
}
const TABLE: &[(i64, &str, &str)] = &[
(1000, "M", "m"),
(900, "CM", "cm"),
(500, "D", "d"),
(400, "CD", "cd"),
(100, "C", "c"),
(90, "XC", "xc"),
(50, "L", "l"),
(40, "XL", "xl"),
(10, "X", "x"),
(9, "IX", "ix"),
(5, "V", "v"),
(4, "IV", "iv"),
(1, "I", "i"),
];
let mut v = value;
let mut out = String::new();
for &(n, up, lo) in TABLE {
while v >= n {
out.push_str(if upper { up } else { lo });
v -= n;
}
}
out
}
fn to_alpha(value: i64, upper: bool) -> String {
if value <= 0 || value > MAX_RENDERABLE_LABEL_VALUE {
return String::new();
}
let v = value - 1;
let letter = (v % 26) as u8;
let count = (v / 26) + 1;
let ch = if upper { b'A' + letter } else { b'a' + letter } as char;
(0..count).map(|_| ch).collect()
}
pub struct PageLabelDocumentHelper<'a, R: Read + Seek> {
pdf: &'a mut Pdf<R>,
}
impl<'a, R: Read + Seek> PageLabelDocumentHelper<'a, R> {
pub fn new(pdf: &'a mut Pdf<R>) -> Self {
Self { pdf }
}
fn pagelabels_root(&mut self) -> Result<Option<Object>> {
let Some(catalog_ref) = self.pdf.root_ref() else {
return Ok(None);
};
let Some(catalog) = self.pdf.resolve_borrowed(catalog_ref)?.as_dict() else {
return Ok(None);
};
Ok(catalog.get("PageLabels").cloned())
}
pub fn has_page_labels(&mut self) -> Result<bool> {
Ok(self.pagelabels_root()?.is_some())
}
pub fn ranges(&mut self) -> Result<Vec<(i64, LabelRange)>> {
let Some(root) = self.pagelabels_root()? else {
return Ok(vec![]);
};
crate::name_number_tree::read_number_tree(
self.pdf,
root,
|pdf, v| {
let dict = match v {
Object::Dictionary(d) => Some(d),
Object::Reference(r) => pdf.resolve_borrowed(r)?.as_dict().cloned(),
_ => None,
};
match dict {
Some(d) => Ok(Some(LabelRange::from_dict_resolved(pdf, &d)?)),
None => Ok(None),
}
},
DEFAULT_MAX_TREE_DEPTH,
)
}
pub fn label_for_page(&mut self, page_idx: i64) -> Result<Option<LabelRange>> {
let ranges = self.ranges()?;
let mut chosen: Option<&(i64, LabelRange)> = None;
for entry in &ranges {
if entry.0 <= page_idx {
chosen = Some(entry);
} else {
break;
}
}
Ok(chosen.map(|(first, r)| {
let offset = page_idx.saturating_sub(*first);
LabelRange {
style: r.style,
prefix: r.prefix.clone(),
start: r.start.saturating_add(offset),
}
}))
}
pub fn label_string_for_page(&mut self, page_idx: i64) -> Result<String> {
match self.label_for_page(page_idx)? {
Some(effective) => Ok(effective.format(effective.start)),
None => Ok((page_idx + 1).to_string()),
}
}
pub fn labels_for_page_range(
&mut self,
start_idx: i64,
end_idx: i64,
new_start_idx: i64,
) -> Result<Vec<(i64, LabelRange)>> {
let ranges = self.ranges()?;
let explicit: std::collections::BTreeSet<i64> = ranges.iter().map(|(i, _)| *i).collect();
let first_label = match self.label_for_page(start_idx)? {
Some(r) => r,
None => LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: new_start_idx.saturating_add(1),
},
};
let mut out = vec![(new_start_idx, first_label)];
let idx_offset = new_start_idx.saturating_sub(start_idx);
for &i in explicit.range((start_idx + 1)..=end_idx) {
if let Some(lab) = self.label_for_page(i)? {
out.push((i.saturating_add(idx_offset), lab));
}
}
Ok(out)
}
fn raw_entries(&mut self) -> Result<Vec<(i64, Object)>> {
let Some(root) = self.pagelabels_root()? else {
return Ok(vec![]);
};
crate::name_number_tree::read_number_tree(
self.pdf,
root,
|_, v| Ok(Some(v)),
DEFAULT_MAX_TREE_DEPTH,
)
}
pub fn set_range(&mut self, first_page_idx: i64, range: LabelRange) -> Result<()> {
let mut entries = self.raw_entries()?;
let value = Object::Dictionary(range.to_dict());
match entries.iter_mut().find(|(k, _)| *k == first_page_idx) {
Some(e) => e.1 = value,
None => {
entries.push((first_page_idx, value));
entries.sort_by_key(|(k, _)| *k);
}
}
self.rebuild(entries)
}
pub fn remove_range(&mut self, first_page_idx: i64) -> Result<bool> {
let mut entries = self.raw_entries()?;
let before = entries.len();
entries.retain(|(k, _)| *k != first_page_idx);
if entries.len() == before {
return Ok(false);
}
self.rebuild(entries)?;
Ok(true)
}
fn rebuild(&mut self, entries: Vec<(i64, Object)>) -> Result<()> {
let Some(catalog_ref) = self.pdf.root_ref() else {
return Ok(());
};
let Some(mut catalog) = self.pdf.resolve_borrowed(catalog_ref)?.as_dict().cloned() else {
return Ok(());
};
if entries.is_empty() {
catalog.remove("PageLabels");
self.pdf
.set_object(catalog_ref, Object::Dictionary(catalog));
return Ok(());
}
let mut next_num: u32 = self
.pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let mut alloc = move || -> ObjectRef {
next_num += 1;
ObjectRef::new(next_num, 0)
};
let (root_ref, nodes) = crate::name_number_tree::build_number_tree(&entries, &mut alloc);
for (r, node) in nodes {
self.pdf.set_object(r, node);
}
catalog.insert("PageLabels", Object::Reference(root_ref));
self.pdf
.set_object(catalog_ref, Object::Dictionary(catalog));
Ok(())
}
}
impl<R: Read + Seek> Pdf<R> {
pub fn page_labels(&mut self) -> PageLabelDocumentHelper<'_, R> {
PageLabelDocumentHelper::new(self)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn pdf_with_pagelabels(nums: Vec<Object>) -> Pdf<Cursor<Vec<u8>>> {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.7\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = bytes.len() as u64;
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = bytes.len() as u64;
bytes.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \ntrailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("open");
let pl_ref = ObjectRef::new(10, 0);
let mut leaf = Dictionary::new();
leaf.insert("Nums", Object::Array(nums));
pdf.set_object(pl_ref, Object::Dictionary(leaf));
let catalog_ref = pdf.root_ref().unwrap();
let mut catalog = pdf
.resolve_borrowed(catalog_ref)
.unwrap()
.as_dict()
.unwrap()
.clone();
catalog.insert("PageLabels", Object::Reference(pl_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
pdf
}
fn label_dict(style: &str, st: Option<i64>, prefix: Option<&str>) -> Object {
let mut d = Dictionary::new();
d.insert("S", Object::Name(style.into()));
if let Some(s) = st {
d.insert("St", Object::Integer(s));
}
if let Some(p) = prefix {
d.insert("P", Object::String(p.as_bytes().to_vec()));
}
Object::Dictionary(d)
}
#[test]
fn label_string_multi_range_matches_spec() {
let mut pdf = pdf_with_pagelabels(vec![
Object::Integer(0),
label_dict("r", None, None),
Object::Integer(3),
label_dict("D", Some(1), None),
Object::Integer(6),
label_dict("D", Some(1), Some("A-")),
]);
let mut h = pdf.page_labels();
assert!(h.has_page_labels().unwrap());
assert_eq!(h.label_string_for_page(0).unwrap(), "i");
assert_eq!(h.label_string_for_page(1).unwrap(), "ii");
assert_eq!(h.label_string_for_page(2).unwrap(), "iii");
assert_eq!(h.label_string_for_page(3).unwrap(), "1");
assert_eq!(h.label_string_for_page(5).unwrap(), "3");
assert_eq!(h.label_string_for_page(6).unwrap(), "A-1");
assert_eq!(h.label_string_for_page(8).unwrap(), "A-3");
}
#[test]
fn label_for_page_offsets_start() {
let mut pdf =
pdf_with_pagelabels(vec![Object::Integer(0), label_dict("D", Some(10), None)]);
let mut h = pdf.page_labels();
let lab = h.label_for_page(2).unwrap().expect("range applies");
assert_eq!(lab.start, 12, "/St 10 + offset 2");
assert_eq!(lab.style, LabelStyle::Decimal);
}
#[test]
fn no_pagelabels_defaults_to_decimal() {
let mut pdf = pdf_with_pagelabels(vec![]); let mut h = pdf.page_labels();
assert_eq!(h.label_string_for_page(0).unwrap(), "1");
assert_eq!(h.label_string_for_page(4).unwrap(), "5");
assert!(h.label_for_page(0).unwrap().is_none());
}
#[test]
fn page_before_first_range_defaults_to_decimal() {
let mut pdf = pdf_with_pagelabels(vec![Object::Integer(3), label_dict("R", Some(1), None)]);
let mut h = pdf.page_labels();
assert_eq!(
h.label_string_for_page(0).unwrap(),
"1",
"page before first range"
);
assert_eq!(h.label_string_for_page(3).unwrap(), "I");
}
#[test]
fn labels_for_page_range_renumbers_and_copies_explicit() {
let mut pdf = pdf_with_pagelabels(vec![
Object::Integer(0),
label_dict("r", Some(1), None),
Object::Integer(5),
label_dict("D", Some(1), None),
]);
let mut h = pdf.page_labels();
let out = h.labels_for_page_range(3, 6, 0).unwrap();
assert_eq!(out[0].0, 0);
assert_eq!(out[0].1.style, LabelStyle::RomanLower);
assert_eq!(out[0].1.start, 4);
assert!(out
.iter()
.any(|(idx, r)| *idx == 2 && r.style == LabelStyle::Decimal));
}
#[test]
fn set_range_inserts_and_round_trips() {
let mut pdf = pdf_with_pagelabels(vec![]); {
let mut h = pdf.page_labels();
h.set_range(
0,
LabelRange {
style: LabelStyle::RomanLower,
prefix: String::new(),
start: 1,
},
)
.unwrap();
h.set_range(
3,
LabelRange {
style: LabelStyle::Decimal,
prefix: "A-".into(),
start: 1,
},
)
.unwrap();
}
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 2);
assert_eq!(ranges[0].0, 0);
assert_eq!(ranges[0].1.style, LabelStyle::RomanLower);
assert_eq!(ranges[1].0, 3);
assert_eq!(ranges[1].1.prefix, "A-");
assert_eq!(h.label_string_for_page(4).unwrap(), "A-2");
}
#[test]
fn set_range_replaces_existing_index() {
let mut pdf = pdf_with_pagelabels(vec![Object::Integer(0), label_dict("D", Some(1), None)]);
{
let mut h = pdf.page_labels();
h.set_range(
0,
LabelRange {
style: LabelStyle::RomanUpper,
prefix: String::new(),
start: 1,
},
)
.unwrap();
}
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1);
assert_eq!(ranges[0].1.style, LabelStyle::RomanUpper);
}
#[test]
fn remove_range_drops_entry_and_pagelabels_when_empty() {
let mut pdf = pdf_with_pagelabels(vec![Object::Integer(0), label_dict("D", Some(1), None)]);
{
let mut h = pdf.page_labels();
assert!(h.remove_range(0).unwrap());
assert!(!h.remove_range(99).unwrap(), "absent index => false");
}
let mut h = pdf.page_labels();
assert!(
!h.has_page_labels().unwrap(),
"/PageLabels dropped when empty"
);
assert_eq!(
h.label_string_for_page(0).unwrap(),
"1",
"defaults after removal"
);
}
#[test]
fn roman_matches_spec() {
assert_eq!(to_roman(1, true), "I");
assert_eq!(to_roman(4, true), "IV");
assert_eq!(to_roman(9, false), "ix");
assert_eq!(to_roman(40, true), "XL");
assert_eq!(to_roman(90, false), "xc");
assert_eq!(to_roman(400, true), "CD");
assert_eq!(to_roman(900, true), "CM");
assert_eq!(to_roman(3888, true), "MMMDCCCLXXXVIII");
assert_eq!(to_roman(0, true), "");
assert_eq!(to_roman(-3, false), "");
}
#[test]
fn formatters_cap_huge_values() {
assert!(!to_roman(MAX_RENDERABLE_LABEL_VALUE, true).is_empty());
assert_eq!(to_roman(MAX_RENDERABLE_LABEL_VALUE + 1, true), "");
assert_eq!(to_roman(i64::MAX, true), "");
assert!(!to_alpha(MAX_RENDERABLE_LABEL_VALUE, true).is_empty());
assert_eq!(to_alpha(MAX_RENDERABLE_LABEL_VALUE + 1, true), "");
assert_eq!(to_alpha(i64::MAX, true), "");
}
#[test]
fn alpha_repeating_letters() {
assert_eq!(to_alpha(1, true), "A");
assert_eq!(to_alpha(26, true), "Z");
assert_eq!(to_alpha(27, true), "AA");
assert_eq!(to_alpha(52, false), "zz");
assert_eq!(to_alpha(53, true), "AAA");
assert_eq!(to_alpha(0, true), "");
}
#[test]
fn label_range_format_prefix_and_styles() {
let d = LabelRange {
style: LabelStyle::Decimal,
prefix: "A-".into(),
start: 1,
};
assert_eq!(d.format(5), "A-5");
let r = LabelRange {
style: LabelStyle::RomanLower,
prefix: String::new(),
start: 1,
};
assert_eq!(r.format(3), "iii");
let none = LabelRange {
style: LabelStyle::None,
prefix: "Cover".into(),
start: 1,
};
assert_eq!(
none.format(9),
"Cover",
"None style => prefix only, no number"
);
}
#[test]
fn label_range_dict_round_trip() {
let r = LabelRange {
style: LabelStyle::RomanUpper,
prefix: "App-".into(),
start: 5,
};
let dict = r.to_dict();
assert_eq!(dict.get("S"), Some(&Object::Name("R".into())));
assert_eq!(dict.get("St"), Some(&Object::Integer(5)));
assert_eq!(LabelRange::from_dict(&dict), r);
let bare = LabelRange {
style: LabelStyle::None,
prefix: String::new(),
start: 1,
};
assert!(
bare.to_dict().iter().next().is_none(),
"all-default range => empty dict"
);
}
#[test]
fn ranges_resolves_indirect_inner_st() {
let mut pdf = pdf_with_pagelabels(vec![]); let st_ref = ObjectRef::new(11, 0);
pdf.set_object(st_ref, Object::Integer(7));
let mut label = Dictionary::new();
label.insert("S", Object::Name("D".into()));
label.insert("St", Object::Reference(st_ref));
let pl_ref = ObjectRef::new(10, 0);
let mut leaf = Dictionary::new();
leaf.insert(
"Nums",
Object::Array(vec![Object::Integer(0), Object::Dictionary(label)]),
);
pdf.set_object(pl_ref, Object::Dictionary(leaf));
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1);
assert_eq!(ranges[0].1.start, 7, "indirect /St must be resolved");
}
#[test]
fn set_range_round_trips_multi_leaf_tree() {
let mut pdf = pdf_with_pagelabels(vec![]);
{
let mut h = pdf.page_labels();
for i in 0..40i64 {
h.set_range(
i * 2,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
)
.unwrap();
}
}
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(
ranges.len(),
40,
"all 40 ranges survive the multi-leaf tree"
);
assert_eq!(ranges[0].0, 0);
assert_eq!(ranges[39].0, 78);
assert!(ranges.windows(2).all(|w| w[0].0 < w[1].0), "ascending");
}
#[test]
fn label_style_name_round_trip_all_variants() {
for (bytes, style, name) in [
(b"D".as_ref(), LabelStyle::Decimal, Some("D")),
(b"R".as_ref(), LabelStyle::RomanUpper, Some("R")),
(b"r".as_ref(), LabelStyle::RomanLower, Some("r")),
(b"A".as_ref(), LabelStyle::AlphaUpper, Some("A")),
(b"a".as_ref(), LabelStyle::AlphaLower, Some("a")),
] {
assert_eq!(LabelStyle::from_name(bytes), style);
assert_eq!(style.to_name(), name);
}
assert_eq!(LabelStyle::from_name(b"Z"), LabelStyle::None);
assert_eq!(LabelStyle::None.to_name(), None);
}
#[test]
fn format_alpha_styles() {
let up = LabelRange {
style: LabelStyle::AlphaUpper,
prefix: String::new(),
start: 1,
};
assert_eq!(up.format(27), "AA");
let lo = LabelRange {
style: LabelStyle::AlphaLower,
prefix: "x".into(),
start: 1,
};
assert_eq!(lo.format(2), "xb");
}
#[test]
fn from_dict_non_name_style_is_none() {
let mut d = Dictionary::new();
d.insert("S", Object::Integer(0)); assert_eq!(LabelRange::from_dict(&d).style, LabelStyle::None);
}
#[test]
fn ranges_handles_indirect_and_non_dict_values() {
let mut pdf = pdf_with_pagelabels(vec![]);
let lab_ref = ObjectRef::new(20, 0);
let mut lab = Dictionary::new();
lab.insert("S", Object::Name("D".into()));
pdf.set_object(lab_ref, Object::Dictionary(lab));
let pl_ref = ObjectRef::new(10, 0);
let mut leaf = Dictionary::new();
leaf.insert(
"Nums",
Object::Array(vec![
Object::Integer(0),
Object::Reference(lab_ref), Object::Integer(5),
Object::Integer(99), ]),
);
pdf.set_object(pl_ref, Object::Dictionary(leaf));
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1, "non-dict value skipped");
assert_eq!(ranges[0].0, 0);
assert_eq!(ranges[0].1.style, LabelStyle::Decimal);
}
#[test]
fn ranges_non_name_style_resolves_to_none() {
let mut pdf = pdf_with_pagelabels(vec![]);
let pl_ref = ObjectRef::new(10, 0);
let mut lab = Dictionary::new();
lab.insert("S", Object::Integer(0)); let mut leaf = Dictionary::new();
leaf.insert(
"Nums",
Object::Array(vec![Object::Integer(0), Object::Dictionary(lab)]),
);
pdf.set_object(pl_ref, Object::Dictionary(leaf));
let mut h = pdf.page_labels();
let ranges = h.ranges().unwrap();
assert_eq!(ranges.len(), 1);
assert_eq!(ranges[0].1.style, LabelStyle::None);
}
#[test]
fn labels_for_page_range_fabricates_default_when_first_unlabeled() {
let mut pdf = pdf_with_pagelabels(vec![Object::Integer(5), label_dict("D", Some(1), None)]);
let mut h = pdf.page_labels();
let out = h.labels_for_page_range(0, 6, 0).unwrap();
assert_eq!(out[0].0, 0);
assert_eq!(out[0].1.style, LabelStyle::Decimal);
assert_eq!(out[0].1.start, 1);
assert!(out.iter().any(|(idx, _)| *idx == 5));
}
#[test]
fn helper_tolerates_non_dict_catalog() {
let mut pdf = pdf_with_pagelabels(vec![]);
let catalog_ref = pdf.root_ref().unwrap();
pdf.set_object(catalog_ref, Object::Integer(0)); let mut h = pdf.page_labels();
assert!(
!h.has_page_labels().unwrap(),
"non-dict catalog => no labels"
);
assert_eq!(h.ranges().unwrap(), vec![]);
h.set_range(
0,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
)
.unwrap();
}
#[test]
fn helper_tolerates_missing_root() {
let mut bytes = Vec::new();
bytes.extend_from_slice(b"%PDF-1.7\n");
let off1 = bytes.len() as u64;
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref = bytes.len() as u64;
bytes.extend_from_slice(
format!(
"xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \ntrailer\n<< /Size 2 >>\nstartxref\n{xref}\n%%EOF\n"
)
.as_bytes(),
);
let mut pdf = Pdf::open(Cursor::new(bytes)).expect("rootless trailer still opens");
assert!(pdf.root_ref().is_none(), "rootless trailer => no root_ref");
let mut h = pdf.page_labels();
assert!(!h.has_page_labels().unwrap());
assert_eq!(h.ranges().unwrap(), vec![]);
h.set_range(
0,
LabelRange {
style: LabelStyle::Decimal,
prefix: String::new(),
start: 1,
},
)
.unwrap();
}
}