Add support for incrementing year and month

pull/1235/head
Jason Rodney Hansen 3 years ago committed by Ivan Tham
parent c1f6167e37
commit 95cfeed2fa

11
Cargo.lock generated

@ -325,6 +325,15 @@ dependencies = [
"regex", "regex",
] ]
[[package]]
name = "gregorian"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3452972f2c995c38dc9b84f09fe14f1ca462a0580642fe6756fed58fdef29050"
dependencies = [
"libc",
]
[[package]] [[package]]
name = "grep-matcher" name = "grep-matcher"
version = "0.1.5" version = "0.1.5"
@ -369,8 +378,8 @@ name = "helix-core"
version = "0.5.0" version = "0.5.0"
dependencies = [ dependencies = [
"arc-swap", "arc-swap",
"chrono",
"etcetera", "etcetera",
"gregorian",
"helix-syntax", "helix-syntax",
"log", "log",
"once_cell", "once_cell",

@ -36,7 +36,7 @@ similar = "2.1"
etcetera = "0.3" etcetera = "0.3"
chrono = { version = "0.4", default-features = false, features = ["alloc", "std"] } gregorian = "0.2.1"
[dev-dependencies] [dev-dependencies]
quickcheck = { version = "1", default-features = false } quickcheck = { version = "1", default-features = false }

@ -1,70 +1,124 @@
use chrono::{Duration, NaiveDate}; use gregorian::{Date, DateResultExt};
use regex::Regex;
use std::borrow::Cow; use std::borrow::Cow;
use ropey::RopeSlice; use ropey::RopeSlice;
use crate::{ use crate::{Range, Tendril};
textobject::{textobject_word, TextObject},
Range, Tendril, #[derive(Copy, Clone, Debug, PartialEq, Eq)]
}; struct Format {
regex: &'static str,
separator: char,
}
// Only support formats that aren't region specific. // Only support formats that aren't region specific.
static FORMATS: &[&str] = &["%Y-%m-%d", "%Y/%m/%d"]; static FORMATS: &[Format] = &[
Format {
regex: r"(\d{4})-(\d{2})-(\d{2})",
separator: '-',
},
Format {
regex: r"(\d{4})/(\d{2})/(\d{2})",
separator: '/',
},
];
// We don't want to parse ambiguous dates like 10/11/12 or 7/8/10.
// They must be YYYY-mm-dd or YYYY/mm/dd.
// So 2021-01-05 works, but 2021-1-5 doesn't.
const DATE_LENGTH: usize = 10; const DATE_LENGTH: usize = 10;
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum DateField {
Year,
Month,
Day,
}
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]
pub struct DateIncrementor { pub struct DateIncrementor {
pub date: NaiveDate, pub date: Date,
pub range: Range, pub range: Range,
pub format: &'static str,
field: DateField,
format: Format,
} }
impl DateIncrementor { impl DateIncrementor {
pub fn from_range(text: RopeSlice, range: Range) -> Option<DateIncrementor> { pub fn from_range(text: RopeSlice, range: Range) -> Option<DateIncrementor> {
// Don't increment if the cursor is one right of the date text. let from = range.from().saturating_sub(DATE_LENGTH);
if text.char(range.from()).is_whitespace() { let to = (range.from() + DATE_LENGTH).min(text.len_chars());
return None; let (from_in_text, to_in_text) = (range.from() - from, range.to() - from);
} let text: Cow<str> = text.slice(from..to).into();
let range = textobject_word(text, range, TextObject::Inside, 1, true); FORMATS.iter().find_map(|&format| {
let text: Cow<str> = text.slice(range.from()..range.to()).into(); let re = Regex::new(format.regex).ok()?;
let captures = re.captures(&text)?;
let first = text.chars().next()?; let date = captures.get(0)?;
let last = text.chars().next_back()?; let offset = range.from() - from_in_text;
let range = Range::new(date.start() + offset, date.end() + offset);
// Allow date strings in quotes. let year = captures.get(1)?;
let (range, text) = if first == last && (first == '"' || first == '\'') { let month = captures.get(2)?;
( let day = captures.get(3)?;
Range::new(range.from() + 1, range.to() - 1),
Cow::from(&text[1..text.len() - 1]),
)
} else {
(range, text)
};
if text.len() != DATE_LENGTH { let year_range = year.range();
return None; let month_range = month.range();
} let day_range = day.range();
FORMATS.iter().find_map(|format| { let to_inclusive = if to_in_text > from_in_text {
NaiveDate::parse_from_str(&text, format) to_in_text - 1
.ok() } else {
.map(|date| DateIncrementor { to_in_text
date, };
range, let field = if year_range.contains(&from_in_text) && year_range.contains(&to_inclusive)
format, {
}) DateField::Year
} else if month_range.contains(&from_in_text) && month_range.contains(&to_inclusive) {
DateField::Month
} else if day_range.contains(&from_in_text) && day_range.contains(&to_inclusive) {
DateField::Day
} else {
return None;
};
let year: i16 = year.as_str().parse().ok()?;
let month: u8 = month.as_str().parse().ok()?;
let day: u8 = day.as_str().parse().ok()?;
let date = Date::new(year, month, day).ok()?;
Some(DateIncrementor {
date,
field,
range,
format,
})
}) })
} }
pub fn incremented_text(&self, amount: i64) -> Tendril { pub fn incremented_text(&self, amount: i64) -> Tendril {
let incremented_date = self.date + Duration::days(amount); let date = match self.field {
incremented_date.format(self.format).to_string().into() DateField::Year => self
.date
.add_years(amount.try_into().unwrap_or(0))
.or_next_valid(),
DateField::Month => self
.date
.add_months(amount.try_into().unwrap_or(0))
.or_prev_valid(),
DateField::Day => self.date.add_days(amount.try_into().unwrap_or(0)),
};
format!(
"{:04}{}{:02}{}{:02}",
date.year(),
self.format.separator,
date.month().to_number(),
self.format.separator,
date.day()
)
.into()
} }
} }
@ -74,43 +128,144 @@ mod test {
use crate::Rope; use crate::Rope;
#[test] #[test]
fn test_date_dashes() { fn test_create_incrementor_for_year_with_dashes() {
let rope = Rope::from_str("2021-11-15"); let rope = Rope::from_str("2021-11-15");
let range = Range::point(0);
assert_eq!( for head in 0..=3 {
DateIncrementor::from_range(rope.slice(..), range), let range = Range::point(head);
Some(DateIncrementor { assert_eq!(
date: NaiveDate::from_ymd(2021, 11, 15), DateIncrementor::from_range(rope.slice(..), range),
range: Range::new(0, 10), Some(DateIncrementor {
format: "%Y-%m-%d", date: Date::new(2021, 11, 15).unwrap(),
}) 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 head in 5..=6 {
let range = Range::point(head);
assert_eq!(
DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor {
date: Date::new(2021, 11, 15).unwrap(),
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 head in 8..=9 {
let range = Range::point(head);
assert_eq!(
DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor {
date: Date::new(2021, 11, 15).unwrap(),
range: Range::new(0, 10),
field: DateField::Day,
format: FORMATS[0],
})
);
}
} }
#[test] #[test]
fn test_date_slashes() { fn test_try_create_incrementor_on_dashes() {
let rope = Rope::from_str("2021-11-15");
for head in &[4, 7] {
let range = Range::point(*head);
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"); let rope = Rope::from_str("2021/11/15");
let range = Range::point(0);
assert_eq!( for head in 0..=3 {
DateIncrementor::from_range(rope.slice(..), range), let range = Range::point(head);
Some(DateIncrementor { assert_eq!(
date: NaiveDate::from_ymd(2021, 11, 15), DateIncrementor::from_range(rope.slice(..), range),
range: Range::new(0, 10), Some(DateIncrementor {
format: "%Y/%m/%d", date: Date::new(2021, 11, 15).unwrap(),
}) 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 head in 5..=6 {
let range = Range::point(head);
assert_eq!(
DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor {
date: Date::new(2021, 11, 15).unwrap(),
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 head in 8..=9 {
let range = Range::point(head);
assert_eq!(
DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor {
date: Date::new(2021, 11, 15).unwrap(),
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 head in &[4, 7] {
let range = Range::point(*head);
assert_eq!(DateIncrementor::from_range(rope.slice(..), range), None,);
}
} }
#[test] #[test]
fn test_date_surrounded_by_spaces() { fn test_date_surrounded_by_spaces() {
let rope = Rope::from_str(" 2021-11-15 "); let rope = Rope::from_str(" 2021-11-15 ");
let range = Range::point(10); let range = Range::point(3);
assert_eq!( assert_eq!(
DateIncrementor::from_range(rope.slice(..), range), DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor { Some(DateIncrementor {
date: NaiveDate::from_ymd(2021, 11, 15), date: Date::new(2021, 11, 15).unwrap(),
range: Range::new(3, 13), range: Range::new(3, 13),
format: "%Y-%m-%d", field: DateField::Year,
format: FORMATS[0],
}) })
); );
} }
@ -122,23 +277,25 @@ mod test {
assert_eq!( assert_eq!(
DateIncrementor::from_range(rope.slice(..), range), DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor { Some(DateIncrementor {
date: NaiveDate::from_ymd(2021, 11, 15), date: Date::new(2021, 11, 15).unwrap(),
range: Range::new(8, 18), range: Range::new(8, 18),
format: "%Y-%m-%d", field: DateField::Year,
format: FORMATS[0],
}) })
); );
} }
#[test] #[test]
fn test_date_in_double_quotes() { fn test_date_in_double_quotes() {
let rope = Rope::from_str("date = \"2021-11-15\""); let rope = Rope::from_str("let date = \"2021-11-15\";");
let range = Range::point(10); let range = Range::point(12);
assert_eq!( assert_eq!(
DateIncrementor::from_range(rope.slice(..), range), DateIncrementor::from_range(rope.slice(..), range),
Some(DateIncrementor { Some(DateIncrementor {
date: NaiveDate::from_ymd(2021, 11, 15), date: Date::new(2021, 11, 15).unwrap(),
range: Range::new(8, 18), range: Range::new(12, 22),
format: "%Y-%m-%d", field: DateField::Year,
format: FORMATS[0],
}) })
); );
} }
@ -189,23 +346,28 @@ mod test {
#[test] #[test]
fn test_increment_dates() { fn test_increment_dates() {
let tests = [ let tests = [
("1980-12-21", 1, "1980-12-22"), // (original, cursor, amount, expected)
("1980-12-21", -1, "1980-12-20"), ("2020-02-28", 0, 1, "2021-02-28"),
("1980-12-21", 100, "1981-03-31"), ("2020-02-29", 0, 1, "2021-03-01"),
("1980-12-21", -100, "1980-09-12"), ("2020-01-31", 5, 1, "2020-02-29"),
("1980-12-21", 1000, "1983-09-17"), ("2020-01-20", 5, 1, "2020-02-20"),
("1980-12-21", -1000, "1978-03-27"), ("2020-02-28", 8, 1, "2020-02-29"),
("1980/12/21", 1, "1980/12/22"), ("2021-02-28", 8, 1, "2021-03-01"),
("1980/12/21", -1, "1980/12/20"), ("2021-02-28", 0, -1, "2020-02-28"),
("1980/12/21", 100, "1981/03/31"), ("2021-03-01", 0, -1, "2020-03-01"),
("1980/12/21", -100, "1980/09/12"), ("2020-02-29", 5, -1, "2020-01-29"),
("1980/12/21", 1000, "1983/09/17"), ("2020-02-20", 5, -1, "2020-01-20"),
("1980/12/21", -1000, "1978/03/27"), ("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, amount, expected) in tests { for (original, cursor, amount, expected) in tests {
let rope = Rope::from_str(original); let rope = Rope::from_str(original);
let range = Range::point(0); let range = Range::point(cursor);
assert_eq!( assert_eq!(
DateIncrementor::from_range(rope.slice(..), range) DateIncrementor::from_range(rope.slice(..), range)
.unwrap() .unwrap()

Loading…
Cancel
Save