From 46d9d67a47cae2006231d0434d51daeb0cd08666 Mon Sep 17 00:00:00 2001
From: Brandon W Maister <bwm@materialize.io>
Date: Mon, 23 Dec 2019 12:01:34 -0500
Subject: [PATCH] Change >=/<= behavior to panic on year overflow

I'm not sure what the semantics are of that in tic, but none exist now and
hopefully no tz rules are set up by governments such that it's possible for
them to ovrflow years.
---
 src/line.rs | 40 ++++++++++++++++++++++++----------------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/line.rs b/src/line.rs
index 73474d5..9a2cd3d 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -188,9 +188,9 @@ impl Month {
         }
     }
 
-    /// Get the next calendar month, wrapping such than `December.next() == January`
-    fn next(self) -> Month {
-        match self {
+    /// Get the next calendar month, with an error going from Dec->Jan
+    fn next_in_year(self) -> Result<Month, &'static str> {
+        Ok(match self {
             Month::January => Month::February,
             Month::February => Month::March,
             Month::March => Month::April,
@@ -202,14 +202,14 @@ impl Month {
             Month::September => Month::October,
             Month::October => Month::November,
             Month::November => Month::December,
-            Month::December => Month::January,
-        }
+            Month::December => Err("Cannot wrap year from dec->jan")?,
+        })
     }
 
-    /// Get the previous calendar month, wrapping such that `January.prev() == December`
-    fn prev(self) -> Month {
-        match self {
-            Month::January => Month::December,
+    /// Get the previous calendar month, with an error going from Jan->Dec
+    fn prev_in_year(self) -> Result<Month, &'static str> {
+        Ok(match self {
+            Month::January => Err("Cannot wrap years from jan->dec")?,
             Month::February => Month::January,
             Month::March => Month::February,
             Month::April => Month::March,
@@ -221,7 +221,7 @@ impl Month {
             Month::October => Month::September,
             Month::November => Month::October,
             Month::December => Month::November,
-        }
+        })
     }
 }
 
@@ -374,7 +374,8 @@ impl DaySpec {
     pub fn to_concrete_day(&self, year: i64, month: Month) -> (Month, i8) {
         let leap = is_leap(year);
         let length = month.length(leap);
-        let prev_length = month.prev().length(leap);
+        // we will never hit the 0 because we unwrap prev_in_year below
+        let prev_length = month.prev_in_year().map(|m| m.length(leap)).unwrap_or(0);
 
         match *self {
             DaySpec::Ordinal(day) => (month, day),
@@ -391,11 +392,14 @@ impl DaySpec {
                     if inner_day >= 1 && Weekday::calculate(year, month, inner_day) == weekday {
                         Some((month, inner_day))
                     } else if inner_day < 1
-                        && Weekday::calculate(year, month.prev(), prev_length + inner_day)
-                            == weekday
+                        && Weekday::calculate(
+                            year,
+                            month.prev_in_year().unwrap(),
+                            prev_length + inner_day,
+                        ) == weekday
                     {
                         // inner_day is negative, so this is subtraction
-                        Some((month.prev(), prev_length + inner_day))
+                        Some((month.prev_in_year().unwrap(), prev_length + inner_day))
                     } else {
                         None
                     }
@@ -408,9 +412,13 @@ impl DaySpec {
                     {
                         Some((month, inner_day))
                     } else if inner_day > length
-                        && Weekday::calculate(year, month.next(), inner_day - length) == weekday
+                        && Weekday::calculate(
+                            year,
+                            month.next_in_year().unwrap(),
+                            inner_day - length,
+                        ) == weekday
                     {
-                        Some((month.next(), inner_day - length))
+                        Some((month.next_in_year().unwrap(), inner_day - length))
                     } else {
                         None
                     }