diff options
| -rw-r--r-- | CHANGES.md | 3 | ||||
| -rw-r--r-- | Cargo.lock | 2 | ||||
| -rw-r--r-- | Cargo.toml | 2 | ||||
| -rw-r--r-- | README.md | 4 | ||||
| -rw-r--r-- | src/lib.rs | 66 | ||||
| -rw-r--r-- | tests/tests.rs | 108 |
6 files changed, 177 insertions, 8 deletions
@@ -1,5 +1,8 @@ # Change Log +## 2.1.0 +* added since expressions: "since yesterday", "since the beginning of the month", "since the end of last year", "after midnight", ... +* added "the" as a synonym of "this" as a period modifier: "the beginning of the month" = "the beginning of this month" ## 2.0.0 *2020-3-7* * fixing specific time to specific time pattern: "noon yesterday through midnight today" * allow parsing of hours with leading 0; e.g., "08:57:29" @@ -171,7 +171,7 @@ dependencies = [ [[package]] name = "two_timer" -version = "2.0.0" +version = "2.1.0" dependencies = [ "chrono 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1,6 +1,6 @@ [package] name = "two_timer" -version = "2.0.0" +version = "2.1.0" authors = ["dfhoughton <dfhoughton@gmail.com>"] description="parser for English time expressions" homepage="https://github.com/dfhoughton/two-timer" @@ -38,5 +38,7 @@ Some expressions it can handle: * ten seconds from now * 5 minutes before and after midnight * 1969-05-06 12:03:05 +* since the start of the year +* since yesterday -The complete API is available at https://docs.rs/two_timer/0.1.0/two_timer/. +The complete API is available at https://docs.rs/two_timer/. @@ -102,7 +102,7 @@ are 2. a relative expression will be interpreted as appropriate given its order -- the second expression describes a time after the first 3. if neither expression is fully-specified, the first will be interpreted relative to "now" and the -second relative ot the first +second relative to the first The rules of interpretation for relative time expressions in ranges will likely be refined further in the future. @@ -248,7 +248,13 @@ lazy_static! { one_time => <moment_or_period> - two_times -> ("from")? <moment_or_period> <to> <moment_or_period> + two_times -> ("from")? <moment_or_period> <to> <moment_or_period> | <since_time> + + since_time -> <since> <clusivity>? <moment_or_period> + + clusivity -> ("the") <terminus> ("of") + + terminus => <beginning> | <end> to => <up_to> | <through> @@ -340,17 +346,20 @@ lazy_static! { adverb => [["now", "today", "tomorrow", "yesterday"]] am_pm => (?-ib) [["am", "AM", "pm", "PM", "a.m.", "A.M.", "p.m.", "P.M."]] bce => (?-ib) [["bce", "b.c.e.", "bc", "b.c.", "BCE", "B.C.E.", "BC", "B.C."]] + beginning => [["beginning", "start"]] ce => (?-ib) [["ce", "c.e.", "ad", "a.d.", "CE", "C.E.", "AD", "A.D."]] direction -> [["before", "after", "around", "before and after"]] displacement => [["week", "day", "hour", "minute", "second"]] ("s")? // not handling variable-width periods like months or years + end => ("end") from_now_or_ago => [["from now", "ago"]] h12 => (?-B) [(1..=12).into_iter().collect::<Vec<_>>()] h24 => [(1..=24).into_iter().flat_map(|i| vec![format!("{}", i), format!("{:02}", i)]).collect::<Vec<_>>()] minute => (?-B) [ (0..60).into_iter().map(|i| format!("{:02}", i)).collect::<Vec<_>>() ] - modifier => [["this", "last", "next"]] + modifier => [["the", "this", "last", "next"]] named_time => [["noon", "midnight"]] n_year => r(r"\b(?:[1-9][0-9]{0,4}|0)\b") roman => [["nones", "ides", "kalends"]] + since => [["since", "after"]] unit => [["week", "day", "hour", "minute", "second"]] ("s")? universal => [["always", "ever", "all time", "forever", "from beginning to end", "from the beginning to the end"]] up_to => [["to", "until", "up to", "till"]] @@ -548,7 +557,7 @@ lazy_static! { // various phrases all meaning from the first measurable moment to the last adverb => [["now", "today", "yesterday"]] - modifier => [["this", "last"]] + modifier => [["the", "this", "last"]] a_day => [ "Sunday Monday Tuesday Wednesday Thursday Friday Saturday Tues Weds Thurs Tues. Weds. Thurs." @@ -647,6 +656,55 @@ pub fn parse( }; } if let Some(two_times) = parse.name("two_times") { + let mut inclusive = two_times.has("beginning"); + let exclusive = !inclusive && two_times.has("end"); // note this is *explicitly* exclusive + if !(inclusive || exclusive) && (two_times.has("time") || two_times.has("precise_time")) { + // treating "since noon" as including 12:00:00 and "since 2am" as including 14:00:00 + inclusive = true; + } + if let Some(previous_time) = two_times.name("since_time") { + if specific(previous_time) { + return match specific_moment(previous_time, &config) { + Ok((d1, d2)) => { + let t = if inclusive { d1 } else { d2 }; + // if *implicitly* exclusive and we find things misordered, we become inclusive + let t = if !(inclusive || exclusive) && t > config.now { + d1 + } else { + t + }; + if t > config.now { + Err(TimeError::Misordered(format!( + "the inferred times, {} and {}, are misordered", + t, config.now + ))) + } else { + Ok((t, config.now.clone(), false)) + } + } + Err(s) => Err(s), + }; + } + return match relative_moment(previous_time, &config, &config.now, true) { + Ok((d1, d2)) => { + let t = if inclusive { d1 } else { d2 }; + let t = if !(inclusive || exclusive) && t > config.now { + d1 + } else { + t + }; + if t > config.now { + Err(TimeError::Misordered(format!( + "the inferred times, {} and {}, are misordered", + t, config.now + ))) + } else { + Ok((t, config.now.clone(), false)) + } + } + Err(s) => Err(s), + }; + } let first = &two_times.children().unwrap()[0]; let last = &two_times.children().unwrap()[2]; let is_through = two_times.has("through"); diff --git a/tests/tests.rs b/tests/tests.rs index ae1126e..c2eb23a 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -1,6 +1,6 @@ #![feature(test)] extern crate two_timer; -use two_timer::{parsable, parse, Config}; +use two_timer::{parsable, parse, Config, TimeError}; extern crate chrono; use chrono::naive::NaiveDate; use chrono::{Duration, Local}; @@ -422,6 +422,16 @@ fn this_week() { } #[test] +fn the_week() { + let now = NaiveDate::from_ymd(1969, 5, 6).and_hms(0, 0, 0); + let d1 = NaiveDate::from_ymd(1969, 5, 5).and_hms(0, 0, 0); + let d2 = NaiveDate::from_ymd(1969, 5, 12).and_hms(0, 0, 0); + let (start, end, _) = parse("the week", Some(Config::new().now(now))).unwrap(); + assert_eq!(d1, start); + assert_eq!(d2, end); +} + +#[test] fn next_week() { let now = NaiveDate::from_ymd(1969, 5, 6).and_hms(0, 0, 0); let d1 = NaiveDate::from_ymd(1969, 5, 12).and_hms(0, 0, 0); @@ -1428,6 +1438,17 @@ fn noon() { assert!(false, "didn't match"); } } + let now = NaiveDate::from_ymd(1969, 5, 6).and_hms(0, 0, 0); + match parse("noon on May 6, 1969", Some(Config::new().now(now))) { + Ok((start, end, _)) => { + assert_eq!(d1, start, "'noon' is the same as 'noon today'"); + assert_eq!(d2, end); + } + Err(e) => { + println!("{:?}", e); + assert!(false, "didn't match"); + } + } } #[test] @@ -1596,3 +1617,88 @@ fn relative_time_regression() { parse("24", None).unwrap(); assert!(true, "'24' didn't cause a panic"); } + +#[test] +fn since_yesterday() { + let then = NaiveDate::from_ymd(1969, 5, 10).and_hms(0, 0, 0); + let now = then + Duration::hours(5); + match parse("since yesterday", Some(Config::new().now(now))) { + Ok((start, end, two_times)) => { + assert!(!two_times, "isn't a two-time expression"); + assert!(then == start); + assert!(now == end); + } + Err(e) => { + println!("{:?}", e); + assert!(false, "didn't match"); + } + } +} + +#[test] +fn since_noon() { + let then = NaiveDate::from_ymd(1969, 5, 10).and_hms(12, 0, 0); + let now = then + Duration::hours(5); + for expr in &[ + "since noon", + "since noon today", + "since 12", + "since 12am", + "since 12am today", + "since 12:00", + "since 12:00:00", + ] { + match parse(expr, Some(Config::new().now(now))) { + Ok((start, end, two_times)) => { + assert!(!two_times, "isn't a two-time expression"); + assert!(then == start); + assert!(now == end); + } + Err(e) => { + println!("{:?}", e); + assert!(false, "didn't match"); + } + } + } +} + +#[test] +fn since_may() { + let then = NaiveDate::from_ymd(1969, 5, 1).and_hms(0, 0, 0); + let now = then + Duration::hours(5); + for expr in &[ + "since may", + "since the start of may", + "since the beginning of may", + "after may", + "after the start of may", + "after the beginning of may", + ] { + match parse(expr, Some(Config::new().now(now))) { + Ok((start, end, two_times)) => { + assert!(!two_times, "isn't a two-time expression"); + assert!(then == start); + assert!(now == end); + } + Err(e) => { + println!("{:?}", e); + assert!(false, "didn't match"); + } + } + } +} + +#[test] +fn since_the_end_of_may_misordered() { + let then = NaiveDate::from_ymd(1969, 5, 1).and_hms(0, 0, 0); + let now = then + Duration::hours(5); + for expr in &["since the end of may", "after the end of may"] { + match parse(expr, Some(Config::new().now(now))) { + Ok((..)) => assert!(false, "this should not succeed"), + Err(e) => match e { + TimeError::Misordered(_) => assert!(true, "correct error"), + _ => assert!(false, format!("unexpected error: {:?}", e)), + }, + } + } +} |