fix(next,gronx): day of week / day of month can be intersection or union

Author: codenem

checker.go

@@ -34,10 +34,10 @@ func (c *SegmentChecker) SetRef(ref time.Time) {
 func (c *SegmentChecker) CheckDue(segment string, pos int) (due bool, err error) {
 	ref, last := c.GetRef(), -1
 	val, loc := valueByPos(ref, pos), ref.Location()
-	isMonth, isWeekDay := pos == 3, pos == 5
+	isMonthDay, isWeekDay := pos == 3, pos == 5
 
 	for _, offset := range strings.Split(segment, ",") {
-		mod := (isMonth || isWeekDay) && strings.ContainsAny(offset, "LW#")
+		mod := (isMonthDay || isWeekDay) && strings.ContainsAny(offset, "LW#")
 		if due, err = c.isOffsetDue(offset, val, pos); due || (!mod && err != nil) {
 			return
 		}
@@ -47,7 +47,7 @@ func (c *SegmentChecker) CheckDue(segment string, pos int) (due bool, err error)
 		if last == -1 {
 			last = time.Date(ref.Year(), ref.Month(), 1, 0, 0, 0, 0, loc).AddDate(0, 1, 0).Add(-time.Second).Day()
 		}
-		if isMonth {
+		if isMonthDay {
 			due, err = isValidMonthDay(offset, last, ref)
 		} else if isWeekDay {
 			due, err = isValidWeekDay(offset, last, ref)

gronx.go

@@ -96,11 +96,44 @@ func Segments(expr string) ([]string, error) {
 // SegmentsDue checks if all cron parts are due.
 // It returns bool. You should use IsDue(expr) instead.
 func (g *Gronx) SegmentsDue(segs []string) (bool, error) {
-	for pos, seg := range segs {
+	skipMonthDayCheck := false
+	for i := 0; i < len(segs); i++ {
+		pos := len(segs) - 1 - i
+		seg := segs[pos]
+		isMonthDay, isWeekday := pos == 3, pos == 5
+
 		if seg == "*" || seg == "?" {
 			continue
 		}
 
+		if isMonthDay && skipMonthDayCheck {
+			continue
+		}
+
+		if isWeekday {
+			segIsIntersecting := strings.Index(seg, "*/") == 0
+			monthDaySeg := segs[3]
+			monthDaySegIsIntersecting := strings.Index(monthDaySeg, "*") == 0 || monthDaySeg == "?"
+			intersectCase := segIsIntersecting || monthDaySegIsIntersecting
+
+			if !intersectCase {
+				due, err := g.C.CheckDue(seg, pos)
+				if err != nil {
+					return false, err
+				}
+
+				monthDayDue, err := g.C.CheckDue(monthDaySeg, 3)
+				if due || monthDayDue {
+					skipMonthDayCheck = true
+					continue
+				}
+
+				if err != nil {
+					return false, err
+				}
+			}
+		}
+
 		if due, err := g.C.CheckDue(seg, pos); !due {
 			return due, err
 		}

gronx_test.go

@@ -188,7 +188,7 @@ func testcases() []Case {
 		{"0 0 * * 0,2-6", "2011-06-20 23:09:00", false, "2011-06-21 00:00:00"},
 		{"0 0 1 1 0", "2011-06-15 23:09:00", false, "2012-01-01 00:00:00"},
 		{"0 0 1 JAN 0", "2011-06-15 23:09:00", false, "2012-01-01 00:00:00"},
-		{"0 0 1 * 0", "2011-06-15 23:09:00", false, "2012-01-01 00:00:00"},
+		{"0 0 1 * 0", "2011-06-15 23:09:00", false, "2011-06-19 00:00:00"},
 		{"0 0 L * *", "2011-07-15 00:00:00", false, "2011-07-31 00:00:00"},
 		{"0 0 2W * *", "2011-07-01 00:00:00", true, "2011-08-02 00:00:00"},
 		{"0 0 1W * *", "2011-05-01 00:00:00", false, "2011-05-02 00:00:00"},
@@ -214,12 +214,12 @@ func testcases() []Case {
 		{"5/20 * * * *", "2018-08-13 00:24:00", false, "2018-08-13 00:25:00"},
 		{"5/20 * * * *", "2018-08-13 00:45:00", true, "2018-08-13 01:05:00"},
 		{"5-11/4 * * * *", "2018-08-13 00:03:00", false, "2018-08-13 00:05:00"},
-		{"0 0 L * 0", "2011-06-15 23:09:00", false, "2011-07-31 00:00:00"},
-		{"3-59/15 6-12 */15 1 2-5", "2017-01-08 00:00:00", false, "2018-01-30 06:03:00"},
+		{"0 0 L * 0", "2011-06-15 23:09:00", false, "2011-06-19 00:00:00"},
+		{"3-59/15 6-12 */15 1 2-5", "2017-01-08 00:00:00", false, "2017-01-31 06:03:00"},
 		{"* * * * MON-FRI", "2017-01-08 00:00:00", false, "2017-01-09 00:00:00"},
 		{"* * * * TUE", "2017-01-08 00:00:00", false, "2017-01-10 00:00:00"},
-		{"0 1 15 JUL mon,Wed,FRi", "2019-11-14 00:00:00", false, "2020-07-15 01:00:00"},
-		{"0 1 15 jul mon,Wed,FRi", "2019-11-14 00:00:00", false, "2020-07-15 01:00:00"},
+		{"0 1 15 JUL mon,Wed,FRi", "2019-11-14 00:00:00", false, "2020-07-01 01:00:00"},
+		{"0 1 15 jul mon,Wed,FRi", "2019-11-14 00:00:00", false, "2020-07-01 01:00:00"},
 		{"@weekly", "2019-11-14 00:00:00", false, "2019-11-17 00:00:00"},
 		{"@weekly", "2019-11-14 00:00:00", false, "2019-11-17 00:00:00"},
 		{"@weekly", "2019-11-14 00:00:00", false, "2019-11-17 00:00:00"},
@@ -229,6 +229,8 @@ func testcases() []Case {
 		{"* * ? * * * */2", "2021-08-20 00:00:00", false, "2022-01-01 00:00:00"},
 		{"* * * * * * *", "2021-08-20 00:00:00", true, "2021-08-20 00:00:01"},
 		{"* * * * * * 2023-2099", "2021-08-20 00:00:00", false, "2023-01-01 00:00:00"},
+		{"30 9 L */3 *", "2023-04-23 09:30:00", false, "2023-04-30 09:30:00"},
+		{"30 9 L */3 *", "2023-05-01 09:30:00", false, "2023-07-31 09:30:00"},
 	}
 }
 

next.go

@@ -46,16 +46,71 @@ func loop(gron Gronx, segments []string, start time.Time, incl bool, reverse boo
 over:
 	for iter > 0 {
 		iter--
+		skipMonthDayForIter := false
 		for i := 0; i < len(segments); i++ {
 			pos := len(segments) - 1 - i
-			seg := segments[len(segments)-1-i]
+			seg := segments[pos]
+			isMonthDay, isWeekday := pos == 3, pos == 5
+
 			if seg == "*" || seg == "?" {
 				continue
 			}
-			if next, bumped, err = bumpUntilDue(gron.C, seg, pos, next, reverse); bumped {
+
+			if !isWeekday {
+				if isMonthDay && skipMonthDayForIter {
+					continue
+				}
+				if next, bumped, err = bumpUntilDue(gron.C, seg, pos, next, reverse); bumped {
+					goto over
+				}
+				continue
+			}
+			// From here we process the weekday segment in case it is neither * nor ?
+
+			segIsIntersecting := strings.Index(seg, "*/") == 0
+			monthDaySeg := segments[3]
+			monthDaySegIsIntersecting := strings.Index(monthDaySeg, "*") == 0 || monthDaySeg == "?"
+
+			intersectCase := segIsIntersecting || monthDaySegIsIntersecting
+
+			nextForWeekDay := next
+			nextForWeekDay, bumped, err = bumpUntilDue(gron.C, seg, pos, nextForWeekDay, reverse)
+			if !bumped {
+				// Weekday seg is specific and next is already at right weekday, so no need to process month day if union case
+				next = nextForWeekDay
+				if !intersectCase {
+					skipMonthDayForIter = true
+				}
+				continue
+			}
+			// Weekday was bumped, so we need to check for month day
+
+			if intersectCase {
+				// We need intersection so we keep bumped weekday and go over
+				next = nextForWeekDay
 				goto over
 			}
+			// Month day seg is specific and a number/list/range, so we need to check and keep the closest to next
+
+			nextForMonthDay := next
+			nextForMonthDay, bumped, err = bumpUntilDue(gron.C, monthDaySeg, 3, nextForMonthDay, reverse)
+
+			monthDayIsClosestToNextThanWeekDay := reverse && nextForMonthDay.After(nextForWeekDay) ||
+				!reverse && nextForMonthDay.Before(nextForWeekDay)
+
+			if monthDayIsClosestToNextThanWeekDay {
+				next = nextForMonthDay
+				if !bumped {
+					// Month day seg is specific and next is already at right month day, we can continue
+					skipMonthDayForIter = true
+					continue
+				}
+			} else {
+				next = nextForWeekDay
+			}
+			goto over
 		}
+
 		if !incl && next.Format(FullDateFormat) == start.Format(FullDateFormat) {
 			delta := time.Second
 			if reverse {