use crate::{Error, Result};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Endpoint {
Num(u32),
Z,
FromEnd(u32),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Parity {
Odd,
Even,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageRangeEntry {
pub start: Endpoint,
pub end: Option<Endpoint>,
pub parity: Option<Parity>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageRange {
pub(crate) entries: Option<Vec<PageRangeEntry>>,
}
impl PageRange {
pub fn parse(input: &str) -> Result<Self> {
if input.is_empty() {
return Ok(Self { entries: None });
}
let entries = parse_entries(input)?;
Ok(Self {
entries: Some(entries),
})
}
pub fn empty() -> Self {
Self {
entries: Some(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 entries = match &self.entries {
None => return Ok((1..=page_count).collect()),
Some(e) => e,
};
let mut result: Vec<u32> = Vec::new();
for entry in entries {
result.extend(resolve_entry(entry, page_count)?);
}
Ok(result)
}
}
fn resolve_endpoint(ep: &Endpoint, page_count: u32) -> Result<u32> {
match ep {
Endpoint::Num(n) => {
if *n > page_count {
return Err(Error::parse(
0,
format!("page number {n} is out of range (document has {page_count} page(s))"),
));
}
Ok(*n)
}
Endpoint::Z => Ok(page_count),
Endpoint::FromEnd(n) => {
if *n > page_count {
return Err(Error::parse(
0,
format!("r{n} is out of range (document has {page_count} page(s))"),
));
}
Ok(page_count + 1 - n)
}
}
}
fn resolve_entry(entry: &PageRangeEntry, page_count: u32) -> Result<Vec<u32>> {
let start = resolve_endpoint(&entry.start, page_count)?;
let end = match &entry.end {
None => start,
Some(ep) => resolve_endpoint(ep, page_count)?,
};
let seq: Vec<u32> = if start <= end {
(start..=end).collect()
} else {
(end..=start).rev().collect()
};
let filtered = match entry.parity {
None => seq,
Some(Parity::Odd) => seq
.into_iter()
.enumerate()
.filter(|(i, _)| i % 2 == 0)
.map(|(_, p)| p)
.collect(),
Some(Parity::Even) => seq
.into_iter()
.enumerate()
.filter(|(i, _)| i % 2 == 1)
.map(|(_, p)| p)
.collect(),
};
Ok(filtered)
}
struct RangeParser<'a> {
input: &'a str,
pos: usize,
}
impl<'a> RangeParser<'a> {
fn new(input: &'a str) -> Self {
Self { input, pos: 0 }
}
fn remaining(&self) -> &str {
&self.input[self.pos..]
}
fn peek(&self) -> Option<char> {
self.remaining().chars().next()
}
fn advance(&mut self, n: usize) {
self.pos += n;
}
fn err(&self, msg: impl Into<String>) -> Error {
Error::parse(self.pos, msg.into())
}
fn parse_u32(&mut self) -> Result<u32> {
let start = self.pos;
let digits: String = self
.remaining()
.chars()
.take_while(|c| c.is_ascii_digit())
.collect();
if digits.is_empty() {
return Err(self.err(format!("expected a page number at position {}", self.pos)));
}
self.advance(digits.len());
digits
.parse::<u32>()
.map_err(|_| Error::parse(start, format!("page number too large at position {start}")))
}
fn parse_endpoint(&mut self) -> Result<Endpoint> {
match self.peek() {
Some('z') => {
self.advance(1);
Ok(Endpoint::Z)
}
Some('r') => {
self.advance(1);
let n = self.parse_u32()?;
if n == 0 {
return Err(self.err("r0 is invalid; r1 means the last page"));
}
Ok(Endpoint::FromEnd(n))
}
Some(c) if c.is_ascii_digit() => {
let start_pos = self.pos;
let n = self.parse_u32()?;
if n == 0 {
return Err(Error::parse(
start_pos,
"page number 0 is invalid; pages are 1-based",
));
}
Ok(Endpoint::Num(n))
}
Some(c) => Err(self.err(format!(
"unexpected character '{c}' at position {}; expected a page number, 'z', or 'rN'",
self.pos
))),
None => Err(self.err(format!(
"unexpected end of input at position {}; expected a page number, 'z', or 'rN'",
self.pos
))),
}
}
fn parse_entry(&mut self) -> Result<PageRangeEntry> {
let start = self.parse_endpoint()?;
let end = if self.remaining().starts_with('-') {
self.advance(1);
Some(self.parse_endpoint()?)
} else {
None
};
let parity = if self.remaining().starts_with(':') {
self.advance(1); if self.remaining().starts_with("odd") {
self.advance(3);
Some(Parity::Odd)
} else if self.remaining().starts_with("even") {
self.advance(4);
Some(Parity::Even)
} else {
let token: String = self
.remaining()
.chars()
.take_while(|c| c.is_alphanumeric())
.collect();
return Err(self.err(format!(
"unknown parity suffix ':{token}' at position {}; expected ':odd' or ':even'",
self.pos
)));
}
} else {
None
};
Ok(PageRangeEntry { start, end, parity })
}
}
fn parse_entries(input: &str) -> Result<Vec<PageRangeEntry>> {
let mut p = RangeParser::new(input);
let mut entries = Vec::new();
loop {
match p.peek() {
None => break,
Some(',') => {
return Err(p.err(format!(
"empty entry at position {}; consecutive commas are not allowed",
p.pos
)));
}
_ => {}
}
entries.push(p.parse_entry()?);
match p.peek() {
None => break,
Some(',') => {
p.advance(1);
if p.peek().is_none() {
return Err(p.err(format!("trailing comma at position {}", p.pos)));
}
}
Some(c) => {
return Err(p.err(format!(
"unexpected character '{c}' at position {}; expected ',' or end of input",
p.pos
)));
}
}
}
if entries.is_empty() {
return Err(Error::parse(0, "page range is empty"));
}
Ok(entries)
}
#[cfg(test)]
mod tests {
use super::*;
fn parse_ok(input: &str) -> PageRange {
PageRange::parse(input).unwrap_or_else(|e| panic!("expected Ok for {input:?}, got: {e}"))
}
fn parse_err(input: &str) -> String {
PageRange::parse(input)
.err()
.unwrap_or_else(|| panic!("expected Err for {input:?}"))
.to_string()
}
#[test]
fn empty_string_is_all_pages() {
let pr = parse_ok("");
assert_eq!(pr.entries, None);
}
#[test]
fn single_page() {
let pr = parse_ok("3");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].start, Endpoint::Num(3));
assert_eq!(entries[0].end, None);
assert_eq!(entries[0].parity, None);
}
#[test]
fn z_endpoint() {
let pr = parse_ok("z");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::Z);
}
#[test]
fn from_end_endpoint() {
let pr = parse_ok("r3");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::FromEnd(3));
}
#[test]
fn ascending_range() {
let pr = parse_ok("1-5");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::Num(1));
assert_eq!(entries[0].end, Some(Endpoint::Num(5)));
}
#[test]
fn descending_range() {
let pr = parse_ok("5-1");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::Num(5));
assert_eq!(entries[0].end, Some(Endpoint::Num(1)));
}
#[test]
fn range_with_z() {
let pr = parse_ok("r3-z");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::FromEnd(3));
assert_eq!(entries[0].end, Some(Endpoint::Z));
}
#[test]
fn odd_parity() {
let pr = parse_ok("1-9:odd");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].parity, Some(Parity::Odd));
}
#[test]
fn even_parity() {
let pr = parse_ok("1-9:even");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].parity, Some(Parity::Even));
}
#[test]
fn multiple_entries() {
let pr = parse_ok("1,3,5-9,15-12");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries.len(), 4);
}
#[test]
fn parity_on_single_page() {
let pr = parse_ok("5:odd");
let entries = pr.entries.as_ref().unwrap();
assert_eq!(entries[0].start, Endpoint::Num(5));
assert_eq!(entries[0].parity, Some(Parity::Odd));
}
#[test]
fn page_zero_is_invalid() {
let msg = parse_err("0");
assert!(msg.contains("0 is invalid"), "got: {msg}");
}
#[test]
fn r0_is_invalid() {
let msg = parse_err("r0");
assert!(msg.contains("r0 is invalid"), "got: {msg}");
}
#[test]
fn trailing_dash_is_invalid() {
let msg = parse_err("1-");
assert!(msg.contains("expected a page number"), "got: {msg}");
}
#[test]
fn leading_dash_is_invalid() {
let msg = parse_err("-1");
assert!(msg.contains("unexpected character"), "got: {msg}");
}
#[test]
fn double_comma_is_invalid() {
let msg = parse_err("1,,2");
assert!(
msg.contains("empty entry") || msg.contains("consecutive commas"),
"got: {msg}"
);
}
#[test]
fn trailing_comma_is_invalid() {
let msg = parse_err("1,2,");
assert!(msg.contains("trailing comma"), "got: {msg}");
}
#[test]
fn unknown_suffix_is_invalid() {
let msg = parse_err("1-9:foo");
assert!(msg.contains("unknown parity suffix"), "got: {msg}");
}
#[test]
fn bare_colon_is_invalid() {
let msg = parse_err(":odd");
assert!(!msg.is_empty());
}
#[test]
fn alpha_input_is_invalid() {
let msg = parse_err("abc");
assert!(!msg.is_empty());
}
#[test]
fn lone_r_without_number_is_invalid() {
let msg = parse_err("r");
assert!(msg.contains("expected a page number"), "got: {msg}");
}
fn resolve(input: &str, page_count: u32) -> Vec<u32> {
PageRange::parse(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(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 empty_resolves_to_all() {
assert_eq!(resolve("", 5), vec![1, 2, 3, 4, 5]);
}
#[test]
fn empty_constructor_selects_no_pages() {
let none = PageRange::empty();
assert_eq!(none.entries, Some(Vec::new()));
assert_eq!(none.resolve(5).unwrap(), Vec::<u32>::new());
assert_ne!(none, PageRange::parse("").unwrap());
}
#[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 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 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("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]);
}
}