Polishing

Author: jeffgbutler

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/CaseDSLs.kt

@@ -53,11 +53,11 @@ class SearchedCaseCriteriaCollector : GroupingCriteriaCollector() {
         }
 
     fun then(value: String) {
-        this.thenValue = "'$value'"
+        thenValue = "'$value'"
     }
 
     fun then(value: Any) {
-        this.thenValue = value
+        thenValue = value
     }
 }
 
@@ -69,58 +69,48 @@ class KSimpleCaseDSL<T : Any> {
         }
     internal val whenConditions = mutableListOf<SimpleCaseWhenCondition<T>>()
 
-    fun `when`(firstCondition: VisitableCondition<T>, vararg subsequentConditions: VisitableCondition<T>) =
-        ConditionBasedThenGatherer(firstCondition, subsequentConditions.asList())
-
-    fun `when`(firstValue: T, vararg subsequentValues: T) =
-        BasicThenGatherer(firstValue, subsequentValues.asList())
-
-    fun `else`(value: String) {
-        this.elseValue = "'$value'"
-    }
-
-    fun `else`(value: Any) {
-        this.elseValue = value
-    }
-
-    inner class ConditionBasedThenGatherer(private val firstCondition: VisitableCondition<T>,
-                                           private val subsequentConditions: List<VisitableCondition<T>>) {
-        fun then(value: String) {
+    fun `when`(firstCondition: VisitableCondition<T>, vararg subsequentConditions: VisitableCondition<T>,
+               completer: SimpleCaseThenGatherer.() -> Unit) =
+        SimpleCaseThenGatherer().apply(completer).run {
             val allConditions = buildList {
                 add(firstCondition)
                 addAll(subsequentConditions)
             }
 
-            whenConditions.add(ConditionBasedWhenCondition(allConditions, "'$value'"))
+            whenConditions.add(ConditionBasedWhenCondition(allConditions, thenValue))
         }
 
-        fun then(value: Any) {
+    fun `when`(firstValue: T, vararg subsequentValues: T, completer: SimpleCaseThenGatherer.() -> Unit) =
+        SimpleCaseThenGatherer().apply(completer).run {
             val allConditions = buildList {
-                add(firstCondition)
-                addAll(subsequentConditions)
+                add(firstValue)
+                addAll(subsequentValues)
             }
 
-            whenConditions.add(ConditionBasedWhenCondition(allConditions, value))
+            whenConditions.add(BasicWhenCondition(allConditions, thenValue))
         }
+
+    fun `else`(value: String) {
+        this.elseValue = "'$value'"
     }
 
-    inner class BasicThenGatherer(private val firstValue: T, private val subsequentValues: List<T>) {
-        fun then(value: String) {
-            val allValues = buildList {
-                add(firstValue)
-                addAll(subsequentValues)
-            }
+    fun `else`(value: Any) {
+        this.elseValue = value
+    }
+}
 
-            whenConditions.add(BasicWhenCondition(allValues, "'$value'"))
+class SimpleCaseThenGatherer {
+    internal var thenValue: Any? = null
+        private set(value) {
+            assertNull(field, "ERROR.41") //$NON-NLS-1$
+            field = value
         }
 
-        fun then(value: Any) {
-            val allValues = buildList {
-                add(firstValue)
-                addAll(subsequentValues)
-            }
+    fun then(value: String) {
+        thenValue = "'$value'"
+    }
 
-            whenConditions.add(BasicWhenCondition(allValues, value))
-        }
+    fun then(value: Any) {
+        thenValue = value
     }
 }

src/test/kotlin/examples/kotlin/animal/data/KCaseExpressionTest.kt

@@ -373,7 +373,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")).then("yes")
+                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("yes") }
                     `else`("no")
                 }.`as`("IsAFox")
             ) {
@@ -427,7 +427,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` ("Artic fox", "Red fox").then("yes")
+                    `when` ("Artic fox", "Red fox") { then("yes") }
                     `else`("no")
                 }.`as`("IsAFox")
             ) {
@@ -481,7 +481,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")).then(true)
+                    `when` (isEqualTo("Artic fox"), isEqualTo("Red fox")) { then(true) }
                     `else`(false)
                 }.`as`("IsAFox")
             ) {
@@ -535,7 +535,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when` ("Artic fox", "Red fox").then(true)
+                    `when` ("Artic fox", "Red fox") { then(true) }
                     `else`(false)
                 }.`as`("IsAFox")
             ) {
@@ -589,7 +589,7 @@ class KCaseExpressionTest {
             val selectStatement = select(
                 animalName,
                 case(animalName) {
-                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")).then("yes")
+                    `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("yes") }
                 }.`as`("IsAFox")
             ) {
                 from(animalData)
@@ -632,13 +632,26 @@ class KCaseExpressionTest {
     fun testInvalidDoubleElseSimple() {
         assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
             case(animalName) {
-                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")).then("'yes'")
+                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) { then("'yes'") }
                 `else`("Fred")
                 `else`("Wilma")
             }
         }.withMessage(Messages.getString("ERROR.42"))
     }
 
+    @Test
+    fun testInvalidDoubleThenSimple() {
+        assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
+            case(animalName) {
+                `when`(isEqualTo("Artic fox"), isEqualTo("Red fox")) {
+                    then("'yes'")
+                    then("no")
+                }
+                `else`("Fred")
+            }
+        }.withMessage(Messages.getString("ERROR.41"))
+    }
+
     @Test
     fun testInvalidDoubleElseSearched() {
         assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
@@ -669,14 +682,14 @@ class KCaseExpressionTest {
     @Test
     fun testInvalidSearchedMissingWhen() {
         assertThatExceptionOfType(InvalidSqlException::class.java).isThrownBy {
-            select(case { `else`("Fred") }){ from(animalData) }
+            select(case { `else`("Fred") }) { from(animalData) }
         }.withMessage(Messages.getString("ERROR.40"))
     }
 
     @Test
     fun testInvalidSimpleMissingWhen() {
         assertThatExceptionOfType(InvalidSqlException::class.java).isThrownBy {
-            select(case (id) { `else`("Fred") }){ from (animalData) }
+            select(case (id) { `else`("Fred") }) { from (animalData) }
         }.withMessage(Messages.getString("ERROR.40"))
     }
 }