Kotlin Updates

- Make consistent functions for building providers
- Make consistent functions for executing mappers
- Format code according to Kotlin style guide

Author: jeffgbutler

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/AbstractQueryExpressionDSLExtensions.kt

@@ -74,4 +74,3 @@ fun <T : AbstractQueryExpressionDSL<T, SelectModel>> AbstractQueryExpressionDSL<
     collect(collector)
     return rightJoin(table, alias, collector.onJoinCriterion, collector.andJoinCriteria)
 }
-

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/AbstractWhereDSLExtensions.kt

@@ -19,15 +19,13 @@ import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.where.AbstractWhereDSL
 
-fun <T,M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                                         collect: CriteriaReceiver): M {
+fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): M {
     val collector = CriteriaCollector()
     collect(collector)
     return and(column, condition, collector.criteria)
 }
 
-fun <T,M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                                         collect: CriteriaReceiver): M {
+fun <T, M : AbstractWhereDSL<M>> AbstractWhereDSL<M>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver): M {
     val collector = CriteriaCollector()
     collect(collector)
     return or(column, condition, collector.criteria)

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/CountDSLExtensions.kt

@@ -17,40 +17,35 @@ package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.VisitableCondition
-import org.mybatis.dynamic.sql.delete.DeleteDSL
-import org.mybatis.dynamic.sql.delete.DeleteModel
 import org.mybatis.dynamic.sql.select.CountDSL
 import org.mybatis.dynamic.sql.select.SelectModel
 import org.mybatis.dynamic.sql.util.Buildable
 
 typealias CountCompleter = CountDSL<SelectModel>.() -> Buildable<SelectModel>
 
-fun <T> CountDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                     collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> CountDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> CountDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().and(column, condition)
-        }
+    apply {
+        where().and(column, condition)
+    }
 
-fun <T> CountDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                   collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> CountDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> CountDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().or(column, condition)
-        }
-
-fun <T> CountDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                  collect: CriteriaReceiver) =
-        apply {
-            where().or(column, condition, collect)
-        }
+    apply {
+        where().or(column, condition)
+    }
+
+fun <T> CountDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().or(column, condition, collect)
+    }
 
 fun CountDSL<SelectModel>.allRows() = this as Buildable<SelectModel>

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/CriteriaCollector.kt

@@ -25,44 +25,42 @@ class CriteriaCollector {
     val criteria = mutableListOf<SqlCriterion<*>>()
 
     fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-            apply {
-                criteria.add(SqlCriterion.withColumn(column)
-                        .withCondition(condition)
-                        .withConnector("and")
-                        .build())
-            }
+        apply {
+            criteria.add(SqlCriterion.withColumn(column)
+                .withCondition(condition)
+                .withConnector("and")
+                .build())
+        }
 
-    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                collect: CriteriaCollector.() -> CriteriaCollector) =
-            apply {
-                val collector = CriteriaCollector()
-                collect(collector)
-                val criterion: SqlCriterion<T> = SqlCriterion.withColumn(column)
-                        .withCondition(condition)
-                        .withSubCriteria(collector.criteria)
-                        .withConnector("and")
-                        .build()
-                criteria.add(criterion)
-            }
+    fun <T> and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaCollector.() -> CriteriaCollector) =
+        apply {
+            val collector = CriteriaCollector()
+            collect(collector)
+            val criterion: SqlCriterion<T> = SqlCriterion.withColumn(column)
+                .withCondition(condition)
+                .withSubCriteria(collector.criteria)
+                .withConnector("and")
+                .build()
+            criteria.add(criterion)
+        }
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-            apply {
-                criteria.add(SqlCriterion.withColumn(column)
-                        .withCondition(condition)
-                        .withConnector("or")
-                        .build())
-            }
+        apply {
+            criteria.add(SqlCriterion.withColumn(column)
+                .withCondition(condition)
+                .withConnector("or")
+                .build())
+        }
 
-    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-               collect: CriteriaCollector.() -> CriteriaCollector) =
-            apply {
-                val collector = CriteriaCollector()
-                collect(collector)
-                val criterion: SqlCriterion<T> = SqlCriterion.withColumn(column)
-                        .withCondition(condition)
-                        .withSubCriteria(collector.criteria)
-                        .withConnector("or")
-                        .build()
-                criteria.add(criterion)
-            }
+    fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaCollector.() -> CriteriaCollector) =
+        apply {
+            val collector = CriteriaCollector()
+            collect(collector)
+            val criterion: SqlCriterion<T> = SqlCriterion.withColumn(column)
+                .withCondition(condition)
+                .withSubCriteria(collector.criteria)
+                .withConnector("or")
+                .build()
+            criteria.add(criterion)
+        }
 }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/DeleteDSLExtensions.kt

@@ -23,32 +23,29 @@ import org.mybatis.dynamic.sql.util.Buildable
 
 typealias DeleteCompleter = DeleteDSL<DeleteModel>.() -> Buildable<DeleteModel>
 
-fun <T> DeleteDSL<DeleteModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                     collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> DeleteDSL<DeleteModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> DeleteDSL<DeleteModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().and(column, condition)
-        }
+    apply {
+        where().and(column, condition)
+    }
 
-fun <T> DeleteDSL<DeleteModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                   collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> DeleteDSL<DeleteModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> DeleteDSL<DeleteModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().or(column, condition)
-        }
-
-fun <T> DeleteDSL<DeleteModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                  collect: CriteriaReceiver) =
-        apply {
-            where().or(column, condition, collect)
-        }
+    apply {
+        where().or(column, condition)
+    }
+
+fun <T> DeleteDSL<DeleteModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().or(column, condition, collect)
+    }
 
 fun DeleteDSL<DeleteModel>.allRows() = this as Buildable<DeleteModel>

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/FromGathererExtensions.kt

@@ -19,15 +19,12 @@ import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL
 import org.mybatis.dynamic.sql.select.SelectModel
 
-// These functions are intended for use in a Join mapper where a join is setup before the remainder
-// of the query is completed
-
 typealias QueryExpressionEnhancer = QueryExpressionDSL<SelectModel>.() -> QueryExpressionDSL<SelectModel>
 
-fun QueryExpressionDSL.FromGatherer<SelectModel>.fromJoining(table: SqlTable,
-                                                             enhance: QueryExpressionEnhancer) =
-        enhance(from(table))
+// These functions are intended for use in a Join mapper where a join is setup before the remainder
+// of the query is completed
+fun QueryExpressionDSL.FromGatherer<SelectModel>.from(table: SqlTable, enhancer: QueryExpressionEnhancer) =
+    enhancer(from(table))
 
-fun QueryExpressionDSL.FromGatherer<SelectModel>.fromJoining(table: SqlTable, alias: String,
-                                                             enhance: QueryExpressionEnhancer) =
-        enhance(from(table, alias))
+fun QueryExpressionDSL.FromGatherer<SelectModel>.from(table: SqlTable, alias: String, enhancer: QueryExpressionEnhancer) =
+    enhancer(from(table, alias))

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/JoinCollector.kt

@@ -26,21 +26,20 @@ class JoinCollector {
     val andJoinCriteria = mutableListOf<JoinCriterion>()
 
     fun on(column: BasicColumn, condition: JoinCondition) =
-            apply {
-                onJoinCriterion = JoinCriterion.Builder()
-                        .withConnector("on")
-                        .withJoinColumn(column)
-                        .withJoinCondition(condition)
-                        .build()
-            }
+        apply {
+            onJoinCriterion = JoinCriterion.Builder()
+                .withConnector("on")
+                .withJoinColumn(column)
+                .withJoinCondition(condition)
+                .build()
+        }
 
     fun and(column: BasicColumn, condition: JoinCondition) =
-            apply {
-                andJoinCriteria.add(JoinCriterion.Builder()
-                        .withConnector("and")
-                        .withJoinColumn(column)
-                        .withJoinCondition(condition)
-                        .build())
-
-            }
+        apply {
+            andJoinCriteria.add(JoinCriterion.Builder()
+                .withConnector("and")
+                .withJoinColumn(column)
+                .withJoinCondition(condition)
+                .build())
+        }
 }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/QueryExpressionDSLExtensions.kt

@@ -23,32 +23,29 @@ import org.mybatis.dynamic.sql.util.Buildable
 
 typealias SelectCompleter = QueryExpressionDSL<SelectModel>.() -> Buildable<SelectModel>
 
-fun <T> QueryExpressionDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                              collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> QueryExpressionDSL<SelectModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> QueryExpressionDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().and(column, condition)
-        }
+    apply {
+        where().and(column, condition)
+    }
 
-fun <T> QueryExpressionDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                            collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> QueryExpressionDSL<SelectModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> QueryExpressionDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().or(column, condition)
-        }
-
-fun <T> QueryExpressionDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                           collect: CriteriaReceiver) =
-        apply {
-            where().or(column, condition, collect)
-        }
+    apply {
+        where().or(column, condition)
+    }
+
+fun <T> QueryExpressionDSL<SelectModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().or(column, condition, collect)
+    }
 
 fun QueryExpressionDSL<SelectModel>.allRows() = this as Buildable<SelectModel>

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/UpdateDSLExtensions.kt

@@ -23,30 +23,27 @@ import org.mybatis.dynamic.sql.util.Buildable
 
 typealias UpdateCompleter = UpdateDSL<UpdateModel>.() -> Buildable<UpdateModel>
 
-fun <T> UpdateDSL<UpdateModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                     collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> UpdateDSL<UpdateModel>.where(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> UpdateDSL<UpdateModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().and(column, condition)
-        }
+    apply {
+        where().and(column, condition)
+    }
 
-fun <T> UpdateDSL<UpdateModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                   collect: CriteriaReceiver) =
-        apply {
-            where().and(column, condition, collect)
-        }
+fun <T> UpdateDSL<UpdateModel>.and(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().and(column, condition, collect)
+    }
 
 fun <T> UpdateDSL<UpdateModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>) =
-        apply {
-            where().or(column, condition)
-        }
+    apply {
+        where().or(column, condition)
+    }
 
-fun <T> UpdateDSL<UpdateModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>,
-                                  collect: CriteriaReceiver) =
-        apply {
-            where().or(column, condition, collect)
-        }
+fun <T> UpdateDSL<UpdateModel>.or(column: BindableColumn<T>, condition: VisitableCondition<T>, collect: CriteriaReceiver) =
+    apply {
+        where().or(column, condition, collect)
+    }