refactor ical importer for rrule repetition

Author: firu11

pkg/core/ical.go

@@ -2,15 +2,18 @@ package core
 
 import (
 	"crypto/sha256"
-	"errors"
 	"fmt"
 	"io"
 	"time"
 
 	ics "github.com/arran4/golang-ical"
 	"github.com/google/uuid"
+	rrule "github.com/teambition/rrule-go"
 )
 
+// parseICal parses ical events from r to []Event.
+// calendar is copied to each event and used to scope deterministic IDs.
+// When stableIDs is false, each event gets a random ID.
 func parseICal(r io.Reader, calendar string, stableIDs bool) ([]Event, error) {
 	cal, err := ics.ParseCalendar(r)
 	if err != nil {
@@ -25,7 +28,7 @@ func parseICal(r io.Reader, calendar string, stableIDs bool) ([]Event, error) {
 			return nil, fmt.Errorf("import event %d: %w", i+1, err)
 		}
 		if stableIDs {
-			event.Id = icalEventID(calendar, icalText(source, ics.ComponentPropertyUniqueId), i, event)
+			event.Id = icalEventID(calendar, source.Id(), i, event)
 		}
 		if err := event.Validate(); err != nil {
 			return nil, fmt.Errorf("import event %d: %w", i+1, err)
@@ -47,7 +50,7 @@ func parseICalEvent(source *ics.VEvent, calendar string) (Event, error) {
 		return Event{}, fmt.Errorf("read DTEND: %w", err)
 	}
 
-	repeat, err := parseICalRepetition(source)
+	repeat, err := parseICalRRule(source, from)
 	if err != nil {
 		return Event{}, err
 	}
@@ -63,63 +66,18 @@ func parseICalEvent(source *ics.VEvent, calendar string) (Event, error) {
 	}, nil
 }
 
-func parseICalRepetition(event *ics.VEvent) (*Repetition, error) {
-	if event.HasProperty(ics.ComponentPropertyRdate) ||
-		event.HasProperty(ics.ComponentPropertyExdate) ||
-		event.HasProperty(ics.ComponentPropertyExrule) ||
-		event.HasProperty(ics.ComponentPropertyRecurrenceId) {
-		return nil, errors.New("recurrence dates and exceptions are not supported")
-	}
-
-	rules, err := event.GetRRules()
-	if err != nil {
-		return nil, err
-	}
-	if len(rules) == 0 {
+func parseICalRRule(event *ics.VEvent, start time.Time) (*rrule.Set, error) {
+	value := icalText(event, ics.ComponentPropertyRrule)
+	if value == "" {
 		return nil, nil
 	}
-	if len(rules) != 1 {
-		return nil, errors.New("multiple recurrence rules are not supported")
-	}
-
-	rule := rules[0]
-	if hasICalModifiers(rule) {
-		return nil, errors.New("recurrence modifiers are not supported")
-	}
 
-	frequency, err := parseICalFrequency(rule.Freq)
+	option, err := rrule.StrToROptionInLocation(value, start.Location())
 	if err != nil {
-		return nil, err
-	}
-
-	return &Repetition{
-		Frequency: frequency,
-		Interval:  rule.Interval,
-		Until:     rule.Until,
-		Count:     rule.Count,
-	}, nil
-}
-
-func parseICalFrequency(frequency ics.Frequency) (Freq, error) {
-	switch frequency {
-	case ics.FrequencyDaily:
-		return Day, nil
-	case ics.FrequencyWeekly:
-		return Week, nil
-	case ics.FrequencyMonthly:
-		return Month, nil
-	case ics.FrequencyYearly:
-		return Year, nil
-	default:
-		return Invalid, fmt.Errorf("unsupported recurrence frequency %q", frequency)
+		return nil, fmt.Errorf("parse RRULE: %w", err)
 	}
-}
-
-func hasICalModifiers(rule *ics.RecurrenceRule) bool {
-	return len(rule.BySecond)+len(rule.ByMinute)+len(rule.ByHour)+
-		len(rule.ByDay)+len(rule.ByMonthDay)+len(rule.ByYearDay)+
-		len(rule.ByWeekNo)+len(rule.ByMonth)+len(rule.BySetPos) > 0 ||
-		rule.Wkst != ""
+	option.Dtstart = start
+	return newRecurrence(*option, nil)
 }
 
 func icalText(event *ics.VEvent, property ics.ComponentProperty) string {
@@ -132,13 +90,8 @@ func icalText(event *ics.VEvent, property ics.ComponentProperty) string {
 
 func icalEventID(calendar, uid string, index int, event Event) uuid.UUID {
 	if uid == "" {
+		// fallback it uid is missing
 		uid = fmt.Sprintf("%d\x00%s\x00%s", index, event.Title, event.From.Format(time.RFC3339Nano))
 	}
-	sum := sha256.Sum256([]byte(calendar + "\x00" + uid))
-
-	var id uuid.UUID
-	copy(id[:], sum[:16])
-	id[6] = id[6]&0x0f | 0x80
-	id[8] = id[8]&0x3f | 0x80
-	return id
+	return uuid.NewHash(sha256.New(), uuid.Nil, []byte(calendar+"\x00"+uid), 8)
 }

pkg/core/ical_test.go

@@ -4,6 +4,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+
+	rrule "github.com/teambition/rrule-go"
 )
 
 func TestParseICal(t *testing.T) {
@@ -58,18 +60,23 @@ END:VCALENDAR`
 	if second.Repeat == nil {
 		t.Fatal("Repeat is nil")
 	}
-	if second.Repeat.Frequency != Week {
-		t.Errorf("Frequency = %v, want %v", second.Repeat.Frequency, Week)
+	rule := second.Repeat.GetRRule()
+	if rule == nil {
+		t.Fatal("RRULE is nil")
+	}
+	option := rule.OrigOptions
+	if option.Freq != rrule.WEEKLY {
+		t.Errorf("Frequency = %v, want %v", option.Freq, rrule.WEEKLY)
 	}
-	if second.Repeat.Interval != 2 {
-		t.Errorf("Interval = %d, want 2", second.Repeat.Interval)
+	if option.Interval != 2 {
+		t.Errorf("Interval = %d, want 2", option.Interval)
 	}
-	if second.Repeat.Count != 4 {
-		t.Errorf("Count = %d, want 4", second.Repeat.Count)
+	if option.Count != 4 {
+		t.Errorf("Count = %d, want 4", option.Count)
 	}
 }
 
-func TestParseICalRejectsUnsupportedRecurrence(t *testing.T) {
+func TestParseICalSupportsRecurrenceModifiers(t *testing.T) {
 	input := `BEGIN:VCALENDAR
 VERSION:2.0
 PRODID:-//git-calendar//test//EN
@@ -82,9 +89,14 @@ RRULE:FREQ=WEEKLY;COUNT=4;BYDAY=MO,WE
 END:VEVENT
 END:VCALENDAR`
 
-	_, err := parseICal(strings.NewReader(input), "Work", false)
-	if err == nil || !strings.Contains(err.Error(), "recurrence modifiers are not supported") {
-		t.Fatalf("error = %v, want unsupported recurrence modifier error", err)
+	events, err := parseICal(strings.NewReader(input), "Work", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	weekdays := events[0].Repeat.GetRRule().OrigOptions.Byweekday
+	if len(weekdays) != 2 || weekdays[0].String() != "MO" || weekdays[1].String() != "WE" {
+		t.Fatalf("Byweekday = %v, want [MO WE]", weekdays)
 	}
 }