implementing InvalidBehavior (SKIP) in RFC 7529

Also enforcing stricter ranges on numeric inputs.

Author: stephens2424

expansions.go

@@ -77,6 +77,7 @@ func expandByWeekdays(tt []time.Time, weekStart time.Weekday, weekdays ...Qualif
 
 	return e
 }
+
 func expandByMonthDays(tt []time.Time, monthdays ...int) []time.Time {
 	if len(monthdays) == 0 {
 		return tt
@@ -92,42 +93,89 @@ func expandByMonthDays(tt []time.Time, monthdays ...int) []time.Time {
 	return e
 }
 
-func expandByYearDays(tt []time.Time, yeardays ...int) []time.Time {
+func expandByYearDays(tt []time.Time, ib InvalidBehavior, yeardays ...int) []time.Time {
 	if len(yeardays) == 0 {
 		return tt
 	}
 
 	e := make([]time.Time, 0, len(tt)*len(yeardays))
 	for _, t := range tt {
 		yearStart := time.Date(t.Year(), time.January, 1, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+		startYear := yearStart.Year()
 
 		for _, yd := range yeardays {
-			e = append(e, yearStart.AddDate(0, 0, yd))
+			added := yearStart.AddDate(0, 0, yd-1) // subtract one because we start on the 1st, so if we want yearday 1, we actually want to advance 0.
+			if added.Year() != startYear {
+				switch ib {
+				case OmitInvalid:
+					// do nothing
+				case NextInvalid:
+					e = append(e, added)
+				case PrevInvalid:
+					e = append(e, added.AddDate(0, 0, -1))
+				}
+			} else {
+				e = append(e, added)
+			}
 		}
 	}
 
 	return e
 }
 
-func expandByWeekNumbers(tt []time.Time, weekStarts time.Weekday, weekNumbers ...int) []time.Time {
+func expandByWeekNumbers(tt []time.Time, ib InvalidBehavior, weekStarts time.Weekday, byWeekdays []time.Weekday, weekNumbers ...int) []time.Time {
 	if len(weekNumbers) == 0 {
 		return tt
 	}
 
 	e := make([]time.Time, 0, len(tt)*len(weekNumbers))
 	for _, t := range tt {
-		yearStart := time.Date(t.Year(), time.January, 1, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
-		yearStart = forwardToWeekday(yearStart, t.Weekday())
+		ys := yearStart(t, weekStarts)
+
+		byWeekdays := byWeekdays
+		if len(byWeekdays) == 0 {
+			// NOTE: the spec is not 100% clear on what to do in this case.
+			// rrule.js, for instance, will default to returning the full
+			// week. lib-recur seems to copy the weekday from the input
+			// time. I'm going with the latter, since it seems more consistent
+			// with the behavior you'd get on a BYMONTH clause.
+			byWeekdays = []time.Weekday{t.Weekday()}
+		}
 
 		for _, w := range weekNumbers {
-			e = append(e, yearStart.AddDate(0, 0, (w-1)*7))
+			ws := ys.AddDate(0, 0, (w-1)*7)
+
+			if weekYearStart := yearStart(ws, weekStarts); weekYearStart.Year() != ys.Year() {
+				// check that the week we generated is still within the proper
+				// year, or if it ran over because the year did not have enough
+				// weeks
+
+				nextYearStart := yearStart(ys.AddDate(1, 0, 0), weekStarts)
+				switch ib {
+				case OmitInvalid:
+					// do nothing
+				case NextInvalid:
+					for _, wd := range byWeekdays {
+						e = append(e, forwardToWeekday(nextYearStart, wd))
+					}
+				case PrevInvalid:
+					for _, wd := range byWeekdays {
+						e = append(e, backToWeekday(nextYearStart, wd))
+					}
+				}
+				continue
+			}
+
+			for _, wd := range byWeekdays {
+				e = append(e, forwardToWeekday(ws, wd))
+			}
 		}
 	}
 
 	return e
 }
 
-func expandByMonths(tt []time.Time, ib invalidBehavior, months ...time.Month) []time.Time {
+func expandByMonths(tt []time.Time, ib InvalidBehavior, months ...time.Month) []time.Time {
 	if len(months) == 0 {
 		return tt
 	}
@@ -138,13 +186,13 @@ func expandByMonths(tt []time.Time, ib invalidBehavior, months ...time.Month) []
 			set := time.Date(t.Year(), m, t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 			if set.Month() != m {
 				switch ib {
-				case prevInvalid:
+				case PrevInvalid:
 					set = time.Date(t.Year(), t.Month()+1, -1, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 					e = append(e, set)
-				case nextInvalid:
+				case NextInvalid:
 					set = time.Date(t.Year(), t.Month()+1, 1, t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 					e = append(e, set)
-				case omitInvalid:
+				case OmitInvalid:
 					// do nothing
 				}
 			} else {
@@ -160,7 +208,7 @@ func expandByMonths(tt []time.Time, ib invalidBehavior, months ...time.Month) []
 // bySetPos is not nil, it is assumed tt is the full set of instances within the
 // monthly iteration, and only the instances matching the posisions of bySetPos
 // are returned. This is an optimization.
-func expandMonthByWeekdays(tt []time.Time, ib invalidBehavior, bySetPos []int, weekdays ...QualifiedWeekday) []time.Time {
+func expandMonthByWeekdays(tt []time.Time, ib InvalidBehavior, bySetPos []int, weekdays ...QualifiedWeekday) []time.Time {
 	if len(weekdays) == 0 {
 		return tt
 	}
@@ -173,7 +221,7 @@ func expandMonthByWeekdays(tt []time.Time, ib invalidBehavior, bySetPos []int, w
 	return e
 }
 
-func expandYearByWeekdays(tt []time.Time, ib invalidBehavior, weekdays ...QualifiedWeekday) []time.Time {
+func expandYearByWeekdays(tt []time.Time, ib InvalidBehavior, weekdays ...QualifiedWeekday) []time.Time {
 	if len(weekdays) == 0 {
 		return tt
 	}

go.mod

@@ -1 +1,9 @@
 module github.com/stephens2424/rrule
+
+go 1.12
+
+require (
+	github.com/stretchr/testify v1.3.0
+	github.com/teambition/rrule-go v1.2.3
+	golang.org/x/tools v0.0.0-20190228203856-589c23e65e65 // indirect
+)

invalidBehavior.go

@@ -1,9 +1,19 @@
 package rrule
 
-type invalidBehavior int
+// InvalidBehavior specifies how to behave when a pattern generates a date that
+// wouldn't exist, like February 31st.
+type InvalidBehavior int
 
 const (
-	omitInvalid invalidBehavior = iota
-	nextInvalid
-	prevInvalid
+	// OmitInvalid skips invalid dates. This is the only choice for RFC
+	// 5545 and RFC 2445.
+	OmitInvalid InvalidBehavior = iota
+
+	// NextInvalid chooses the next valid date. So if February 31st were generated,
+	// March 1st would be used.
+	NextInvalid
+
+	// PrevInvalid chooses the previously valid date. So if February 31st were generated,
+	// the result would be February 28th (or 29th on a leap year).
+	PrevInvalid
 )

parse.go

@@ -149,19 +149,19 @@ func ParseRRule(str string) (RRule, error) {
 			}
 			rrule.Interval = i
 		case "BYSECOND":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, 0, 60, true)
 			if err != nil {
 				return rrule, err
 			}
 			rrule.BySeconds = ints
 		case "BYMINUTE":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, 0, 59, true)
 			if err != nil {
 				return rrule, err
 			}
 			rrule.ByMinutes = ints
 		case "BYHOUR":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, 0, 23, true)
 			if err != nil {
 				return rrule, err
 			}
@@ -173,19 +173,19 @@ func ParseRRule(str string) (RRule, error) {
 			}
 			rrule.ByWeekdays = wds
 		case "BYMONTHDAY":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, -31, 31, false)
 			if err != nil {
 				return rrule, err
 			}
 			rrule.ByMonthDays = ints
 		case "BYYEARDAY":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, -366, 366, true)
 			if err != nil {
 				return rrule, err
 			}
 			rrule.ByYearDays = ints
 		case "BYWEEKNO":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, -53, 53, false)
 			if err != nil {
 				return rrule, err
 			}
@@ -197,7 +197,7 @@ func ParseRRule(str string) (RRule, error) {
 			}
 			rrule.ByMonths = months
 		case "BYSETPOS":
-			ints, err := parseInts(value)
+			ints, err := parseInts(value, -366, 366, false)
 			if err != nil {
 				return rrule, err
 			}
@@ -208,6 +208,18 @@ func ParseRRule(str string) (RRule, error) {
 				return rrule, err
 			}
 			rrule.WeekStart = &wd
+		case "SKIP":
+			skip, err := parseSkip(value)
+			if err != nil {
+				return rrule, err
+			}
+			rrule.InvalidBehavior = skip
+		case "RSCALE":
+			err := parseRScale(value)
+			if err != nil {
+				return rrule, err
+			}
+
 		default:
 			return rrule, fmt.Errorf("%q is not a supported RRULE part", directive)
 		}
@@ -217,18 +229,34 @@ func ParseRRule(str string) (RRule, error) {
 	return rrule, err
 }
 
-func parseInts(str string) ([]int, error) {
+func parseInts(str string, min, max int, allowZero bool) ([]int, error) {
 	if len(str) == 0 {
 		return nil, nil
 	}
 	var err error
 	parts := strings.Split(str, ",")
 	ints := make([]int, len(parts))
 	for i, p := range parts {
-		ints[i], err = strconv.Atoi(p)
+		var currentInt int
+
+		currentInt, err = strconv.Atoi(p)
 		if err != nil {
 			return nil, err
 		}
+
+		if currentInt == 0 && !allowZero {
+			return nil, fmt.Errorf("zero is not valid")
+		}
+
+		if currentInt < min {
+			return nil, fmt.Errorf("%d is below minimum %d", currentInt, min)
+		}
+
+		if currentInt > max {
+			return nil, fmt.Errorf("%d is above maximum %d", currentInt, max)
+		}
+
+		ints[i] = currentInt
 	}
 
 	return ints, nil
@@ -331,3 +359,25 @@ func strToFreq(str string) (Frequency, error) {
 		return Yearly, fmt.Errorf("frequency %q is not valid", str)
 	}
 }
+
+func parseSkip(str string) (InvalidBehavior, error) {
+	switch strings.ToLower(str) {
+	case "omit":
+		return OmitInvalid, nil
+	case "backward":
+		return PrevInvalid, nil
+	case "forward":
+		return NextInvalid, nil
+	}
+
+	return OmitInvalid, fmt.Errorf("skip value %v is not valid", str)
+}
+
+func parseRScale(str string) error {
+	switch strings.ToLower(str) {
+	case "gregorian", "gregory":
+		return nil
+	default:
+		return fmt.Errorf("invalid rscale %q: only gregorian is supported", str)
+	}
+}