use anyhow::{Context, Result};
use chrono::NaiveDate;
use regex::Regex;
const MONTH_NAMES: &[(&str, &str)] = &[
("enero", "January"),
("febrero", "February"),
("marzo", "March"),
("abril", "April"),
("mayo", "May"),
("junio", "June"),
("julio", "July"),
("agosto", "August"),
("septiembre", "September"),
("setiembre", "September"), ("sept", "Sep"),
("octubre", "October"),
("noviembre", "November"),
("diciembre", "December"),
];
const MONTHS_FULL: &str =
"January|February|March|April|May|June|July|August|September|October|November|December";
const MONTHS_ABBR: &str = "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec";
#[derive(Debug)]
pub struct DateScanner {
finders: Vec<(Regex, String)>,
months: Regex,
}
impl DateScanner {
pub fn new(formats: &[String]) -> Result<Self> {
let mut finders = Vec::with_capacity(formats.len());
for fmt in formats {
let pattern =
finder_pattern(fmt).with_context(|| format!("unsupported date format {fmt:?}"))?;
let re = Regex::new(&pattern)
.with_context(|| format!("date format {fmt:?} derived an invalid regex"))?;
finders.push((re, fmt.clone()));
}
let alternation: Vec<&str> = MONTH_NAMES.iter().map(|(m, _)| *m).collect();
let months = Regex::new(&format!(r"(?i)\b(?:{})\b", alternation.join("|")))
.expect("static month table regex");
Ok(Self { finders, months })
}
pub fn normalize_months(&self, text: &str) -> String {
self.months
.replace_all(text, |caps: ®ex::Captures<'_>| {
let hit = caps[0].to_lowercase();
MONTH_NAMES
.iter()
.find(|(m, _)| *m == hit)
.map(|(_, en)| *en)
.unwrap_or("")
.to_string()
})
.into_owned()
}
pub fn scan(&self, text: &str) -> Vec<NaiveDate> {
let text = self.normalize_months(text);
let mut hits: Vec<(usize, NaiveDate)> = Vec::new();
for (re, fmt) in &self.finders {
for m in re.find_iter(&text) {
let compact = m.as_str().split_whitespace().collect::<Vec<_>>().join(" ");
if let Ok(date) = NaiveDate::parse_from_str(&compact, fmt) {
if !hits.iter().any(|(pos, _)| *pos == m.start()) {
hits.push((m.start(), date));
}
}
}
}
hits.sort_by_key(|(pos, _)| *pos);
hits.into_iter().map(|(_, d)| d).collect()
}
}
fn finder_pattern(fmt: &str) -> Result<String> {
let mut out = String::new();
let mut chars = fmt.chars();
while let Some(c) = chars.next() {
if c == '%' {
let spec = chars
.next()
.context("dangling % at the end of the format")?;
match spec {
'B' => out.push_str(&format!("(?:{MONTHS_FULL})")),
'b' => out.push_str(&format!("(?:{MONTHS_ABBR})")),
'd' | 'e' => out.push_str(r"\d{1,2}"),
'm' => out.push_str(r"\d{1,2}"),
'Y' => out.push_str(r"\d{4}"),
'y' => out.push_str(r"\d{2}"),
'%' => out.push('%'),
other => anyhow::bail!("unsupported strftime specifier %{other}"),
}
} else if c.is_whitespace() {
out.push_str(r"\s+");
} else {
out.push_str(®ex::escape(&c.to_string()));
}
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
fn scanner(formats: &[&str]) -> DateScanner {
let owned: Vec<String> = formats.iter().map(|s| s.to_string()).collect();
DateScanner::new(&owned).unwrap()
}
fn ymd(y: i32, m: u32, d: u32) -> NaiveDate {
NaiveDate::from_ymd_opt(y, m, d).unwrap()
}
#[test]
fn finds_english_month_dates_in_prose() {
let s = scanner(&["%B %d, %Y"]);
let dates = s.scan("adopted as permanent on January 9, 2019. See In re");
assert_eq!(dates, vec![ymd(2019, 1, 9)]);
}
#[test]
fn doubled_spaces_still_parse() {
let s = scanner(&["%B %d, %Y"]);
assert_eq!(
s.scan("Effective February 13, 2002 [rev]"),
vec![ymd(2002, 2, 13)]
);
}
#[test]
fn bluebook_sept_abbreviation_normalizes_via_the_table() {
let s = scanner(&["%b. %d, %Y"]);
assert_eq!(
s.scan("Amended, effective Sept. 25, 2023."),
vec![ymd(2023, 9, 25)]
);
let s = scanner(&["%B %d, %Y"]);
assert_eq!(
s.scan("effective September 25, 2023"),
vec![ymd(2023, 9, 25)]
);
}
#[test]
fn multiple_dates_come_back_in_text_order() {
let s = scanner(&["%B %d, %Y", "%m/%d/%Y"]);
let dates = s.scan("adopted 08/01/1998; amended effective March 2, 2004");
assert_eq!(dates, vec![ymd(1998, 8, 1), ymd(2004, 3, 2)]);
}
#[test]
fn spanish_month_names_normalize_via_the_table() {
let s = scanner(&["%d de %B de %Y"]);
assert_eq!(
s.scan("enmendada el 9 de enero de 2019"),
vec![ymd(2019, 1, 9)]
);
assert_eq!(
s.scan("efectivo el 1 de Septiembre de 2020"),
vec![ymd(2020, 9, 1)]
);
}
#[test]
fn abbreviated_months_and_literal_dots() {
let s = scanner(&["%b. %d, %Y"]);
assert_eq!(s.scan("amended Feb. 25, 2019"), vec![ymd(2019, 2, 25)]);
}
#[test]
fn nonsense_numbers_do_not_parse() {
let s = scanner(&["%m/%d/%Y"]);
assert!(s.scan("case no. 80/99/0012 is not a date").is_empty());
}
#[test]
fn unsupported_specifier_is_rejected() {
let err = DateScanner::new(&["%H:%M".to_string()]).unwrap_err();
assert!(format!("{err:#}").contains("unsupported strftime specifier"));
}
}