feat(filter/regexTitle): add IncludeRegexp property

Author: timonegk

README.md

@@ -197,10 +197,13 @@ filters:
     config:
       HourStart: 8
       HourEnd: 17
-  # Events where the title matches the ExcludeRegexp (RE2 Regex) aren't synced
+  # Include / Exclude events based on the title (RE2 Regex)
+  # Events are included by default, ExcludeRegexp defines excluded events, IncludeRegexp defines exception from exclusion
+  # If only inclusion should be defined, use ".*" for ExcludeRegexp
   - name: RegexTitle
     config:
       ExcludeRegexp: ".*test"
+      IncludeRegexp: ".*test-but-included"
 ```
 
 ## Auth

example.sync.yaml

@@ -69,10 +69,13 @@ filters:
     config:
       HourStart: 8
       HourEnd: 17
-  # Events where the title matches the ExcludeRegexp (RE2 Regex) aren't synced
+  # Include / Exclude events based on the title (RE2 Regex)
+  # Events are included by default, ExcludeRegexp defines excluded events, IncludeRegexp defines exception from exclusion
+  # If only inclusion should be defined, use ".*" for ExcludeRegexp
   - name: RegexTitle
     config:
       ExcludeRegexp: ".*test"
+      IncludeRegexp: ".*test-but-included"
 
 # Perform multiple calendar updates concurrently
 # Defaults to 1 if not set

internal/filter/regexTitle.go

@@ -10,31 +10,56 @@ import (
 
 type RegexTitle struct {
 	ExcludeRegexp string
+	IncludeRegexp string
 }
 
 func (a RegexTitle) Name() string {
 	return "RegexTitle"
 }
 
 func (a RegexTitle) Filter(event models.Event) bool {
+	// Filter() return true if the event should be kept
 
-	if len(a.ExcludeRegexp) == 0 {
-		log.Debugf("Regular Expression is empty, skipping Filter %s for event: %s", a.Name(), event.Title)
+	// special case nothing excluded or included: keep all
+	if len(a.ExcludeRegexp) == 0 && len(a.IncludeRegexp) == 0 {
 		return true
 	}
 
+	// matchExclude defaults to false (exclude no events)
+	matchExclude := false
+	if len(a.ExcludeRegexp) > 0 {
+		matchExclude = a.MatchRegex(event, a.ExcludeRegexp)
+	}
+	// matchInclude defaults to false (don't include)
+	matchInclude := false
+	if len(a.IncludeRegexp) > 0 {
+		matchInclude = a.MatchRegex(event, a.IncludeRegexp)
+	}
+
+	// use allow - deny - allow pattern
+	// (default is allow, then excluded are denied, but included are allowed again)
+	if matchInclude && matchExclude {
+		return true
+	} else if matchExclude {
+		return false
+	} else {
+		return true
+	}
+}
+
+func (a RegexTitle) MatchRegex(event models.Event, re string) bool {
 	log.Debugf("Running Regexp %s on event title: %s", a.ExcludeRegexp, event.Title)
 
-	r, err := regexp.Compile(a.ExcludeRegexp)
+	r, err := regexp.Compile(re)
 	if err != nil {
 		log.Fatalf("Regular expression of Filter %s is not valid, please check", a.Name())
 	}
 
 	// if the title matches the Regexp, return false (filter the event)
 	if r.MatchString(event.Title) {
-		log.Debugf("Regular Expression %s matches the events title: %s, gets filtered", a.Name(), event.Title)
-		return false
+		log.Debugf("Regular Expression %s matches the events title: %s", a.Name(), event.Title)
+		return true
 	}
 
-	return true
+	return false
 }

internal/filter/regexTitle_test.go

@@ -23,13 +23,13 @@ var sourceEvents = []models.Event{
 	{
 		ICalUID:     "testId3",
 		ID:          "testUid2",
-		Title:       "foo",
+		Title:       "taste",
 		Description: "bar",
 	},
 }
 
 // Some events should be filtered
-func TestRegexTitleFilter(t *testing.T) {
+func TestRegexTitleFilterExclude(t *testing.T) {
 
 	expectedSinkEvents := []models.Event{sourceEvents[1], sourceEvents[2]}
 
@@ -48,3 +48,23 @@ func TestRegexTitleFilterEmptyRegex(t *testing.T) {
 	}
 	checkEventFilter(t, eventFilter, sourceEvents, expectedSinkEvents)
 }
+
+// Only the included events should be there
+func TestRegexTitleFilterInclude(t *testing.T) {
+	expectedSinkEvents := []models.Event{sourceEvents[0], sourceEvents[1]}
+	eventFilter := filter.RegexTitle{
+		ExcludeRegexp: ".*",
+		IncludeRegexp: "[tT]est.*",
+	}
+	checkEventFilter(t, eventFilter, sourceEvents, expectedSinkEvents)
+}
+
+// the excluded events should be excluded but the included should be included again
+func TestRegexTitleFilterExcludeInclude(t *testing.T) {
+	expectedSinkEvents := []models.Event{sourceEvents[0]}
+	eventFilter := filter.RegexTitle{
+		ExcludeRegexp: "t.*",
+		IncludeRegexp: "test.*",
+	}
+	checkEventFilter(t, eventFilter, sourceEvents, expectedSinkEvents)
+}