Only generate recurrence fields/properties for recurring main events (#89)

* Remove `EventValidator.removeRecurrenceOfExceptions`

* Only generate recurrence fields/properties for recurring main events

* Add RecurringFieldsProcessorTest; fix wrong AND instead of OR

* Make all EXDATES valid

Author: rfc2822

lib/src/main/kotlin/at/bitfire/ical4android/validation/EventValidator.kt

@@ -48,7 +48,6 @@ object EventValidator {
         val dtStart = correctStartAndEndTime(event)
         sameTypeForDtStartAndRruleUntil(dtStart, event.rRules)
         removeRRulesWithUntilBeforeDtStart(dtStart, event.rRules)
-        removeRecurrenceOfExceptions(event.exceptions)
     }
 
 
@@ -168,25 +167,6 @@ object EventValidator {
         }
     }
 
-
-    /**
-     * Removes all recurrence information of exceptions of (potentially recurring) events. This is:
-     * `RRULE`, `RDATE` and `EXDATE`.
-     * Note: This repair step needs to be applied after all exceptions have been found.
-     *
-     * @param exceptions exceptions of an event
-     */
-    @VisibleForTesting
-    internal fun removeRecurrenceOfExceptions(exceptions: List<Event>) {
-        for (exception in exceptions) {
-            // Drop all RRULEs, RDATEs, EXDATEs for the exception
-            exception.rRules.clear()
-            exception.rDates.clear()
-            exception.exDates.clear()
-        }
-    }
-
-
     /**
      * Will remove the RRULES of an event where UNTIL lies before DTSTART
      */

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/builder/RecurrenceFieldsBuilder.kt

@@ -24,7 +24,7 @@ class RecurrenceFieldsBuilder: AndroidEntityBuilder {
 
         val recurring = from.rRules.isNotEmpty() || from.rDates.isNotEmpty()
         if (recurring && from === main) {
-            // only for recurring main events
+            // generate recurrence fields only for recurring main events
             val dtStart = from.dtStart
 
             // RRULE

lib/src/main/kotlin/at/bitfire/synctools/mapping/calendar/processor/RecurrenceFieldsProcessor.kt

@@ -28,28 +28,34 @@ class RecurrenceFieldsProcessor: AndroidEventFieldProcessor {
 
     override fun process(from: Entity, main: Entity, to: Event) {
         val values = from.entityValues
+        val rRuleField = values.getAsString(Events.RRULE)
+        val rDateField = values.getAsString(Events.RDATE)
+
+        // generate recurrence properties only for recurring main events
+        val recurring = rRuleField != null || rDateField != null
+        if (from !== main || !recurring)
+            return
+
         val allDay = (values.getAsInteger(Events.ALL_DAY) ?: 0) != 0
         val tsStart = values.getAsLong(Events.DTSTART) ?: throw InvalidLocalResourceException("Found event without DTSTART")
 
         // RRULE
-        values.getAsString(Events.RRULE)?.let { rulesStr ->
+        if (rRuleField != null)
             try {
-                for (rule in rulesStr.split(AndroidTimeUtils.RECURRENCE_RULE_SEPARATOR))
+                for (rule in rRuleField.split(AndroidTimeUtils.RECURRENCE_RULE_SEPARATOR))
                     to.rRules += RRule(rule)
             } catch (e: Exception) {
                 logger.log(Level.WARNING, "Couldn't parse RRULE field, ignoring", e)
             }
-        }
 
         // RDATE
-        values.getAsString(Events.RDATE)?.let { datesStr ->
+        if (rDateField != null)
             try {
-                val rDate = AndroidTimeUtils.androidStringToRecurrenceSet(datesStr, tzRegistry, allDay, tsStart) { RDate(it) }
+                val rDate = AndroidTimeUtils.androidStringToRecurrenceSet(rDateField, tzRegistry, allDay, tsStart) { RDate(it) }
                 to.rDates += rDate
             } catch (e: Exception) {
                 logger.log(Level.WARNING, "Couldn't parse RDATE field, ignoring", e)
             }
-        }
 
         // EXRULE
         values.getAsString(Events.EXRULE)?.let { rulesStr ->

lib/src/test/kotlin/at/bitfire/ical4android/validation/EventValidatorTest.kt

@@ -9,23 +9,13 @@ package at.bitfire.ical4android.validation
 import at.bitfire.ical4android.Event
 import at.bitfire.ical4android.EventReader
 import net.fortuna.ical4j.model.Date
-import net.fortuna.ical4j.model.DateList
 import net.fortuna.ical4j.model.DateTime
-import net.fortuna.ical4j.model.Property
-import net.fortuna.ical4j.model.PropertyList
 import net.fortuna.ical4j.model.Recur
-import net.fortuna.ical4j.model.TimeZone
 import net.fortuna.ical4j.model.TimeZoneRegistry
 import net.fortuna.ical4j.model.TimeZoneRegistryFactory
-import net.fortuna.ical4j.model.component.VTimeZone
-import net.fortuna.ical4j.model.parameter.Value
 import net.fortuna.ical4j.model.property.DtEnd
 import net.fortuna.ical4j.model.property.DtStart
-import net.fortuna.ical4j.model.property.ExDate
-import net.fortuna.ical4j.model.property.RDate
 import net.fortuna.ical4j.model.property.RRule
-import net.fortuna.ical4j.model.property.RecurrenceId
-import net.fortuna.ical4j.model.property.TzId
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -374,116 +364,6 @@ class EventValidatorTest {
         )
     }
 
-    @Test
-    fun testRemoveRecurrencesOfRecurringWithExceptions() {
-        // Test manually created event
-        val tzRegistry = TimeZoneRegistryFactory.getInstance().createRegistry()
-        val tz = tzRegistry.getTimeZone("Europe/Paris")
-        val manualEvent = Event().apply {
-            dtStart = DtStart("20240219T130000", tz)
-            dtEnd = DtEnd("20240219T140000", tz)
-            summary = "recurring event"
-            rRules.add(RRule(Recur.Builder()                        // Should keep this RRULE
-                .frequency(Recur.Frequency.DAILY)
-                .interval(1)
-                .count(5)
-                .build()))
-            sequence = 0
-            uid = "76c08fb1-99a3-41cf-b482-2d3b06648814"
-            exceptions.add(Event().apply {
-                dtStart = DtStart("20240221T110000", tz)
-                dtEnd = DtEnd("20240221T120000", tz)
-                recurrenceId = RecurrenceId("20240221T130000", tz)
-                sequence = 0
-                summary = "exception of recurring event"
-                rRules.addAll(listOf(
-                    RRule(Recur.Builder()                           // but remove this one
-                        .frequency(Recur.Frequency.DAILY)
-                        .count(6)
-                        .interval(2)
-                        .build()),
-                    RRule(Recur.Builder()                           // and this one
-                        .frequency(Recur.Frequency.DAILY)
-                        .count(6)
-                        .interval(2)
-                        .build())
-                ))
-                rDates.addAll(listOf(
-                    RDate(DateList(Value("19970714T123000Z"))),
-                    RDate(
-                        DateList(
-                            Value("19960403T020000Z"),
-                            TimeZone(
-                                VTimeZone(
-                                    PropertyList<Property>(1).apply {
-                                        add(TzId("US-EASTERN"))
-                                    }
-                                )
-                            )
-                        )
-                    )
-                ))
-                exDates.addAll(listOf(
-                    ExDate(DateList(Value("19970714T123000Z"))),
-                    ExDate(
-                        DateList(
-                            Value("19960403T020000Z"),
-                            TimeZone(
-                                VTimeZone(
-                                    PropertyList<Property>(1).apply {
-                                        add(TzId("US-EASTERN"))
-                                    }
-                                )
-                            )
-                        )
-                    )
-                ))
-                uid = "76c08fb1-99a3-41cf-b482-2d3b06648814"
-            })
-        }
-        assertTrue(manualEvent.rRules.size == 1)
-        assertTrue(manualEvent.exceptions.first().rRules.size == 2)
-        assertTrue(manualEvent.exceptions.first().rDates.size == 2)
-        assertTrue(manualEvent.exceptions.first().exDates.size == 2)
-        EventValidator.removeRecurrenceOfExceptions(manualEvent.exceptions) // Repair the manually created event
-        assertTrue(manualEvent.rRules.size == 1)
-        assertTrue(manualEvent.exceptions.first().rRules.isEmpty())
-        assertTrue(manualEvent.exceptions.first().rDates.isEmpty())
-        assertTrue(manualEvent.exceptions.first().exDates.isEmpty())
-
-        // Test event from reader, the reader will repair the event itself
-        val eventFromReader = eventReader.readEvents(StringReader(
-            "BEGIN:VCALENDAR\n" +
-                "BEGIN:VEVENT\n" +
-                "DTSTAMP:20240215T102755Z\n" +
-                "SUMMARY:recurring event\n" +
-                "DTSTART;TZID=Europe/Paris:20240219T130000\n" +
-                "DTEND;TZID=Europe/Paris:20240219T140000\n" +
-                "RRULE:FREQ=DAILY;INTERVAL=1;COUNT=5\n" +           // Should keep this RRULE
-                "UID:76c08fb1-99a3-41cf-b482-2d3b06648814\n" +
-                "END:VEVENT\n" +
-
-                // Exception for the recurring event above
-                "BEGIN:VEVENT\n" +
-                "DTSTAMP:20240215T102908Z\n" +
-                "RECURRENCE-ID;TZID=Europe/Paris:20240221T130000\n" +
-                "SUMMARY:exception of recurring event\n" +
-                "RRULE:FREQ=DAILY;COUNT=6;INTERVAL=2\n" +           // but remove this one
-                "RRULE:FREQ=DAILY;COUNT=6;INTERVAL=2\n" +           // and this one
-                "EXDATE;TZID=Europe/Paris:20240704T193000\n" +      // also this
-                "RDATE;TZID=US-EASTERN:19970714T083000\n" +         // and this
-                "DTSTART;TZID=Europe/Paris:20240221T110000\n" +
-                "DTEND;TZID=Europe/Paris:20240221T120000\n" +
-                "UID:76c08fb1-99a3-41cf-b482-2d3b06648814\n" +
-                "END:VEVENT\n" +
-                "END:VCALENDAR"
-        )).first()
-        assertTrue(eventFromReader.rRules.size == 1)
-        assertTrue(eventFromReader.exceptions.first().rRules.isEmpty())
-        assertTrue(eventFromReader.exceptions.first().rDates.isEmpty())
-        assertTrue(eventFromReader.exceptions.first().exDates.isEmpty())
-    }
-
     @Test
     fun testRemoveRRulesWithUntilBeforeDtStart() {
         val dtStart = DtStart(DateTime("20220531T125304"))

lib/src/test/kotlin/at/bitfire/synctools/mapping/calendar/builder/RecurrenceFieldsBuilderTest.kt

@@ -32,6 +32,7 @@ class RecurrenceFieldsBuilderTest {
 
     @Test
     fun `Exception event`() {
+        // Exceptions (of recurring events) must never have recurrence properties themselves.
         val result = Entity(ContentValues())
         builder.build(
             from = Event(dtStart = DtStart()).apply {
@@ -50,6 +51,25 @@ class RecurrenceFieldsBuilderTest {
         ), result.entityValues)
     }
 
+    @Test
+    fun `EXDATE for non-recurring event`() {
+        val main = Event(dtStart = DtStart()).apply {
+            exDates += ExDate()
+        }
+        val result = Entity(ContentValues())
+        builder.build(
+            from = main,
+            main = main,
+            to = result
+        )
+        assertContentValuesEqual(contentValuesOf(
+            Events.RRULE to null,
+            Events.RDATE to null,
+            Events.EXRULE to null,
+            Events.EXDATE to null
+        ), result.entityValues)
+    }
+
     @Test
     fun `Single RRULE`() {
         val result = Entity(ContentValues())

lib/src/test/kotlin/at/bitfire/synctools/mapping/calendar/processor/RecurringFieldsProcessorTest.kt

@@ -0,0 +1,79 @@
+/*
+ * This file is part of bitfireAT/synctools which is released under GPLv3.
+ * Copyright © All Contributors. See the LICENSE and AUTHOR files in the root directory for details.
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+package at.bitfire.synctools.mapping.calendar.processor
+
+import android.content.ContentValues
+import android.content.Entity
+import android.provider.CalendarContract.Events
+import androidx.core.content.contentValuesOf
+import at.bitfire.ical4android.Event
+import junit.framework.TestCase.assertEquals
+import net.fortuna.ical4j.model.ParameterList
+import net.fortuna.ical4j.model.property.RDate
+import net.fortuna.ical4j.model.property.RRule
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class RecurringFieldsProcessorTest {
+
+    private val processor = RecurrenceFieldsProcessor()
+
+    @Test
+    fun `Recurring exception`() {
+        val result = Event()
+        val entity = Entity(contentValuesOf(
+            Events.DTSTART to System.currentTimeMillis(),
+            Events.RRULE to "FREQ=DAILY;COUNT=10",
+            Events.RDATE to "20251010T010203Z",
+            Events.EXRULE to "FREQ=WEEKLY;COUNT=1",
+            Events.EXDATE to "20260201T010203Z"
+        ))
+        processor.process(entity, Entity(ContentValues()), result)
+        // exceptions must never have recurrence properties
+        assertTrue(result.rRules.isEmpty())
+        assertTrue(result.rDates.isEmpty())
+        assertTrue(result.exRules.isEmpty())
+        assertTrue(result.exDates.isEmpty())
+    }
+
+    @Test
+    fun `Non-recurring main event`() {
+        val result = Event()
+        val entity = Entity(contentValuesOf(
+            Events.DTSTART to System.currentTimeMillis(),
+            Events.EXRULE to "FREQ=WEEKLY;COUNT=1",
+            Events.EXDATE to "20260201T010203Z"
+        ))
+        processor.process(entity, entity, result)
+        // non-recurring events must never have recurrence properties
+        assertTrue(result.rRules.isEmpty())
+        assertTrue(result.rDates.isEmpty())
+        assertTrue(result.exRules.isEmpty())
+        assertTrue(result.exDates.isEmpty())
+    }
+
+    @Test
+    fun `Recurring main event`() {
+        val result = Event()
+        val entity = Entity(contentValuesOf(
+            Events.DTSTART to System.currentTimeMillis(),
+            Events.RRULE to "FREQ=DAILY;COUNT=10",
+            Events.RDATE to "20251010T010203Z",
+            Events.EXRULE to "FREQ=WEEKLY;COUNT=1",
+            Events.EXDATE to "20260201T010203Z"
+        ))
+        processor.process(entity, entity, result)
+        assertEquals(listOf(RRule("FREQ=DAILY;COUNT=10")), result.rRules)
+        assertEquals(listOf(RDate(ParameterList(), "20251010T010203Z")), result.rDates)
+        assertEquals("FREQ=WEEKLY;COUNT=1", result.exRules.joinToString { it.value })
+        assertEquals("20260201T010203Z", result.exDates.joinToString { it.value })
+    }
+
+}