Add RecurrenceSet::isFinite method to deprecate isInfinite, closes #134 (#135)

dmfs · web-flow · commit 8ee6f28a7bef · 2024-04-06T14:00:23.000+02:00
diff --git a/build.gradle b/build.gradle
@@ -78,7 +78,7 @@ dependencies {
     api libs.jems2
     testImplementation project("lib-recur-hamcrest")
     testImplementation project("lib-recur-confidence")
-    testImplementation 'org.dmfs:jems2-testing:2.22.0'
+    testImplementation libs.jems2.testing
     testImplementation libs.jems2.confidence
     testImplementation 'org.saynotobugs:confidence-core:0.42.0'
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -1,7 +1,7 @@
 [versions]
 eclipse-jdt = "2.2.600"
 hamcrest = "2.2"
-jems2 = "2.22.0"
+jems2 = "2.23.1"
 junit = "5.8.2"
 junit-testkit = "1.9.2"
 srcless = "0.3.0"
diff --git a/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSet.java b/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSet.java
@@ -32,6 +32,7 @@ public EmptyRecurrenceSet()
     {
         super(new AllOf<>(
             new Is<>(new EmptyIterable()),
+            new Is<>(new Finite()),
             new Is<>(new Not<>(new Infinite()))));
     }
 }
diff --git a/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Finite.java b/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Finite.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
+import org.saynotobugs.confidence.description.Text;
+import org.saynotobugs.confidence.quality.composite.AllOf;
+import org.saynotobugs.confidence.quality.composite.Not;
+import org.saynotobugs.confidence.quality.composite.QualityComposition;
+import org.saynotobugs.confidence.quality.object.Satisfies;
+
+@StaticFactories(value = "Recur", packageName = "org.dmfs.rfc5545.confidence")
+public final class Finite extends QualityComposition<RecurrenceSet>
+{
+    public Finite()
+    {
+        super(new AllOf<>(
+            new Not<>(new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite"))),
+            new Satisfies<>(RecurrenceSet::isFinite, new Text("finite"))));
+    }
+}
diff --git a/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Infinite.java b/lib-recur-confidence/src/main/java/org/dmfs/rfc5545/confidence/quality/Infinite.java
@@ -20,6 +20,8 @@
 import org.dmfs.rfc5545.RecurrenceSet;
 import org.dmfs.srcless.annotations.staticfactory.StaticFactories;
 import org.saynotobugs.confidence.description.Text;
+import org.saynotobugs.confidence.quality.composite.AllOf;
+import org.saynotobugs.confidence.quality.composite.Not;
 import org.saynotobugs.confidence.quality.composite.QualityComposition;
 import org.saynotobugs.confidence.quality.object.Satisfies;
 
@@ -28,6 +30,8 @@ public final class Infinite extends QualityComposition<RecurrenceSet>
 {
     public Infinite()
     {
-        super(new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite")));
+        super(new AllOf<>(
+            new Not<>(new Satisfies<>(RecurrenceSet::isFinite, new Text("finite"))),
+            new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite"))));
     }
 }
diff --git a/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSetTest.java b/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/EmptyRecurrenceSetTest.java
@@ -38,21 +38,25 @@ void test()
             allOf(
                 org.saynotobugs.confidence.test.quality.Test.<RecurrenceSet>passes(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(false)),
+                    with(RecurrenceSet::isFinite, returning(true)),
                     with(RecurrenceSet::iterator, returning(new EmptyIterator())))),
 
                 fails(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(true)),
+                    with(RecurrenceSet::isFinite, returning(false)),
                     with(RecurrenceSet::iterator, returning(new EmptyIterator())))),
 
                 fails(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(false)),
+                    with(RecurrenceSet::isFinite, returning(true)),
                     with(RecurrenceSet::iterator, returning(
                         new FastForwardable(
                             DateTime.parse("20240101"),
                             new Seq<>(DateTime.parse("20240102"), DateTime.parse("20240103"))))))),
 
                 fails(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(true)),
+                    with(RecurrenceSet::isFinite, returning(false)),
                     with(RecurrenceSet::iterator, returning(
                         new FastForwardable(
                             DateTime.parse("20240101"),
diff --git a/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/FiniteTest.java b/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/FiniteTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2024 Marten Gajda <marten@dmfs.org>
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.dmfs.rfc5545.confidence.quality;
+
+import org.dmfs.rfc5545.InstanceIterator;
+import org.dmfs.rfc5545.RecurrenceSet;
+import org.junit.jupiter.api.Test;
+
+import static org.dmfs.jems2.mockito.Mock.*;
+import static org.saynotobugs.confidence.Assertion.assertThat;
+import static org.saynotobugs.confidence.quality.Core.allOf;
+import static org.saynotobugs.confidence.test.quality.Test.fails;
+
+class FiniteTest
+{
+    @Test
+    void test()
+    {
+        assertThat(new Finite(),
+            allOf(
+                org.saynotobugs.confidence.test.quality.Test.<RecurrenceSet>passes(mock(RecurrenceSet.class,
+                    with(RecurrenceSet::isInfinite, returning(false)),
+                    with(RecurrenceSet::isFinite, returning(true)),
+                    with(RecurrenceSet::iterator, returning(mock(InstanceIterator.class))))),
+
+                fails(mock(RecurrenceSet.class,
+                    with(RecurrenceSet::isInfinite, returning(true)),
+                    with(RecurrenceSet::isFinite, returning(false)),
+                    with(RecurrenceSet::iterator, returning(mock(InstanceIterator.class)))))));
+    }
+
+}
diff --git a/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/InfiniteTest.java b/lib-recur-confidence/src/test/java/org/dmfs/rfc5545/confidence/quality/InfiniteTest.java
@@ -35,10 +35,12 @@ void test()
             allOf(
                 org.saynotobugs.confidence.test.quality.Test.<RecurrenceSet>passes(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(true)),
+                    with(RecurrenceSet::isFinite, returning(false)),
                     with(RecurrenceSet::iterator, returning(mock(InstanceIterator.class))))),
 
                 fails(mock(RecurrenceSet.class,
                     with(RecurrenceSet::isInfinite, returning(false)),
+                    with(RecurrenceSet::isFinite, returning(true)),
                     with(RecurrenceSet::iterator, returning(mock(InstanceIterator.class)))))));
     }
 
diff --git a/src/main/java/org/dmfs/rfc5545/RecurrenceSet.java b/src/main/java/org/dmfs/rfc5545/RecurrenceSet.java
@@ -18,8 +18,6 @@
 package org.dmfs.rfc5545;
 
 
-import org.dmfs.jems2.Optional;
-
 /**
  * A set of instances.
  */
@@ -32,6 +30,17 @@ public interface RecurrenceSet extends Iterable<DateTime>
 
     /**
      * Returns whether this {@link RecurrenceSet} is infinite or not.
+     *
+     * @deprecated in favour of {@link #isFinite()}
      */
+    @Deprecated(forRemoval = true)
     boolean isInfinite();
+
+    /**
+     * Returns whether this {@link RecurrenceSet} is finite.
+     */
+    default boolean isFinite()
+    {
+        return !isInfinite();
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/optional/LastInstance.java b/src/main/java/org/dmfs/rfc5545/optional/LastInstance.java
@@ -19,7 +19,7 @@
 
 import org.dmfs.jems2.Optional;
 import org.dmfs.jems2.optional.DelegatingOptional;
-import org.dmfs.jems2.optional.Restrained;
+import org.dmfs.jems2.optional.If;
 import org.dmfs.rfc5545.DateTime;
 import org.dmfs.rfc5545.RecurrenceSet;
 
@@ -31,6 +31,6 @@ public final class LastInstance extends DelegatingOptional<DateTime>
 {
     public LastInstance(RecurrenceSet recurrenceSet)
     {
-        super(new Restrained<>(() -> !recurrenceSet.isInfinite(), new Last<>(recurrenceSet)));
+        super(new If<>(recurrenceSet::isFinite, new Last<>(recurrenceSet)));
     }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/Difference.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/Difference.java
@@ -47,4 +47,10 @@ public boolean isInfinite()
     {
         return mMinuend.isInfinite();
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return mMinuend.isFinite();
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/FastForwarded.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/FastForwarded.java
@@ -65,4 +65,10 @@ public boolean isInfinite()
     {
         return mDelegate.isInfinite();
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return mDelegate.isFinite();
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/Merged.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/Merged.java
@@ -20,6 +20,7 @@
 import org.dmfs.jems2.iterable.Mapped;
 import org.dmfs.jems2.iterable.Seq;
 import org.dmfs.jems2.iterable.Sieved;
+import org.dmfs.jems2.predicate.Not;
 import org.dmfs.rfc5545.InstanceIterator;
 import org.dmfs.rfc5545.RecurrenceSet;
 
@@ -56,6 +57,11 @@ public boolean isInfinite()
                     return new Sieved<>(RecurrenceSet::isInfinite, delegates).iterator().hasNext();
                 }
 
+                @Override
+                public boolean isFinite()
+                {
+                    return !new Sieved<>(new Not<>(RecurrenceSet::isFinite), delegates).iterator().hasNext();
+                }
             });
     }
 
@@ -77,4 +83,10 @@ public boolean isInfinite()
     {
         return mDelegate.isInfinite();
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return mDelegate.isFinite();
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/OfList.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/OfList.java
@@ -93,4 +93,10 @@ public boolean isInfinite()
     {
         return false;
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return true;
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/OfRule.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/OfRule.java
@@ -47,4 +47,10 @@ public boolean isInfinite()
     {
         return mRecurrenceRule.isInfinite();
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return !mRecurrenceRule.isInfinite();
+    }
 }
diff --git a/src/main/java/org/dmfs/rfc5545/recurrenceset/OfRuleAndFirst.java b/src/main/java/org/dmfs/rfc5545/recurrenceset/OfRuleAndFirst.java
@@ -67,4 +67,10 @@ public boolean isInfinite()
     {
         return mRecurrenceRule.isInfinite();
     }
+
+    @Override
+    public boolean isFinite()
+    {
+        return !mRecurrenceRule.isInfinite();
+    }
 }
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/DifferenceTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/DifferenceTest.java
@@ -65,7 +65,7 @@ void testInstancesAndExceptions() throws InvalidRecurrenceRuleException
                 new OfRule(new RecurrenceRule("FREQ=HOURLY;INTERVAL=12;COUNT=10"), DateTime.parse("20240224T120000")),
                 new OfRule(new RecurrenceRule("FREQ=DAILY;COUNT=5"), DateTime.parse("20240224T000000"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240224T120000"),
                     DateTime.parse("20240225T120000"),
@@ -87,7 +87,7 @@ void test_github_issue_93() throws InvalidRecurrenceRuleException
                 new OfRule(new RecurrenceRule("FREQ=WEEKLY;UNTIL=20200511T000000Z;BYDAY=TU"), DateTime.parse("20200414T160000Z")),
                 new OfList(DateTime.parse("20200421T160000Z"), DateTime.parse("20200505T160000Z"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20200414T160000Z"),
                     DateTime.parse("20200428T160000Z"))));
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/FastForwardedTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/FastForwardedTest.java
@@ -55,7 +55,7 @@ void testFastForwardRule() throws InvalidRecurrenceRuleException
             new FastForwarded(DateTime.parse("20240218"),
                 new OfRule(new RecurrenceRule("FREQ=DAILY;COUNT=5"), DateTime.parse("20240215"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240218"),
                     DateTime.parse("20240219"))));
@@ -69,7 +69,7 @@ void testFastForwardRuleWithUnsyncedStart() throws InvalidRecurrenceRuleExceptio
             new FastForwarded(DateTime.parse("20240218"),
                 new OfRuleAndFirst(new RecurrenceRule("FREQ=DAILY;BYDAY=FR;COUNT=3"), DateTime.parse("20240215"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240223"))));
     }
@@ -82,7 +82,7 @@ void testFastForwardRuleWithUnsyncedStartMultipleInstances() throws InvalidRecur
             new FastForwarded(DateTime.parse("20240218"),
                 new OfRuleAndFirst(new RecurrenceRule("FREQ=DAILY;BYDAY=FR;COUNT=5"), DateTime.parse("20240207"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240223"),
                     DateTime.parse("20240301"))));
@@ -99,7 +99,7 @@ void testFastForwardList()
                     DateTime.parse("20240218"),
                     DateTime.parse("20240219"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240218"),
                     DateTime.parse("20240219"))));
@@ -118,7 +118,7 @@ void testFastForwardMultiple() throws InvalidRecurrenceRuleException
                     DateTime.parse("20240220"),
                     DateTime.parse("20240221"))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240218"),
                     DateTime.parse("20240219"),
@@ -138,7 +138,7 @@ void testFastForwardWithExceptions() throws InvalidRecurrenceRuleException
                         DateTime.parse("20240217"),
                         DateTime.parse("20240220")))),
             allOf(
-                is(not(infinite())),
+                is(finite()),
                 iterates(
                     DateTime.parse("20240218"),
                     DateTime.parse("20240219"),
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/MergedTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/MergedTest.java
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/OfListTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/OfListTest.java
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/OfRuleAndFirstTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/OfRuleAndFirstTest.java
diff --git a/src/test/java/org/dmfs/rfc5545/recurrenceset/OfRuleTest.java b/src/test/java/org/dmfs/rfc5545/recurrenceset/OfRuleTest.java

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ dependencies {`
`78`	`78`	`api libs.jems2`
`79`	`79`	`testImplementation project("lib-recur-hamcrest")`
`80`	`80`	`testImplementation project("lib-recur-confidence")`
`81`		`- testImplementation 'org.dmfs:jems2-testing:2.22.0'`
	`81`	`+ testImplementation libs.jems2.testing`
`82`	`82`	`testImplementation libs.jems2.confidence`
`83`	`83`	`testImplementation 'org.saynotobugs:confidence-core:0.42.0'`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ public EmptyRecurrenceSet()`
`32`	`32`	`{`
`33`	`33`	`super(new AllOf<>(`
`34`	`34`	`new Is<>(new EmptyIterable()),`
	`35`	`+ new Is<>(new Finite()),`
`35`	`36`	`new Is<>(new Not<>(new Infinite()))));`
`36`	`37`	`}`
`37`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@`
`20`	`20`	`import org.dmfs.rfc5545.RecurrenceSet;`
`21`	`21`	`import org.dmfs.srcless.annotations.staticfactory.StaticFactories;`
`22`	`22`	`import org.saynotobugs.confidence.description.Text;`
	`23`	`+import org.saynotobugs.confidence.quality.composite.AllOf;`
	`24`	`+import org.saynotobugs.confidence.quality.composite.Not;`
`23`	`25`	`import org.saynotobugs.confidence.quality.composite.QualityComposition;`
`24`	`26`	`import org.saynotobugs.confidence.quality.object.Satisfies;`
`25`	`27`
`@@ -28,6 +30,8 @@ public final class Infinite extends QualityComposition<RecurrenceSet>`
`28`	`30`	`{`
`29`	`31`	`public Infinite()`
`30`	`32`	`{`
`31`		`- super(new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite")));`
	`33`	`+ super(new AllOf<>(`
	`34`	`+ new Not<>(new Satisfies<>(RecurrenceSet::isFinite, new Text("finite"))),`
	`35`	`+ new Satisfies<>(RecurrenceSet::isInfinite, new Text("infinite"))));`
`32`	`36`	`}`
`33`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`
`20`	`20`	`import org.dmfs.jems2.Optional;`
`21`	`21`	`import org.dmfs.jems2.optional.DelegatingOptional;`
`22`		`-import org.dmfs.jems2.optional.Restrained;`
	`22`	`+import org.dmfs.jems2.optional.If;`
`23`	`23`	`import org.dmfs.rfc5545.DateTime;`
`24`	`24`	`import org.dmfs.rfc5545.RecurrenceSet;`
`25`	`25`
`@@ -31,6 +31,6 @@ public final class LastInstance extends DelegatingOptional<DateTime>`
`31`	`31`	`{`
`32`	`32`	`public LastInstance(RecurrenceSet recurrenceSet)`
`33`	`33`	`{`
`34`		`- super(new Restrained<>(() -> !recurrenceSet.isInfinite(), new Last<>(recurrenceSet)));`
	`34`	`+ super(new If<>(recurrenceSet::isFinite, new Last<>(recurrenceSet)));`
`35`	`35`	`}`
`36`	`36`	`}`