diff --git a/helix-core/src/increment/date.rs b/helix-core/src/increment/date.rs deleted file mode 100644 index 054429907..000000000 --- a/helix-core/src/increment/date.rs +++ /dev/null @@ -1,474 +0,0 @@ -use regex::Regex; - -use std::borrow::Cow; -use std::cmp; - -use ropey::RopeSlice; - -use crate::{Range, Tendril}; - -use chrono::{Datelike, Duration, NaiveDate}; - -use super::Increment; - -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_days(date: NaiveDate, amount: i64) -> Option { - date.checked_add_signed(Duration::days(amount)) -} - -fn add_months(date: NaiveDate, amount: i64) -> Option { - let month = date.month0() as i64 + amount; - let year = date.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 + 13 - } else { - month + 1 - } as u32; - - let day = cmp::min(date.day(), ndays_in_month(year, month)); - - Some(NaiveDate::from_ymd(year, month, day)) -} - -fn add_years(date: NaiveDate, amount: i64) -> Option { - let year = i32::try_from(date.year() as i64 + amount).ok()?; - let ndays = ndays_in_month(year, date.month()); - - if date.day() > ndays { - let d = NaiveDate::from_ymd(year, date.month(), ndays); - Some(d.succ()) - } else { - date.with_year(year) - } -} - -#[derive(Copy, Clone, Debug, PartialEq, Eq)] -struct Format { - regex: &'static str, - separator: char, -} - -// Only support formats that aren't region specific. -static FORMATS: &[Format] = &[ - Format { - regex: r"(\d{4})-(\d{2})-(\d{2})", - separator: '-', - }, - Format { - regex: r"(\d{4})/(\d{2})/(\d{2})", - separator: '/', - }, -]; - -const DATE_LENGTH: usize = 10; - -#[derive(Copy, Clone, Debug, PartialEq, Eq)] -enum DateField { - Year, - Month, - Day, -} - -#[derive(Debug, PartialEq, Eq)] -pub struct DateIncrementor { - date: NaiveDate, - range: Range, - field: DateField, - format: Format, -} - -impl DateIncrementor { - pub fn from_range(text: RopeSlice, range: Range) -> Option { - let range = if range.is_empty() { - if range.anchor < text.len_bytes() { - // 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 - }; - - let from = range.from().saturating_sub(DATE_LENGTH); - let to = (range.from() + DATE_LENGTH).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(); - - FORMATS.iter().find_map(|&format| { - let re = Regex::new(format.regex).ok()?; - let captures = re.captures(&text)?; - - let date = captures.get(0)?; - let offset = range.from() - from_in_text; - let range = Range::new(date.start() + offset, date.end() + offset); - - let (year, month, day) = (captures.get(1)?, captures.get(2)?, captures.get(3)?); - let (year_range, month_range, day_range) = (year.range(), month.range(), day.range()); - - let field = if year_range.contains(&from_in_text) - && year_range.contains(&(to_in_text - 1)) - { - DateField::Year - } else if month_range.contains(&from_in_text) && month_range.contains(&(to_in_text - 1)) - { - DateField::Month - } else if day_range.contains(&from_in_text) && day_range.contains(&(to_in_text - 1)) { - DateField::Day - } else { - return None; - }; - - let date = NaiveDate::from_ymd_opt( - year.as_str().parse::().ok()?, - month.as_str().parse::().ok()?, - day.as_str().parse::().ok()?, - )?; - - Some(DateIncrementor { - date, - field, - range, - format, - }) - }) - } -} - -impl Increment for DateIncrementor { - fn increment(&self, amount: i64) -> (Range, Tendril) { - let date = match self.field { - DateField::Year => add_years(self.date, amount), - DateField::Month => add_months(self.date, amount), - DateField::Day => add_days(self.date, amount), - } - .unwrap_or(self.date); - - ( - self.range, - format!( - "{:04}{}{:02}{}{:02}", - date.year(), - self.format.separator, - date.month(), - self.format.separator, - date.day() - ) - .into(), - ) - } -} - -#[cfg(test)] -mod test { - use super::*; - use crate::Rope; - - #[test] - fn test_create_incrementor_for_year_with_dashes() { - let rope = Rope::from_str("2021-11-15"); - - for cursor in 0..=3 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Year, - format: FORMATS[0], - }) - ); - } - } - - #[test] - fn test_create_incrementor_for_month_with_dashes() { - let rope = Rope::from_str("2021-11-15"); - - for cursor in 5..=6 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Month, - format: FORMATS[0], - }) - ); - } - } - - #[test] - fn test_create_incrementor_for_day_with_dashes() { - let rope = Rope::from_str("2021-11-15"); - - for cursor in 8..=9 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Day, - format: FORMATS[0], - }) - ); - } - } - - #[test] - fn test_try_create_incrementor_on_dashes() { - let rope = Rope::from_str("2021-11-15"); - - for &cursor in &[4, 7] { - let range = Range::new(cursor, cursor + 1); - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,); - } - } - - #[test] - fn test_create_incrementor_for_year_with_slashes() { - let rope = Rope::from_str("2021/11/15"); - - for cursor in 0..=3 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Year, - format: FORMATS[1], - }) - ); - } - } - - #[test] - fn test_create_incrementor_for_month_with_slashes() { - let rope = Rope::from_str("2021/11/15"); - - for cursor in 5..=6 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Month, - format: FORMATS[1], - }) - ); - } - } - - #[test] - fn test_create_incrementor_for_day_with_slashes() { - let rope = Rope::from_str("2021/11/15"); - - for cursor in 8..=9 { - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Day, - format: FORMATS[1], - }) - ); - } - } - - #[test] - fn test_try_create_incrementor_on_slashes() { - let rope = Rope::from_str("2021/11/15"); - - for &cursor in &[4, 7] { - let range = Range::new(cursor, cursor + 1); - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,); - } - } - - #[test] - fn test_date_surrounded_by_spaces() { - let rope = Rope::from_str(" 2021-11-15 "); - let range = Range::new(3, 4); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(3, 13), - field: DateField::Year, - format: FORMATS[0], - }) - ); - } - - #[test] - fn test_date_in_single_quotes() { - let rope = Rope::from_str("date = '2021-11-15'"); - let range = Range::new(10, 11); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(8, 18), - field: DateField::Year, - format: FORMATS[0], - }) - ); - } - - #[test] - fn test_date_in_double_quotes() { - let rope = Rope::from_str("let date = \"2021-11-15\";"); - let range = Range::new(12, 13); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(12, 22), - field: DateField::Year, - format: FORMATS[0], - }) - ); - } - - #[test] - fn test_date_cursor_one_right_of_date() { - let rope = Rope::from_str("2021-11-15 "); - let range = Range::new(10, 11); - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None); - } - - #[test] - fn test_date_cursor_one_left_of_number() { - let rope = Rope::from_str(" 2021-11-15"); - let range = Range::new(0, 1); - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None); - } - - #[test] - fn test_date_empty_range_at_beginning() { - let rope = Rope::from_str("2021-11-15"); - let range = Range::point(0); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Year, - format: FORMATS[0], - }) - ); - } - - #[test] - fn test_date_empty_range_at_in_middle() { - let rope = Rope::from_str("2021-11-15"); - let range = Range::point(5); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range), - Some(DateIncrementor { - date: NaiveDate::from_ymd(2021, 11, 15), - range: Range::new(0, 10), - field: DateField::Month, - format: FORMATS[0], - }) - ); - } - - #[test] - fn test_date_empty_range_at_end() { - let rope = Rope::from_str("2021-11-15"); - let range = Range::point(10); - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None); - } - - #[test] - fn test_invalid_dates() { - 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", - ]; - - for invalid in tests { - let rope = Rope::from_str(invalid); - let range = Range::new(0, 1); - - assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None); - } - } - - #[test] - fn test_increment_dates() { - 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"), - ]; - - for (original, cursor, amount, expected) in tests { - let rope = Rope::from_str(original); - let range = Range::new(cursor, cursor + 1); - assert_eq!( - DateIncrementor::from_range(rope.slice(..), range) - .unwrap() - .increment(amount) - .1, - expected.into() - ); - } - } -} diff --git a/helix-core/src/increment/date_time.rs b/helix-core/src/increment/date_time.rs new file mode 100644 index 000000000..393801044 --- /dev/null +++ b/helix-core/src/increment/date_time.rs @@ -0,0 +1,515 @@ +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, + format: Format, + 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 = match (has_date, has_time) { + (true, true) => NaiveDateTime::parse_from_str( + &text[date_time.start()..date_time.end()], + format.fmt, + ) + .ok()?, + (true, false) => { + let date = NaiveDate::parse_from_str( + &text[date_time.start()..date_time.end()], + format.fmt, + ) + .ok()?; + + date.and_hms(0, 0, 0) + } + (false, true) => { + let time = NaiveTime::parse_from_str( + &text[date_time.start()..date_time.end()], + format.fmt, + ) + .ok()?; + + NaiveDate::from_ymd(0, 1, 1).and_time(time) + } + (false, false) => return None, + }; + + Some(DateTimeIncrementor { + date_time, + range, + format: format.clone(), + 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.format.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(Clone, 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 mut chars = remaining[i + 1..].chars(); + let spec_len = if let Some(c) = chars.next() { + if c == '-' { + if chars.next().is_some() { + 2 + } else { + 0 + } + } else { + 1 + } + } else { + 0 + }; + + if i < remaining.len() - spec_len { + let specifier = &remaining[i + 1..i + 1 + spec_len]; + if let Some(field) = DateField::from_specifier(specifier) { + fields.push(field); + max_len += field.max_len + remaining[..i].len(); + regex += &remaining[..i]; + regex += &format!("({})", field.regex); + remaining = &remaining[i + spec_len + 1..]; + } else { + regex += &remaining[..=i]; + } + } else { + regex += remaining; + } + } + + 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(DateField { + regex: r"\d{4}", + unit: DateUnit::Years, + max_len: 5, + }), + "y" => Some(DateField { + regex: r"\d\d", + unit: DateUnit::Years, + max_len: 2, + }), + "m" => Some(DateField { + regex: r"[0-1]\d", + unit: DateUnit::Months, + max_len: 2, + }), + "d" => Some(DateField { + regex: r"[0-3]\d", + unit: DateUnit::Days, + max_len: 2, + }), + "-d" => Some(DateField { + regex: r"[1-3]?\d", + unit: DateUnit::Days, + max_len: 2, + }), + "a" => Some(DateField { + regex: r"Sun|Mon|Tue|Wed|Thu|Fri|Sat", + unit: DateUnit::Days, + max_len: 3, + }), + "A" => Some(DateField { + regex: r"Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday", + unit: DateUnit::Days, + max_len: 9, + }), + "b" | "h" => Some(DateField { + regex: r"Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec", + unit: DateUnit::Months, + max_len: 3, + }), + "B" => Some(DateField { + regex: r"January|February|March|April|May|June|July|August|September|October|November|December", + unit: DateUnit::Months, + max_len: 9, + }), + "H" => Some(DateField { + regex: r"[0-2]\d", + unit: DateUnit::Hours, + max_len: 2, + }), + "M" => Some(DateField { + regex: r"[0-5]\d", + unit: DateUnit::Minutes, + max_len: 2, + }), + "S" => Some(DateField { + regex: r"[0-5]\d", + unit: DateUnit::Seconds, + max_len: 2, + }), + "I" => Some(DateField { + regex: r"[0-1]\d", + unit: DateUnit::Hours, + max_len: 2, + }), + "-I" => Some(DateField { + regex: r"1?\d", + unit: DateUnit::Hours, + max_len: 2, + }), + "P" => Some(DateField { + regex: r"am|pm", + unit: DateUnit::AmPm, + max_len: 2, + }), + "p" => Some(DateField { + 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 + 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 + 13 + } else { + month + 1 + } as u32; + + 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 + 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) + } + } +} diff --git a/helix-core/src/increment/mod.rs b/helix-core/src/increment/mod.rs index 71a1f1833..f59457748 100644 --- a/helix-core/src/increment/mod.rs +++ b/helix-core/src/increment/mod.rs @@ -1,4 +1,4 @@ -pub mod date; +pub mod date_time; pub mod number; use crate::{Range, Tendril}; diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 6329dec75..4869a1356 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -1,7 +1,7 @@ use helix_core::{ comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes, history::UndoKind, - increment::date::DateIncrementor, + increment::date_time::DateTimeIncrementor, increment::{number::NumberIncrementor, Increment}, indent, indent::IndentStyle, @@ -5804,7 +5804,7 @@ fn increment_impl(cx: &mut Context, amount: i64) { let changes = selection.ranges().iter().filter_map(|range| { let incrementor: Option> = if let Some(incrementor) = - DateIncrementor::from_range(text.slice(..), *range) + DateTimeIncrementor::from_range(text.slice(..), *range) { Some(Box::new(incrementor)) } else if let Some(incrementor) = NumberIncrementor::from_range(text.slice(..), *range) {