add default Until time to rule, #24

go.mod

@@ -1 +1,3 @@
 module github.com/teambition/rrule-go
+
+go 1.12

rrule.go

@@ -111,6 +111,7 @@ type ROption struct {
 // documented in the iCalendar RFC, including support for caching of results.
 type RRule struct {
 	OrigOptions             ROption
+	Options                 ROption
 	freq                    Frequency
 	dtstart                 time.Time
 	interval                int
@@ -148,6 +149,10 @@ func NewRRule(arg ROption) (*RRule, error) {
 		r.interval = arg.Interval
 	}
 	r.count = arg.Count
+	if arg.Until.IsZero() {
+		// add largest representable duration (approximately 290 years).
+		arg.Until = arg.Dtstart.Add(time.Duration(1<<63 - 1))
+	}
 	r.until = arg.Until
 	r.wkst = arg.Wkst.weekday
 	for _, pos := range arg.Bysetpos {
@@ -213,6 +218,7 @@ func NewRRule(arg ROption) (*RRule, error) {
 		r.bysecond = arg.Bysecond
 	}
 
+	r.Options = arg
 	// Calculate the timeset if needed
 	r.calculateTimeset()
 
@@ -790,6 +796,11 @@ func (r *RRule) DTStart(dt time.Time) {
 	r.calculateTimeset()
 }
 
+// Until set a new Until for the rule and recalculates the timeset if needed.
+func (r *RRule) Until(ut time.Time) {
+	r.until = ut
+}
+
 // calculateTimeset calculates the timeset if needed.
 func (r *RRule) calculateTimeset() {
 	// Reset the timeset value

rrule_test.go

@@ -3594,6 +3594,22 @@ func TestDTStartWithMicroseconds(t *testing.T) {
 	}
 }
 
+func TestUntil(t *testing.T) {
+	r1, _ := NewRRule(ROption{Freq: DAILY,
+		Dtstart: time.Date(1997, 9, 2, 0, 0, 0, 0, time.UTC)})
+	r1.Until(time.Date(1998, 9, 2, 0, 0, 0, 0, time.UTC))
+
+	r2, _ := NewRRule(ROption{Freq: DAILY,
+		Dtstart: time.Date(1997, 9, 2, 0, 0, 0, 0, time.UTC),
+		Until:   time.Date(1998, 9, 2, 0, 0, 0, 0, time.UTC)})
+
+	v1 := r1.All()
+	v2 := r2.All()
+	if !timesEqual(v1, v2) {
+		t.Errorf("get %v, want %v", v1, v2)
+	}
+}
+
 func TestMaxYear(t *testing.T) {
 	r, _ := NewRRule(ROption{Freq: YEARLY,
 		Count:      3,
@@ -3680,6 +3696,21 @@ func TestBetweenInc(t *testing.T) {
 	}
 }
 
+func TestAllWithDefaultUtil(t *testing.T) {
+	r, _ := NewRRule(ROption{Freq: YEARLY,
+		Dtstart: time.Date(1997, 9, 2, 9, 0, 0, 0, time.UTC)})
+
+	value := r.All()
+	if len(value) > 300 || len(value) < 200 {
+		t.Errorf("No default Util time")
+	}
+
+	r, _ = NewRRule(ROption{Freq: YEARLY})
+	if len(r.All()) != len(value) {
+		t.Errorf("No default Util time")
+	}
+}
+
 func TestWeekdayGetters(t *testing.T) {
 	wd := Weekday{n: 2, weekday: 0}
 	if wd.N() != 2 {

rruleset.go

@@ -41,7 +41,11 @@ func (set *Set) Recurrence() []string {
 func (set *Set) DTStart(dtstart time.Time) {
 	set.dtstart = dtstart
 
-	for _, r := range append(set.rrule, set.exrule...) {
+	for _, r := range set.rrule {
+		r.DTStart(set.dtstart)
+	}
+
+	for _, r := range set.exrule {
 		r.DTStart(set.dtstart)
 	}
 }
@@ -53,6 +57,9 @@ func (set *Set) GetDTStart() time.Time {
 
 // RRule include the given rrule instance in the recurrence set generation.
 func (set *Set) RRule(rrule *RRule) {
+	if !set.dtstart.IsZero() {
+		rrule.DTStart(set.dtstart)
+	}
 	set.rrule = append(set.rrule, rrule)
 }
 
@@ -75,6 +82,9 @@ func (set *Set) GetRDate() []time.Time {
 // Dates which are part of the given recurrence rules will not be generated,
 // even if some inclusive rrule or rdate matches them.
 func (set *Set) ExRule(exrule *RRule) {
+	if !set.dtstart.IsZero() {
+		exrule.DTStart(set.dtstart)
+	}
 	set.exrule = append(set.exrule, exrule)
 }
 

rruleset_test.go

@@ -22,6 +22,22 @@ func TestSet(t *testing.T) {
 	}
 }
 
+func TestSetOverlapping(t *testing.T) {
+	set := Set{}
+	r, _ := NewRRule(ROption{Freq: YEARLY,
+		Dtstart: time.Date(1997, 9, 2, 9, 0, 0, 0, time.UTC)})
+	set.RRule(r)
+	v1 := set.All()
+	if len(v1) > 300 || len(v1) < 200 {
+		t.Errorf("No default Util time")
+	}
+	set.ExRule(r)
+	v2 := set.All()
+	if len(v2) != 0 {
+		t.Errorf("Should no values when RRule and ExRule overlapping")
+	}
+}
+
 func TestSetString(t *testing.T) {
 	set := Set{}
 	r, _ := NewRRule(ROption{Freq: YEARLY, Count: 1, Byweekday: []Weekday{TU},