Added deprecations of old RegexQuantifier members

Author: markwhitaker

src/main/kotlin/RegexQuantifier.kt

@@ -10,6 +10,15 @@ sealed class RegexQuantifier(
 
     interface Greedy {
         val butAsFewAsPossible: RegexQuantifier
+
+        @Deprecated(
+            message = "Replace with butAsFewAsPossible",
+            replaceWith = ReplaceWith(
+                "butAsFewAsPossible",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier"
+            )
+        )
+        fun butAsFewAsPossible() = butAsFewAsPossible
     }
 
     /**
@@ -54,7 +63,7 @@ sealed class RegexQuantifier(
      * @param minimum The minimum number of occurrences to match
      * @return A greedy quantifier: use [butAsFewAsPossible] to make it lazy
      */
-    class AtLeast(minimum: Int): RegexQuantifier("{$minimum,}"), Greedy {
+    class AtLeast(minimum: Int) : RegexQuantifier("{$minimum,}"), Greedy {
         override val butAsFewAsPossible: RegexQuantifier = LazyAtLeast(minimum)
     }
 
@@ -64,7 +73,7 @@ sealed class RegexQuantifier(
      * @param maximum The maximum number of occurrences to match
      * @return A greedy quantifier: use [butAsFewAsPossible] to make it lazy
      */
-    class NoMoreThan(maximum: Int): RegexQuantifier("{0,$maximum}"), Greedy {
+    class NoMoreThan(maximum: Int) : RegexQuantifier("{0,$maximum}"), Greedy {
         override val butAsFewAsPossible: RegexQuantifier = LazyNoMoreThan(maximum)
     }
 
@@ -75,14 +84,88 @@ sealed class RegexQuantifier(
      * @param maximum The maximum number of occurrences to match
      * @return A greedy quantifier: use [butAsFewAsPossible] to make it lazy
      */
-    class Between(minimum: Int, maximum: Int): RegexQuantifier("{$minimum,$maximum}"), Greedy {
+    class Between(minimum: Int, maximum: Int) : RegexQuantifier("{$minimum,$maximum}"), Greedy {
         override val butAsFewAsPossible: RegexQuantifier = LazyBetween(minimum, maximum)
     }
 
-    private object LazyZeroOrMore: RegexQuantifier("*?")
-    private object LazyOneOrMore: RegexQuantifier("+?")
-    private object LazyZeroOrOne: RegexQuantifier("??")
-    private class LazyAtLeast(minimum: Int): RegexQuantifier("{$minimum,}?")
-    private class LazyNoMoreThan(maximum: Int): RegexQuantifier("{0,$maximum}?")
-    private class LazyBetween(minimum: Int, maximum: Int): RegexQuantifier("{$minimum,$maximum}?")
+    private object LazyZeroOrMore : RegexQuantifier("*?")
+    private object LazyOneOrMore : RegexQuantifier("+?")
+    private object LazyZeroOrOne : RegexQuantifier("??")
+    private class LazyAtLeast(minimum: Int) : RegexQuantifier("{$minimum,}?")
+    private class LazyNoMoreThan(maximum: Int) : RegexQuantifier("{0,$maximum}?")
+    private class LazyBetween(minimum: Int, maximum: Int) : RegexQuantifier("{$minimum,$maximum}?")
+
+    companion object {
+        @Deprecated(
+            message = "Replace with ZeroOrOne",
+            replaceWith = ReplaceWith(
+                "ZeroOrOne",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.ZeroOrOne"
+            )
+        )
+        fun oneOrNone() = ZeroOrOne
+
+        @Deprecated(
+            message = "Replace with ZeroOrOne",
+            replaceWith = ReplaceWith(
+                "ZeroOrOne",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.ZeroOrOne"
+            )
+        )
+        fun zeroOrOne() = ZeroOrOne
+
+        @Deprecated(
+            message = "Replace with ZeroOrMore",
+            replaceWith = ReplaceWith(
+                "ZeroOrMore",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.ZeroOrMore"
+            )
+        )
+        fun zeroOrMore() = ZeroOrMore
+
+        @Deprecated(
+            message = "Replace with OneOrMore",
+            replaceWith = ReplaceWith(
+                "OneOrMore",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.OneOrMore"
+            )
+        )
+        fun oneOrMore() = OneOrMore
+
+        @Deprecated(
+            message = "Replace with Exactly",
+            replaceWith = ReplaceWith(
+                "Exactly(times)",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.Exactly"
+            )
+        )
+        fun exactly(times: Int) = Exactly(times)
+
+        @Deprecated(
+            message = "Replace with AtLeast",
+            replaceWith = ReplaceWith(
+                "AtLeast(minimum)",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.AtLeast"
+            )
+        )
+        fun atLeast(minimum: Int) = AtLeast(minimum)
+
+        @Deprecated(
+            message = "Replace with NoMoreThan",
+            replaceWith = ReplaceWith(
+                "NoMoreThan(maximum)",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.NoMoreThan"
+            )
+        )
+        fun noMoreThan(maximum: Int) = NoMoreThan(maximum)
+
+        @Deprecated(
+            message = "Replace with Between",
+            replaceWith = ReplaceWith(
+                "Between(minimum, maximum)",
+                "uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.Between"
+            )
+        )
+        fun between(minimum: Int, maximum: Int) = Between(minimum, maximum)
+    }
 }

src/test/kotlin/RegexBuilderTest.kt

@@ -8,7 +8,6 @@ import uk.co.mainwave.regextoolboxkotlin.RegexBuilder
 import uk.co.mainwave.regextoolboxkotlin.RegexBuilderException
 import uk.co.mainwave.regextoolboxkotlin.RegexOptions.IGNORE_CASE
 import uk.co.mainwave.regextoolboxkotlin.RegexOptions.MULTILINE
-import uk.co.mainwave.regextoolboxkotlin.RegexQuantifier
 import uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.AtLeast
 import uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.Between
 import uk.co.mainwave.regextoolboxkotlin.RegexQuantifier.Exactly