use crate::{Error, Result};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageRange {
raw: Vec<u8>,
}
impl PageRange {
pub fn parse_numrange(input: &str) -> Result<Self> {
crate::qutil::parse_numrange(input.as_bytes(), 0)?;
Ok(Self {
raw: input.as_bytes().to_vec(),
})
}
pub fn all() -> Self {
Self {
raw: b"1-z".to_vec(),
}
}
pub fn empty() -> Self {
Self { raw: Vec::new() }
}
pub fn resolve(&self, page_count: u32) -> Result<Vec<u32>> {
if page_count == 0 {
return Err(Error::parse(0, "page_count must be at least 1"));
}
let max = crate::qutil::qpdf_size_to_int(page_count as usize)?;
Ok(crate::qutil::parse_numrange(&self.raw, max)?
.into_iter()
.map(|page| page as u32)
.collect())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_accepts_qpdf_syntax_only_values() {
assert!(PageRange::parse_numrange("0").is_ok());
assert!(PageRange::parse_numrange("r0").is_ok());
assert!(PageRange::parse_numrange("99").is_ok());
assert!(PageRange::parse_numrange(":odd").is_ok());
}
#[test]
fn parse_rejects_only_qpdf_invalid_syntax() {
for input in ["1-", "-1", "1,,2", "1,2,", "1-9:foo", "abc", "r"] {
assert!(
PageRange::parse_numrange(input).is_err(),
"{input:?} must be invalid"
);
}
}
#[test]
fn resolve_preserves_qpdf_numeric_range_error_bytes() {
let range = PageRange::parse_numrange("0").expect("qpdf syntax-only parse accepts zero");
let error = range
.resolve(3)
.expect_err("zero is out of range for three pages");
assert_eq!(
error.raw_message(),
Some(b"error at * in numeric range *0: number 0 out of range".as_slice())
);
let range = PageRange::parse_numrange("r0").expect("qpdf syntax-only parse accepts r0");
let error = range
.resolve(3)
.expect_err("r0 resolves beyond the last page");
assert_eq!(
error.raw_message(),
Some(b"error at * in numeric range *r0: number 4 out of range".as_slice())
);
}
#[test]
fn parse_empty_is_the_qpdf_empty_selection() {
let range = PageRange::parse_numrange("").expect("empty qpdf range is valid syntax");
assert_eq!(range.resolve(3).unwrap(), Vec::<u32>::new());
}
fn resolve(input: &str, page_count: u32) -> Vec<u32> {
PageRange::parse_numrange(input)
.and_then(|pr| pr.resolve(page_count))
.unwrap_or_else(|e| {
panic!("expected Ok for {input:?} with {page_count} pages, got: {e}")
})
}
fn resolve_err(input: &str, page_count: u32) -> String {
let pr = PageRange::parse_numrange(input).expect("parse should succeed");
pr.resolve(page_count)
.err()
.unwrap_or_else(|| panic!("expected Err for {input:?} with {page_count} pages"))
.to_string()
}
#[test]
fn all_constructor_resolves_to_all() {
assert_eq!(PageRange::all().resolve(5).unwrap(), vec![1, 2, 3, 4, 5]);
}
#[test]
fn empty_constructor_selects_no_pages() {
let none = PageRange::empty();
assert_eq!(none.resolve(5).unwrap(), Vec::<u32>::new());
assert_eq!(none, PageRange::parse_numrange("").unwrap());
assert_ne!(none, PageRange::all());
}
#[test]
fn single_page_resolve() {
assert_eq!(resolve("3", 10), vec![3]);
}
#[test]
fn z_resolves_to_last() {
assert_eq!(resolve("z", 7), vec![7]);
}
#[test]
fn r1_resolves_to_last() {
assert_eq!(resolve("r1", 7), vec![7]);
}
#[test]
fn r2_resolves_to_second_to_last() {
assert_eq!(resolve("r2", 7), vec![6]);
}
#[test]
fn ascending_range_resolve() {
assert_eq!(resolve("1-5", 10), vec![1, 2, 3, 4, 5]);
}
#[test]
fn descending_range_resolve() {
assert_eq!(resolve("5-1", 10), vec![5, 4, 3, 2, 1]);
}
#[test]
fn r3_to_z_resolve() {
assert_eq!(resolve("r3-z", 5), vec![3, 4, 5]);
}
#[test]
fn odd_parity_resolve() {
assert_eq!(resolve("1-9:odd", 9), vec![1, 3, 5, 7, 9]);
}
#[test]
fn even_parity_resolve() {
assert_eq!(resolve("1-9:even", 9), vec![2, 4, 6, 8]);
}
#[test]
fn parity_applies_to_the_whole_selection_not_each_group() {
assert_eq!(resolve("1-3,5-7:odd", 10), vec![1, 3, 6]);
assert_eq!(resolve("1-3,5-7:even", 10), vec![2, 5, 7]);
}
#[test]
fn parity_is_applied_after_exclusion_groups() {
assert_eq!(resolve("1-6,x3:odd", 10), vec![1, 4, 6]);
}
#[test]
fn even_parity_offset_range() {
assert_eq!(resolve("2-8:even", 10), vec![3, 5, 7]);
}
#[test]
fn one_to_twenty_even() {
let expected: Vec<u32> = (1..=10).map(|i| i * 2).collect();
assert_eq!(resolve("1-20:even", 20), expected);
}
#[test]
fn duplicates_preserved_in_declaration_order() {
assert_eq!(resolve("1,3,5,3", 10), vec![1, 3, 5, 3]);
}
#[test]
fn repeated_slot_preserved() {
assert_eq!(resolve("1,1,1,1", 5), vec![1, 1, 1, 1]);
}
#[test]
fn mixed_selection() {
let result = resolve("1,3,5-9,15-12", 20);
let expected = vec![1, 3, 5, 6, 7, 8, 9, 15, 14, 13, 12];
assert_eq!(result, expected);
}
#[test]
fn exclusion_group_removes_pages_from_the_previous_group() {
assert_eq!(resolve("1-3,x2", 3), vec![1, 3]);
}
#[test]
fn exclusion_group_may_not_be_the_first_group() {
let message = PageRange::parse_numrange("x2").unwrap_err().to_string();
assert!(
message.contains("first") || message.contains("exclusion"),
"got: {message}"
);
}
#[test]
fn out_of_range_page_number_is_error() {
let msg = resolve_err("10", 5);
assert!(msg.contains("out of range"), "got: {msg}");
}
#[test]
fn out_of_range_from_end_is_error() {
let msg = resolve_err("r10", 5);
assert!(msg.contains("out of range"), "got: {msg}");
}
#[test]
fn page_count_zero_is_error() {
let pr = PageRange::parse_numrange("1").unwrap();
let err = pr.resolve(0).unwrap_err().to_string();
assert!(err.contains("page_count must be at least 1"), "got: {err}");
}
#[test]
fn z_with_single_page_doc() {
assert_eq!(resolve("z", 1), vec![1]);
}
#[test]
fn full_doc_range_z_1() {
assert_eq!(resolve("z-1", 5), vec![5, 4, 3, 2, 1]);
}
}