use chrono::{Datelike, Duration, NaiveDate, NaiveDateTime, NaiveTime, Timelike}; use once_cell::sync::Lazy; use regex::Regex; use ropey::RopeSlice; use std::borrow::Cow; use std::cmp; use super::Increment; use crate::{Range, Tendril}; #[derive(Debug, PartialEq, Eq)] pub struct DateTimeIncrementor { date_time: NaiveDateTime, range: Range, fmt: &'static str, field: DateField, } impl DateTimeIncrementor { pub fn from_range(text: RopeSlice, range: Range) -> Option { let range = if range.is_empty() { if range.anchor < text.len_chars() { // Treat empty range as a cursor range. range.put_cursor(text, range.anchor + 1, true) } else { // The range is empty and at the end of the text. return None; } } else { range }; FORMATS.iter().find_map(|format| { let from = range.from().saturating_sub(format.max_len); let to = (range.from() + format.max_len).min(text.len_chars()); let (from_in_text, to_in_text) = (range.from() - from, range.to() - from); let text: Cow = text.slice(from..to).into(); let captures = format.regex.captures(&text)?; if captures.len() - 1 != format.fields.len() { return None; } let date_time = captures.get(0)?; let offset = range.from() - from_in_text; let range = Range::new(date_time.start() + offset, date_time.end() + offset); let field = captures .iter() .skip(1) .enumerate() .find_map(|(i, capture)| { let capture = capture?; let capture_range = capture.range(); if capture_range.contains(&from_in_text) && capture_range.contains(&(to_in_text - 1)) { Some(format.fields[i]) } else { None } })?; let has_date = format.fields.iter().any(|f| f.unit.is_date()); let has_time = format.fields.iter().any(|f| f.unit.is_time()); let date_time = &text[date_time.start()..date_time.end()]; let date_time = match (has_date, has_time) { (true, true) => NaiveDateTime::parse_from_str(date_time, format.fmt).ok()?, (true, false) => { let date = NaiveDate::parse_from_str(date_time, format.fmt).ok()?; date.and_hms(0, 0, 0) } (false, true) => { let time = NaiveTime::parse_from_str(date_time, format.fmt).ok()?; NaiveDate::from_ymd(0, 1, 1).and_time(time) } (false, false) => return None, }; Some(DateTimeIncrementor { date_time, range, fmt: format.fmt, field, }) }) } } impl Increment for DateTimeIncrementor { fn increment(&self, amount: i64) -> (Range, Tendril) { let date_time = match self.field.unit { DateUnit::Years => add_years(self.date_time, amount), DateUnit::Months => add_months(self.date_time, amount), DateUnit::Days => add_duration(self.date_time, Duration::days(amount)), DateUnit::Hours => add_duration(self.date_time, Duration::hours(amount)), DateUnit::Minutes => add_duration(self.date_time, Duration::minutes(amount)), DateUnit::Seconds => add_duration(self.date_time, Duration::seconds(amount)), DateUnit::AmPm => toggle_am_pm(self.date_time), } .unwrap_or(self.date_time); (self.range, date_time.format(self.fmt).to_string().into()) } } static FORMATS: Lazy> = Lazy::new(|| { vec![ Format::new("%Y-%m-%d %H:%M:%S"), // 2021-11-24 07:12:23 Format::new("%Y/%m/%d %H:%M:%S"), // 2021/11/24 07:12:23 Format::new("%Y-%m-%d %H:%M"), // 2021-11-24 07:12 Format::new("%Y/%m/%d %H:%M"), // 2021/11/24 07:12 Format::new("%Y-%m-%d"), // 2021-11-24 Format::new("%Y/%m/%d"), // 2021/11/24 Format::new("%a %b %d %Y"), // Wed Nov 24 2021 Format::new("%d-%b-%Y"), // 24-Nov-2021 Format::new("%Y %b %d"), // 2021 Nov 24 Format::new("%b %d, %Y"), // Nov 24, 2021 Format::new("%-I:%M:%S %P"), // 7:21:53 am Format::new("%-I:%M %P"), // 7:21 am Format::new("%-I:%M:%S %p"), // 7:21:53 AM Format::new("%-I:%M %p"), // 7:21 AM Format::new("%H:%M:%S"), // 23:24:23 Format::new("%H:%M"), // 23:24 ] }); #[derive(Debug)] struct Format { fmt: &'static str, fields: Vec, regex: Regex, max_len: usize, } impl Format { fn new(fmt: &'static str) -> Self { let mut remaining = fmt; let mut fields = Vec::new(); let mut regex = String::new(); let mut max_len = 0; while let Some(i) = remaining.find('%') { let after = &remaining[i + 1..]; let mut chars = after.chars(); let c = chars.next().unwrap(); let spec_len = if c == '-' { 1 + chars.next().unwrap().len_utf8() } else { c.len_utf8() }; let specifier = &after[..spec_len]; let field = DateField::from_specifier(specifier).unwrap(); fields.push(field); max_len += field.max_len + remaining[..i].len(); regex += &remaining[..i]; regex += &format!("({})", field.regex); remaining = &after[spec_len..]; } let regex = Regex::new(®ex).unwrap(); Self { fmt, fields, regex, max_len, } } } impl PartialEq for Format { fn eq(&self, other: &Self) -> bool { self.fmt == other.fmt && self.fields == other.fields && self.max_len == other.max_len } } impl Eq for Format {} #[derive(Copy, Clone, Debug, PartialEq, Eq)] struct DateField { regex: &'static str, unit: DateUnit, max_len: usize, } impl DateField { fn from_specifier(specifier: &str) -> Option { match specifier { "Y" => Some(Self { regex: r"\d{4}", unit: DateUnit::Years, max_len: 5, }), "y" => Some(Self { regex: r"\d\d", unit: DateUnit::Years, max_len: 2, }), "m" => Some(Self { regex: r"[0-1]\d", unit: DateUnit::Months, max_len: 2, }), "d" => Some(Self { regex: r"[0-3]\d", unit: DateUnit::Days, max_len: 2, }), "-d" => Some(Self { regex: r"[1-3]?\d", unit: DateUnit::Days, max_len: 2, }), "a" => Some(Self { regex: r"Sun|Mon|Tue|Wed|Thu|Fri|Sat", unit: DateUnit::Days, max_len: 3, }), "A" => Some(Self { regex: r"Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday", unit: DateUnit::Days, max_len: 9, }), "b" | "h" => Some(Self { regex: r"Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec", unit: DateUnit::Months, max_len: 3, }), "B" => Some(Self { regex: r"January|February|March|April|May|June|July|August|September|October|November|December", unit: DateUnit::Months, max_len: 9, }), "H" => Some(Self { regex: r"[0-2]\d", unit: DateUnit::Hours, max_len: 2, }), "M" => Some(Self { regex: r"[0-5]\d", unit: DateUnit::Minutes, max_len: 2, }), "S" => Some(Self { regex: r"[0-5]\d", unit: DateUnit::Seconds, max_len: 2, }), "I" => Some(Self { regex: r"[0-1]\d", unit: DateUnit::Hours, max_len: 2, }), "-I" => Some(Self { regex: r"1?\d", unit: DateUnit::Hours, max_len: 2, }), "P" => Some(Self { regex: r"am|pm", unit: DateUnit::AmPm, max_len: 2, }), "p" => Some(Self { regex: r"AM|PM", unit: DateUnit::AmPm, max_len: 2, }), _ => None, } } } #[derive(Copy, Clone, Debug, PartialEq, Eq)] enum DateUnit { Years, Months, Days, Hours, Minutes, Seconds, AmPm, } impl DateUnit { fn is_date(self) -> bool { matches!(self, DateUnit::Years | DateUnit::Months | DateUnit::Days) } fn is_time(self) -> bool { matches!( self, DateUnit::Hours | DateUnit::Minutes | DateUnit::Seconds ) } } fn ndays_in_month(year: i32, month: u32) -> u32 { // The first day of the next month... let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) }; let d = NaiveDate::from_ymd(y, m, 1); // ...is preceded by the last day of the original month. d.pred().day() } fn add_months(date_time: NaiveDateTime, amount: i64) -> Option { let month = (date_time.month0() as i64).checked_add(amount)?; let year = date_time.year() + i32::try_from(month / 12).ok()?; let year = if month.is_negative() { year - 1 } else { year }; // Normalize month let month = month % 12; let month = if month.is_negative() { month + 12 } else { month } as u32 + 1; let day = cmp::min(date_time.day(), ndays_in_month(year, month)); Some(NaiveDate::from_ymd(year, month, day).and_time(date_time.time())) } fn add_years(date_time: NaiveDateTime, amount: i64) -> Option { let year = i32::try_from((date_time.year() as i64).checked_add(amount)?).ok()?; let ndays = ndays_in_month(year, date_time.month()); if date_time.day() > ndays { let d = NaiveDate::from_ymd(year, date_time.month(), ndays); Some(d.succ().and_time(date_time.time())) } else { date_time.with_year(year) } } fn add_duration(date_time: NaiveDateTime, duration: Duration) -> Option { date_time.checked_add_signed(duration) } fn toggle_am_pm(date_time: NaiveDateTime) -> Option { if date_time.hour() < 12 { add_duration(date_time, Duration::hours(12)) } else { add_duration(date_time, Duration::hours(-12)) } } #[cfg(test)] mod test { use super::*; use crate::Rope; #[test] fn test_increment_date_times() { let tests = [ // (original, cursor, amount, expected) ("2020-02-28", 0, 1, "2021-02-28"), ("2020-02-29", 0, 1, "2021-03-01"), ("2020-01-31", 5, 1, "2020-02-29"), ("2020-01-20", 5, 1, "2020-02-20"), ("2021-01-01", 5, -1, "2020-12-01"), ("2021-01-31", 5, -2, "2020-11-30"), ("2020-02-28", 8, 1, "2020-02-29"), ("2021-02-28", 8, 1, "2021-03-01"), ("2021-02-28", 0, -1, "2020-02-28"), ("2021-03-01", 0, -1, "2020-03-01"), ("2020-02-29", 5, -1, "2020-01-29"), ("2020-02-20", 5, -1, "2020-01-20"), ("2020-02-29", 8, -1, "2020-02-28"), ("2021-03-01", 8, -1, "2021-02-28"), ("1980/12/21", 8, 100, "1981/03/31"), ("1980/12/21", 8, -100, "1980/09/12"), ("1980/12/21", 8, 1000, "1983/09/17"), ("1980/12/21", 8, -1000, "1978/03/27"), ("2021-11-24 07:12:23", 0, 1, "2022-11-24 07:12:23"), ("2021-11-24 07:12:23", 5, 1, "2021-12-24 07:12:23"), ("2021-11-24 07:12:23", 8, 1, "2021-11-25 07:12:23"), ("2021-11-24 07:12:23", 11, 1, "2021-11-24 08:12:23"), ("2021-11-24 07:12:23", 14, 1, "2021-11-24 07:13:23"), ("2021-11-24 07:12:23", 17, 1, "2021-11-24 07:12:24"), ("2021/11/24 07:12:23", 0, 1, "2022/11/24 07:12:23"), ("2021/11/24 07:12:23", 5, 1, "2021/12/24 07:12:23"), ("2021/11/24 07:12:23", 8, 1, "2021/11/25 07:12:23"), ("2021/11/24 07:12:23", 11, 1, "2021/11/24 08:12:23"), ("2021/11/24 07:12:23", 14, 1, "2021/11/24 07:13:23"), ("2021/11/24 07:12:23", 17, 1, "2021/11/24 07:12:24"), ("2021-11-24 07:12", 0, 1, "2022-11-24 07:12"), ("2021-11-24 07:12", 5, 1, "2021-12-24 07:12"), ("2021-11-24 07:12", 8, 1, "2021-11-25 07:12"), ("2021-11-24 07:12", 11, 1, "2021-11-24 08:12"), ("2021-11-24 07:12", 14, 1, "2021-11-24 07:13"), ("2021/11/24 07:12", 0, 1, "2022/11/24 07:12"), ("2021/11/24 07:12", 5, 1, "2021/12/24 07:12"), ("2021/11/24 07:12", 8, 1, "2021/11/25 07:12"), ("2021/11/24 07:12", 11, 1, "2021/11/24 08:12"), ("2021/11/24 07:12", 14, 1, "2021/11/24 07:13"), ("Wed Nov 24 2021", 0, 1, "Thu Nov 25 2021"), ("Wed Nov 24 2021", 4, 1, "Fri Dec 24 2021"), ("Wed Nov 24 2021", 8, 1, "Thu Nov 25 2021"), ("Wed Nov 24 2021", 11, 1, "Thu Nov 24 2022"), ("24-Nov-2021", 0, 1, "25-Nov-2021"), ("24-Nov-2021", 3, 1, "24-Dec-2021"), ("24-Nov-2021", 7, 1, "24-Nov-2022"), ("2021 Nov 24", 0, 1, "2022 Nov 24"), ("2021 Nov 24", 5, 1, "2021 Dec 24"), ("2021 Nov 24", 9, 1, "2021 Nov 25"), ("Nov 24, 2021", 0, 1, "Dec 24, 2021"), ("Nov 24, 2021", 4, 1, "Nov 25, 2021"), ("Nov 24, 2021", 8, 1, "Nov 24, 2022"), ("7:21:53 am", 0, 1, "8:21:53 am"), ("7:21:53 am", 3, 1, "7:22:53 am"), ("7:21:53 am", 5, 1, "7:21:54 am"), ("7:21:53 am", 8, 1, "7:21:53 pm"), ("7:21:53 AM", 0, 1, "8:21:53 AM"), ("7:21:53 AM", 3, 1, "7:22:53 AM"), ("7:21:53 AM", 5, 1, "7:21:54 AM"), ("7:21:53 AM", 8, 1, "7:21:53 PM"), ("7:21 am", 0, 1, "8:21 am"), ("7:21 am", 3, 1, "7:22 am"), ("7:21 am", 5, 1, "7:21 pm"), ("7:21 AM", 0, 1, "8:21 AM"), ("7:21 AM", 3, 1, "7:22 AM"), ("7:21 AM", 5, 1, "7:21 PM"), ("23:24:23", 1, 1, "00:24:23"), ("23:24:23", 3, 1, "23:25:23"), ("23:24:23", 6, 1, "23:24:24"), ("23:24", 1, 1, "00:24"), ("23:24", 3, 1, "23:25"), ]; for (original, cursor, amount, expected) in tests { let rope = Rope::from_str(original); let range = Range::new(cursor, cursor + 1); assert_eq!( DateTimeIncrementor::from_range(rope.slice(..), range) .unwrap() .increment(amount) .1, expected.into() ); } } #[test] fn test_invalid_date_times() { let tests = [ "0000-00-00", "1980-2-21", "1980-12-1", "12345", "2020-02-30", "1999-12-32", "19-12-32", "1-2-3", "0000/00/00", "1980/2/21", "1980/12/1", "12345", "2020/02/30", "1999/12/32", "19/12/32", "1/2/3", "123:456:789", "11:61", "2021-55-12 08:12:54", ]; for invalid in tests { let rope = Rope::from_str(invalid); let range = Range::new(0, 1); assert_eq!(DateTimeIncrementor::from_range(rope.slice(..), range), None) } } }