removed unnecessary main.rs; added time of day handling

2 files changed, 93 insertions, 96 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 437e438..8565b40 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,11 +6,11 @@ extern crate lazy_static;
 extern crate chrono;
 use chrono::offset::LocalResult;
 use chrono::{DateTime, Datelike, Duration, TimeZone, Timelike, Utc, Weekday};
-use pidgin::{Match, Matcher};
+use pidgin::{Grammar, Match, Matcher};
 use regex::Regex;
 
 lazy_static! {
-    static ref GRAMMAR: Matcher = grammar!{
+    static ref GRAMMAR: Grammar = grammar!{
         (?ibBw)
 
         TOP -> r(r"\A") <something> r(r"\z")
@@ -21,7 +21,7 @@ lazy_static! {
         one_moment => <at_moment>
         two_moments -> <at_moment> <to> <at_moment>
         to => [["to", "through", "until", "up to", "thru", "till"]] | r("-+")
-        at_moment -> <at_time>? <moment> <at_time>? | <time>
+        at_moment -> <at_time_on>? <moment> <at_time>? | <time>
         moment => <specific> | <relative>
         specific => <adverb> | <date_with_year>
         relative => ("bar")
@@ -32,6 +32,7 @@ lazy_static! {
         yesterday => ("yesterday")
         date_with_year => <n_date> | <a_date>
         at_time -> ("at") <time>
+        at_time_on -> ("at")? <time> ("on")
         time -> <hour_12> <am_pm>? | <hour_24>
         hour_24 => <h24>
         hour_24 => <h24> (":") <minute>
@@ -39,8 +40,8 @@ lazy_static! {
         hour_12 => <h12>
         hour_12 => <h12> (":") <minute>
         hour_12 => <h12> (":") <minute> (":") <second>
-        minute => [ (0..60).into_iter().map(|i| format!("'{:02}", i)).collect::<Vec<_>>() ]
-        second => [ (0..60).into_iter().map(|i| format!("'{:02}", i)).collect::<Vec<_>>() ]
+        minute => [ (0..60).into_iter().map(|i| format!("{:02}", i)).collect::<Vec<_>>() ]
+        second => [ (0..60).into_iter().map(|i| format!("{:02}", i)).collect::<Vec<_>>() ]
         am_pm => (?-i) [["am", "AM", "pm", "PM", "a.m.", "A.M.", "p.m.", "P.M."]]
         h12 => [(1..=12).into_iter().collect::<Vec<_>>()]
         h24 => [(1..=24).into_iter().collect::<Vec<_>>()]
@@ -103,7 +104,10 @@ lazy_static! {
                      .flat_map(|w| vec![w.to_string(), w[0..3].to_string()])
                      .collect::<Vec<_>>()
             ]
-    }.matcher().unwrap();
+    };
+}
+lazy_static! {
+    static ref MATCHER: Matcher = GRAMMAR.matcher().unwrap();
 }
 
 pub fn parse(
@@ -111,9 +115,7 @@ pub fn parse(
     now: Option<&DateTime<Utc>>,
     period: Option<Period>,
 ) -> Result<(DateTime<Utc>, DateTime<Utc>), String> {
-    let parse = GRAMMAR.parse(phrase);
-    // println!("{:?}", GRAMMAR.rx);
-    // println!("what I got: {:?}", parse);
+    let parse = MATCHER.parse(phrase);
     if parse.is_none() {
         return Err(format!(
             "could not parse \"{}\" as a time expression",
@@ -139,16 +141,16 @@ pub fn parse(
         Period::Minute
     };
     if let Some(moment) = parse.name("one_moment") {
-        if let Some(specific) = moment.name("specific") {
-            return specific_moment(specific, &now, &period);
+        if moment.has("specific") {
+            return specific_moment(moment, &now, &period);
         }
-        if let Some(relative) = moment.name("relative") {
-            return Ok(relative_moment(relative, &now, &now, true));
+        if moment.has("relative") {
+            return Ok(relative_moment(moment, &now, &now, true));
         }
         unreachable!();
     }
     if let Some(two_moments) = parse.name("two_moments") {
-        let moments = two_moments.all_names("moment");
+        let moments = two_moments.all_names("at_moment");
         let first = moments[0];
         let last = moments[1];
         if first.has("specific") {
@@ -192,24 +194,57 @@ pub fn parse(
     unreachable!();
 }
 
+// add time to a date
+fn moment_and_time(
+    m: DateTime<Utc>,
+    default_period: &Period,
+    daytime: Option<&Match>,
+) -> (DateTime<Utc>, DateTime<Utc>) {
+    if let Some(daytime) = daytime {
+        let (hour, minute, second) = time(daytime);
+        let period = if second.is_some() {
+            Period::Second
+        } else if minute.is_some() {
+            Period::Minute
+        } else {
+            Period::Hour
+        };
+        let m = m
+            .with_hour(hour)
+            .unwrap()
+            .with_minute(minute.unwrap_or(0))
+            .unwrap()
+            .with_second(second.unwrap_or(0))
+            .unwrap();
+        moment_to_period(m, &period)
+    } else {
+        moment_to_period(m, default_period)
+    }
+}
+
 fn specific_moment(
     m: &Match,
     now: &DateTime<Utc>,
     period: &Period,
 ) -> Result<(DateTime<Utc>, DateTime<Utc>), String> {
     let now = now.clone();
+    let mut times = m.all_names("time");
+    if times.len() > 1 {
+        return Err(format!("more than one daytime specified in {}", m.as_str()));
+    }
+    let time = times.pop();
     if let Some(adverb) = m.name("adverb") {
         if adverb.has("now") {
-            return Ok(moment_to_period(now, &period));
+            return Ok(moment_and_time(now, period, time));
         }
         if adverb.has("today") {
-            return Ok(moment_to_period(now, &Period::Day));
+            return Ok(moment_and_time(now, &Period::Day, time));
         }
         if adverb.has("tomorrow") {
-            return Ok(moment_to_period(now + Duration::days(1), &Period::Day));
+            return Ok(moment_and_time(now + Duration::days(1), &Period::Day, time));
         }
         if adverb.has("yesterday") {
-            return Ok(moment_to_period(now - Duration::days(1), &Period::Day));
+            return Ok(moment_and_time(now - Duration::days(1), &Period::Day, time));
         }
         unreachable!();
     }
@@ -226,7 +261,7 @@ fn specific_moment(
                 )),
                 LocalResult::Single(d1) => {
                     let d1 = d1.and_hms(0, 0, 0);
-                    Ok((d1, d1 + Duration::days(1)))
+                    Ok(moment_and_time(d1, &Period::Day, time))
                 }
                 LocalResult::Ambiguous(_, _) => Err(format!(
                     "cannot construct unambiguous UTC date with year {}, month {}, and day {}",
@@ -249,7 +284,7 @@ fn specific_moment(
                         let wd = weekday(wd.as_str());
                         if wd == d1.weekday() {
                             let d1 = d1.and_hms(0, 0, 0);
-                            Ok((d1, d1 + Duration::days(1)))
+                            Ok(moment_and_time(d1, &Period::Day, time))
                         } else {
                             Err(format!(
                                 "the weekday of year {}, month {}, day {} is not {}",
@@ -261,7 +296,7 @@ fn specific_moment(
                         }
                     } else {
                         let d1 = d1.and_hms(0, 0, 0);
-                        Ok((d1, d1 + Duration::days(1)))
+                        Ok(moment_and_time(d1, &Period::Day, time))
                     }
                 }
                 LocalResult::Ambiguous(_, _) => Err(format!(
@@ -296,6 +331,36 @@ fn a_month(m: &Match) -> u32 {
     }
 }
 
+// extract hour, minute, and second from time match
+fn time(m: &Match) -> (u32, Option<u32>, Option<u32>) {
+    let hour = if let Some(hour_24) = m.name("hour_24") {
+        s_to_n(hour_24.name("h24").unwrap().as_str())
+    } else if let Some(hour_12) = m.name("hour_12") {
+        let hour = s_to_n(hour_12.name("h12").unwrap().as_str());
+        if let Some(am_pm) = m.name("am_pm") {
+            match am_pm.as_str().chars().nth(0).expect("empty string") {
+                'a' | 'A' => hour,
+                _ => hour + 12,
+            }
+        } else {
+            hour
+        }
+    } else {
+        unreachable!()
+    };
+    if let Some(minute) = m.name("minute") {
+        let minute = s_to_n(minute.as_str());
+        if let Some(second) = m.name("second") {
+            let second = s_to_n(second.as_str());
+            (hour, Some(minute), Some(second))
+        } else {
+            (hour, Some(minute), None)
+        }
+    } else {
+        (hour, None, None)
+    }
+}
+
 fn n_month(m: &Match) -> u32 {
     lazy_static! {
         static ref MONTH: Regex = Regex::new(r"\A0?(\d{1,2})\z").unwrap();
@@ -324,6 +389,13 @@ fn year(m: &Match, now: &DateTime<Utc>) -> i32 {
     }
 }
 
+fn s_to_n(s: &str) -> u32 {
+    lazy_static! {
+        static ref S_TO_N: Regex = Regex::new(r"\A[\D0]*(\d+)\z").unwrap();
+    }
+    S_TO_N.captures(s).unwrap()[1].parse::<u32>().unwrap()
+}
+
 fn n_day(m: &Match) -> u32 {
     m.name("n_day").unwrap().as_str().parse::<u32>().unwrap()
 }
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 0d9bc79..0000000
--- a/src/main.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-#![recursion_limit="512"]
-#[macro_use]
-extern crate pidgin;
-
-fn main() {
-    let g = grammar!{
-        (?ibBw)
-
-        TOP => <universal> | <existential>
-        existential => <specific> | <relative>
-        specific => ("foo")
-        relative => ("bar")
-        universal => [["always", "ever", "all time"]]
-        existential => <date> | <two_times>
-        two_times => <two_dates> | <on_date>
-        two_dates -> <date> <date_separator> <date>
-        on_date -> [["on"]]? <date> [["from"]] <time> [["to"]] <time>
-        date_separator => [["-", "through", "to", "until", "till", "til", "thru"]]
-        date => <specific> | <relative>
-        month => <a_month> | <n_month>
-        time -> <hour_12> <am_pm> | <hour_24>
-        hour_24 => <h24>
-        hour_24 => <h24> (":") <minute>
-        hour_24 => <h24> (":") <minute> (":") <second>
-        hour_12 => <h12>
-        hour_12 => <h12> (":") <minute>
-        hour_12 => <h12> (":") <minute> (":") <second>
-        minute => [ (0..60).into_iter().map(|i| format!("'{:02}", i)).collect::<Vec<_>>() ]
-        second => [ (0..60).into_iter().map(|i| format!("'{:02}", i)).collect::<Vec<_>>() ]
-        am_pm => (?-i) [["am", "AM", "pm", "PM", "a.m.", "A.M.", "p.m.", "P.M."]]
-        h12 => [(1..=12).into_iter().collect::<Vec<_>>()]
-        h24 => [(1..=24).into_iter().collect::<Vec<_>>()]
-        day => <a_day> | <n_date>
-        a_day => [
-                "Sunday Monday Tuesday Wednesday Thursday Friday Saturday"
-                    .split(" ")
-                    .into_iter()
-                    .flat_map(|w| vec![w.to_string(), w[0..2].to_string(), w[0..3].to_string()])
-                    .collect::<Vec<_>>()
-            ]
-        a_day => (?-i) [["M", "T", "W", "R", "F", "S", "U"]]
-        n_date -> <year> ("/") <n_month> ("/") <n_day>
-        n_date -> <year> ("-") <n_month> ("-") <n_day>
-        n_date -> <year> (".") <n_month> (".") <n_day>
-        n_date -> <year> ("/") <n_day>   ("/") <n_month>
-        n_date -> <year> ("-") <n_day>   ("-") <n_month>
-        n_date -> <year> (".") <n_day>   (".") <n_month>
-        year => [
-                (1..=3000)
-                    .into_iter()
-                    .collect::<Vec<_>>()
-            ]
-        year => [
-                (0..=99)
-                    .into_iter()
-                    .flat_map(|i| vec![format!("'{:02}", i), format!("{:02}", i)])
-                    .collect::<Vec<_>>()
-            ]
-        n_day => [
-                (1..=31)
-                    .into_iter()
-                    .flat_map(|i| vec![i.to_string(), format!("{:02}", i)])
-                    .collect::<Vec<_>>()
-            ]
-        n_month => [(1..12).into_iter().collect::<Vec<_>>()]
-        a_month => [
-                "January February March April May June July August September October November December"
-                     .split(" ")
-                     .into_iter()
-                     .flat_map(|w| vec![w.to_string(), w[0..3].to_string()])
-                     .collect::<Vec<_>>()
-            ]
-    };
-    println!("Hello, world!");
-}