chore: code cleanup

Author: yiteam

README.md

@@ -26,7 +26,7 @@ fun shouldReturnTupleWithLimitNumber() {
     )
     val querydslRsql = QuerydslRsql.Builder<Car>(entityManager)
         .select(select)
-        .from(clazz)
+        // .from(clazz)
         .where("id=notnull='' and (name=like='%a%' or name=con='Béla2,Béla11')")
         .sort("id.desc")
         .limit(15L, 15)

src/main/kotlin/team/yi/rsql/querydsl/QuerydslRsql.kt

@@ -208,39 +208,17 @@ class QuerydslRsql<E> private constructor(builder: Builder<E>) {
             this.orderSpecifiers = builder.orderSpecifiers
         }
 
-        fun select(select: String?): BuildBuilder<E> {
-            this.selectString = select
+        fun select(select: String?): BuildBuilder<E> = BuildBuilder(this).apply { this.selectString = select }
+        fun select(vararg expression: Expression<*>?): BuildBuilder<E> = BuildBuilder(this).apply { this.selectExpressions = expression.filterNotNull().distinct() }
 
-            return BuildBuilder(this)
-        }
-
-        fun select(vararg expression: Expression<*>?): BuildBuilder<E> {
-            this.selectExpressions = expression.filterNotNull().distinct()
-
-            return BuildBuilder(this)
-        }
-
-        fun from(entityName: String?): BuildBuilder<E> {
-            this.entityName = entityName
-
-            return BuildBuilder(this)
-        }
+        fun from(entityName: String?): BuildBuilder<E> = BuildBuilder(this).apply { this.entityName = entityName }
+        fun from(entityClass: Class<E>?): BuildBuilder<E> = BuildBuilder(this).apply { this.entityClass = entityClass }
 
-        fun from(entityClass: Class<E>?): BuildBuilder<E> {
-            this.entityClass = entityClass
-
-            return BuildBuilder(this)
-        }
-
-        fun where(where: String?): BuildBuilder<E> {
-            this.where = where
-
-            return BuildBuilder(this)
-        }
+        fun where(where: String?): BuildBuilder<E> = BuildBuilder(this).apply { this.where = where }
 
         @Suppress("unused", "MemberVisibilityCanBePrivate")
         class BuildBuilder<E>(builder: Builder<E>) : Builder<E>(builder) {
-            fun globalPredicate(globalPredicate: BooleanExpression?): BuildBuilder<E> = this.also { super.globalPredicate = globalPredicate }
+            fun globalPredicate(globalPredicate: BooleanExpression?): BuildBuilder<E> = this.apply { super.globalPredicate = globalPredicate }
 
             @Throws(RsqlException::class)
             fun build(): QuerydslRsql<E> {
@@ -252,41 +230,37 @@ class QuerydslRsql<E> private constructor(builder: Builder<E>) {
             }
 
             fun offset(offset: Int?): BuildBuilder<E> = offset(offset?.toLong())
-            fun offset(offset: Long?): BuildBuilder<E> = this.also { super.offset = offset }
+            fun offset(offset: Long?): BuildBuilder<E> = this.apply { super.offset = offset }
 
             fun limit(limit: Int?): BuildBuilder<E> = limit(limit?.toLong())
-            fun limit(limit: Long?): BuildBuilder<E> = this.also { super.limit = limit }
+            fun limit(limit: Long?): BuildBuilder<E> = this.apply { super.limit = limit }
 
             fun limit(offset: Int?, limit: Int?): BuildBuilder<E> = limit(offset?.toLong(), limit?.toLong())
-            fun limit(offset: Long?, limit: Long?): BuildBuilder<E> = this.also {
+            fun limit(offset: Long?, limit: Long?): BuildBuilder<E> = this.apply {
                 super.offset = offset
                 super.limit = limit
             }
 
             fun page(pageNumber: Int, pageSize: Int): BuildBuilder<E> = page(pageNumber.toLong(), pageSize.toLong())
             fun page(pageNumber: Int, pageSize: Long): BuildBuilder<E> = page(pageNumber.toLong(), pageSize)
 
-            fun page(pageNumber: Long, pageSize: Long): BuildBuilder<E> = this.also {
+            fun page(pageNumber: Long, pageSize: Long): BuildBuilder<E> = this.apply {
                 super.limit = pageSize
                 super.offset = pageNumber * pageSize
             }
 
-            fun sort(sort: String?): BuildBuilder<E> = this.also { super.sort = sort }
-            fun sort(vararg expression: OrderSpecifier<*>?): BuildBuilder<E> = this.also { super.orderSpecifiers = expression.filterNotNull().distinct() }
-            fun sort(orderSpecifiers: List<OrderSpecifier<*>>?): BuildBuilder<E> = this.also { super.orderSpecifiers = orderSpecifiers }
+            fun sort(sort: String?): BuildBuilder<E> = this.apply { super.sort = sort }
+            fun sort(vararg expression: OrderSpecifier<*>?): BuildBuilder<E> = this.apply { super.orderSpecifiers = expression.filterNotNull().distinct() }
+            fun sort(orderSpecifiers: List<OrderSpecifier<*>>?): BuildBuilder<E> = this.apply { super.orderSpecifiers = orderSpecifiers }
 
-            fun operator(vararg operator: RsqlOperator): BuildBuilder<E> = this.also { super.rsqlConfig.operators = operator.toList() }
-            fun operators(operators: List<RsqlOperator>): BuildBuilder<E> = this.also { super.rsqlConfig.operators = operators.toList() }
+            fun operator(vararg operator: RsqlOperator): BuildBuilder<E> = this.apply { super.rsqlConfig.operators = operator.toList() }
+            fun operators(operators: List<RsqlOperator>): BuildBuilder<E> = this.apply { super.rsqlConfig.operators = operators.toList() }
 
-            fun fieldTypeHandler(vararg typeHandler: Class<FieldTypeHandler<E>>): BuildBuilder<E> {
-                return this.also { super.rsqlConfig.addFieldTypeHandler(*typeHandler) }
-            }
+            fun fieldTypeHandler(vararg typeHandler: Class<FieldTypeHandler<E>>): BuildBuilder<E> = this.apply { super.rsqlConfig.addFieldTypeHandler(*typeHandler) }
 
-            fun sortFieldTypeHandler(vararg typeHandler: Class<SortFieldTypeHandler<E>>): BuildBuilder<E> {
-                return this.also { super.rsqlConfig.addSortFieldTypeHandler(*typeHandler) }
-            }
+            fun sortFieldTypeHandler(vararg typeHandler: Class<SortFieldTypeHandler<E>>): BuildBuilder<E> = this.apply { super.rsqlConfig.addSortFieldTypeHandler(*typeHandler) }
 
-            fun dateFormat(dateFormat: String): BuildBuilder<E> = this.also { super.rsqlConfig.dateFormat = dateFormat }
+            fun dateFormat(dateFormat: String): BuildBuilder<E> = this.apply { super.rsqlConfig.dateFormat = dateFormat }
         }
     }
 }

src/main/kotlin/team/yi/rsql/querydsl/RsqlConfig.kt

@@ -99,40 +99,30 @@ class RsqlConfig<E> private constructor(builder: Builder<E>) {
         internal val nodeInterceptors = mutableListOf<RsqlNodeInterceptor>()
         internal var dateFormat: String? = null
 
-        fun operator(vararg operator: RsqlOperator): Builder<E> = this.also { this.operators = operator.toList() }
-        fun fieldTypeHandler(vararg typeHandler: Class<out FieldTypeHandler<*>>): Builder<E> = this.also { this.fieldTypeHandlers = typeHandler.toList() }
-        fun sortFieldTypeHandler(vararg typeHandler: Class<out SortFieldTypeHandler<*>>): Builder<E> = this.also { this.sortFieldTypeHandlers = typeHandler.toList() }
+        fun operator(vararg operator: RsqlOperator): Builder<E> = this.apply { this.operators = operator.toList() }
+
+        fun fieldTypeHandler(vararg typeHandler: Class<out FieldTypeHandler<*>>): Builder<E> = this.apply { this.fieldTypeHandlers = typeHandler.toList() }
+
+        fun sortFieldTypeHandler(vararg typeHandler: Class<out SortFieldTypeHandler<*>>): Builder<E> = this.apply { this.sortFieldTypeHandlers = typeHandler.toList() }
 
         @Suppress("UNCHECKED_CAST")
-        fun javaFieldTypeHandler(vararg typeHandler: Class<*>): Builder<E> = this.also {
+        fun javaFieldTypeHandler(vararg typeHandler: Class<*>): Builder<E> = this.apply {
             this.fieldTypeHandlers = typeHandler.mapNotNull { it as? Class<out FieldTypeHandler<*>> }
         }
 
-        @Suppress("UNCHECKED_CAST", "unused")
-        fun javaSortFieldTypeHandler(vararg typeHandler: Class<*>): Builder<E> = this.also {
+        @Suppress("UNCHECKED_CAST")
+        fun javaSortFieldTypeHandler(vararg typeHandler: Class<*>): Builder<E> = this.apply {
             this.sortFieldTypeHandlers = typeHandler.mapNotNull { it as? Class<out SortFieldTypeHandler<*>> }
         }
 
-        fun nodeInterceptors(nodeInterceptors: List<RsqlNodeInterceptor>?): Builder<E> {
-            nodeInterceptors?.let { this.nodeInterceptors.addAll(nodeInterceptors) }
-
-            return this
-        }
+        fun nodeInterceptors(nodeInterceptors: List<RsqlNodeInterceptor>?): Builder<E> = this.apply { nodeInterceptors?.let { this.nodeInterceptors.addAll(nodeInterceptors) } }
 
-        fun nodeInterceptor(block: () -> RsqlNodeInterceptor?): Builder<E> {
-            block()?.let { this.nodeInterceptor(it) }
-
-            return this
-        }
+        fun nodeInterceptor(block: () -> RsqlNodeInterceptor?): Builder<E> = this.apply { block()?.let { this.nodeInterceptor(it) } }
 
         @Suppress("MemberVisibilityCanBePrivate")
-        fun nodeInterceptor(nodeInterceptor: RsqlNodeInterceptor?): Builder<E> {
-            nodeInterceptor?.let { this.nodeInterceptors.add(nodeInterceptor) }
-
-            return this
-        }
+        fun nodeInterceptor(nodeInterceptor: RsqlNodeInterceptor?): Builder<E> = this.apply { nodeInterceptor?.let { this.nodeInterceptors.add(nodeInterceptor) } }
 
-        fun dateFormat(dateFormat: String?): Builder<E> = this.also { this.dateFormat = dateFormat }
+        fun dateFormat(dateFormat: String?): Builder<E> = this.apply { this.dateFormat = dateFormat }
 
         @Throws(RsqlException::class)
         fun build(): RsqlConfig<E> {

src/main/kotlin/team/yi/rsql/querydsl/exception/BuildException.kt

@@ -12,12 +12,14 @@ import javax.persistence.EntityManager
 
 @Suppress("MemberVisibilityCanBePrivate")
 object RsqlUtil {
+    @JvmStatic
     fun getClassForEntityString(entityName: String, entityManager: EntityManager): Class<*>? {
         return entityManager.metamodel.entities
             .firstOrNull { it.name == entityName }
             ?.bindableJavaType
     }
 
+    @JvmStatic
     fun getOperators(customOperators: List<RsqlOperator>?): Set<ComparisonOperator> {
         val operators = Operator.lookup.keys
             .asSequence()
@@ -35,6 +37,7 @@ object RsqlUtil {
         return operators
     }
 
+    @JvmStatic
     fun validateOperators(operators: List<RsqlOperator>) {
         operators.forEach { operator ->
             operator.symbols.forEach {
@@ -54,6 +57,7 @@ object RsqlUtil {
         return if (selectFields.isEmpty()) emptyList() else selectFields.map { pathBuilder[it] }
     }
 
+    @JvmStatic
     fun parseSelectExpression(selectString: String?): List<String> {
         if (selectString.isNullOrBlank()) return emptyList()
 
@@ -62,6 +66,7 @@ object RsqlUtil {
         return str.split(',').distinct()
     }
 
+    @JvmStatic
     fun parseFieldSelector(rootClass: Class<*>, fieldSelector: String?): List<FieldMetadata> {
         var field = fieldSelector
 
@@ -89,6 +94,7 @@ object RsqlUtil {
         return fieldMetadataList
     }
 
+    @JvmStatic
     fun parseSortExpression(sort: String?): Map<String, Order> {
         val result: MutableMap<String, Order> = HashMap()
         val sortParams = parseSelectExpression(sort)