Merge pull request #15 from consoleau/migration-spring-boot-2.2

Update to Spring Boot 2

Author: jamesbassett

.travis.yml

@@ -1,6 +1,6 @@
 language: java
 sudo: true
-jdk: oraclejdk8
+jdk: openjdk8
 script: "./gradle/travisBuild.sh"
 before_cache:
   - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock

README.md

@@ -15,7 +15,7 @@ repositories {
 }
 
 dependencies {
-    compile("au.com.console:kotlin-jpa-specification-dsl:0.1.0")
+    compile("au.com.console:kotlin-jpa-specification-dsl:2.0.0")
 }
 ```
 
@@ -73,23 +73,23 @@ For more complex and dynamic queries it's good practice to create functions that
 and to allow for their composition in complex dynamic queries.
 
 ```kotlin
-fun hasName(name: String?): Specifications<TvShow>? = name?.let {
+fun hasName(name: String?): Specification<TvShow>? = name?.let {
     TvShow::name.equal(it)
 }
 
-fun availableOnNetflix(available: Boolean?): Specifications<TvShow>? = available?.let {
+fun availableOnNetflix(available: Boolean?): Specification<TvShow>? = available?.let {
     TvShow::availableOnNetflix.equal(it)
 }
 
-fun hasReleaseDateIn(releaseDates: List<String>?): Specifications<TvShow>? = releaseDates?.let {
+fun hasReleaseDateIn(releaseDates: List<String>?): Specification<TvShow>? = releaseDates?.let {
     TvShow::releaseDate.`in`(releaseDates)
 }
 
-fun hasKeywordIn(keywords: List<String>?): Specifications<TvShow>? = keywords?.let {
+fun hasKeywordIn(keywords: List<String>?): Specification<TvShow>? = keywords?.let {
     or(keywords.map(::hasKeyword))
 }
 
-fun hasKeyword(keyword: String?): Specifications<TvShow>? = keyword?.let {
+fun hasKeyword(keyword: String?): Specification<TvShow>? = keyword?.let {
     TvShow::synopsis.like("%$keyword%")
 }
 ```
@@ -131,7 +131,7 @@ Or they can be combined with a service-layer query DTO and mapping extension fun
      * A single TvShowQuery is equivalent to an AND of all supplied criteria.
      * Note: any criteria that is null will be ignored (not included in the query).
      */
-    fun TvShowQuery.toSpecification(): Specifications<TvShow> = and(
+    fun TvShowQuery.toSpecification(): Specification<TvShow> = and(
             hasName(name),
             availableOnNetflix(availableOnNetflix),
             hasKeywordIn(keywords),
@@ -155,7 +155,7 @@ This DSL builds on [Spring Data's Specifications abstraction](http://docs.spring
 The code `TvShow::releaseDate.equal("2010")` is a call to the Kotlin extension function:
 
 ```kotlin
-fun <T, R> KProperty1<T, R?>.equal(x: R): Specifications<T> = spec { equal(it, x) }
+fun <T, R> KProperty1<T, R?>.equal(x: R): Specification<T> = spec { equal(it, x) }
 ```
 
 This is a bit dense, but makes sense when it's broken down:
@@ -164,12 +164,12 @@ This is a bit dense, but makes sense when it's broken down:
 - `R`: The property type, for TvShow::releaseDate it is String
 - `KProperty1<T,R?>`: Kotlin reflection API representation of the property `TvShow::releaseDate`. The 1 refers to a property with 1 receiver, and `R?` is declared as nullable for the method to work on nullable properties as well as non-null properties.
 - `x`: The value to test against
-- `Specifications<T>`: The Spring data specifications result
+- `Specification<T>`: The Spring data specifications result
 
 This is implemented using a private helper function `spec` that captures the common use case of taking an Entity property, and using a `CriteriaBuilder` to create a `Predicate`:
 
 ```kotlin
-private fun <T, R> KProperty1<T, R?>.spec(makePredicate: CriteriaBuilder.(path: Path<R>) -> Predicate): Specifications<T> =
+private fun <T, R> KProperty1<T, R?>.spec(makePredicate: CriteriaBuilder.(path: Path<R>) -> Predicate): Specification<T> =
     this.let { property -> where { root -> makePredicate(root.get(property)) } }
 ```
 

build.gradle

@@ -1,9 +1,10 @@
+
 plugins {
-    id 'nebula.kotlin' version '1.2.21'
-    id 'nebula.project' version '3.4.0'
-    id 'nebula.release' version '6.3.0'
-    id 'nebula.maven-publish' version '7.0.1'
-    id 'nebula.nebula-bintray' version '3.5.2'
+    id 'nebula.project' version '7.0.5'
+    id 'nebula.release' version '14.0.2'
+    id 'nebula.kotlin' version '1.3.61'
+    id 'nebula.maven-publish' version '14.1.1'
+    id 'com.jfrog.bintray' version '1.8.4'
 }
 
 group 'au.com.console'
@@ -16,24 +17,30 @@ sourceCompatibility = JavaVersion.VERSION_1_8
 targetCompatibility = JavaVersion.VERSION_1_8
 
 dependencies {
-    compile 'org.springframework.data:spring-data-jpa:1.10.2.RELEASE'
-    compileOnly 'org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.0.Final'
-    testCompile 'org.springframework.boot:spring-boot-starter-data-jpa:1.3.5.RELEASE'
-    testCompile 'com.h2database:h2:1.4.191'
-    testCompile 'org.springframework.boot:spring-boot-starter-test:1.3.5.RELEASE'
-    testCompile 'junit:junit:4.12'
+    api 'org.jetbrains.kotlin:kotlin-reflect'
+    api 'org.springframework.data:spring-data-jpa:2.2.4.RELEASE'
+    compileOnly 'org.hibernate.javax.persistence:hibernate-jpa-2.1-api:1.0.2.Final'
+    testApi 'org.springframework.boot:spring-boot-starter-data-jpa:2.2.2.RELEASE'
+    testApi 'com.h2database:h2:1.4.191'
+    testApi 'org.springframework.boot:spring-boot-starter-test:2.2.4.RELEASE'
+    testApi 'org.junit.jupiter:junit-jupiter-api:5.5.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
+}
+
+test {
+    useJUnitPlatform()
+    testLogging {
+        events("passed", "skipped", "failed")
+        setExceptionFormat("full")
+    }
 }
 
 tasks.bintrayUpload.dependsOn tasks.check
-tasks.artifactoryPublish.dependsOn tasks.check
 
 gradle.taskGraph.whenReady { graph ->
     tasks.bintrayUpload.onlyIf {
         graph.hasTask(':final') || graph.hasTask(':candidate')
     }
-    tasks.artifactoryPublish.onlyIf {
-        graph.hasTask(':snapshot') || graph.hasTask(':devSnapshot')
-    }
 }
 
 bintray {
@@ -52,8 +59,4 @@ bintray {
         issueTrackerUrl = "https://github.com/consoleau/${project.name}/issues"
         vcsUrl = "https://github.com/consoleau/${project.name}.git"
     }
-}
-
-task wrapper(type: Wrapper) {
-    gradleVersion = "4.5.1"
-}
+}

gradle/travisBuild.sh

@@ -2,7 +2,7 @@
 # This script will build the project.
 # Based on https://github.com/nebula-plugins/nebula-kotlin-plugin/blob/master/gradle/buildViaTravis.sh
 
-SWITCHES="-x artifactoryPublish --info --stacktrace"
+SWITCHES="--info --stacktrace"
 
 GRADLE_VERSION=$(./gradlew -version | grep Gradle | cut -d ' ' -f 2)
 

gradle/wrapper/gradle-wrapper.jar

@@ -1,6 +1,5 @@
-#Tue Feb 20 13:21:37 AEST 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.5.1-bin.zip

gradle/wrapper/gradle-wrapper.properties

@@ -1,4 +1,20 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# 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
+#
+#      https://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.
+#
 
 ##############################################################################
 ##
@@ -28,16 +44,16 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn ( ) {
+warn () {
     echo "$*"
 }
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
@@ -109,8 +125,8 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
     JAVACMD=`cygpath --unix "$JAVACMD"`
@@ -154,16 +170,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
 # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]]; then
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
   cd "$(dirname "$0")"
 fi
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+exec "$JAVACMD" "$@"

gradlew

@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -14,7 +30,7 @@ set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

gradlew.bat

@@ -1,7 +1,6 @@
 package au.com.console.jpaspecificationdsl
 
 import org.springframework.data.jpa.domain.Specification
-import org.springframework.data.jpa.domain.Specifications
 import javax.persistence.criteria.*
 import kotlin.reflect.KProperty1
 
@@ -11,25 +10,27 @@ fun <Z, T, R> From<Z, T>.join(prop: KProperty1<T, R?>): Join<T, R> = this.join<T
 // Helper to enable get by Property
 fun <R> Path<*>.get(prop: KProperty1<*, R?>): Path<R> = this.get<R>(prop.name)
 
-// Version of Specifications.where that makes the CriteriaBuilder implicit
-fun <T> where(makePredicate: CriteriaBuilder.(Root<T>) -> Predicate): Specifications<T> =
-        Specifications.where<T> { root, _, criteriaBuilder -> criteriaBuilder.makePredicate(root) }
+// Version of Specification.where that makes the CriteriaBuilder implicit
+fun <T> where(makePredicate: CriteriaBuilder.(Root<T>) -> Predicate): Specification<T> =
+    Specification { root, _, criteriaBuilder -> criteriaBuilder.makePredicate(root) }
 
-// helper function for defining Specifications that take a Path to a property and send it to a CriteriaBuilder
-private fun <T, R> KProperty1<T, R?>.spec(makePredicate: CriteriaBuilder.(path: Path<R>) -> Predicate): Specifications<T> =
-        this.let { property -> where { root -> makePredicate(root.get(property)) } }
+// helper function for defining Specification that take a Path to a property and send it to a CriteriaBuilder
+private fun <T, R> KProperty1<T, R?>.spec(makePredicate: CriteriaBuilder.(path: Path<R>) -> Predicate): Specification<T> =
+    let { property -> where { root -> makePredicate(root.get(property)) } }
 
 // Equality
-fun <T, R> KProperty1<T, R?>.equal(x: R): Specifications<T> = spec { equal(it, x) }
-fun <T, R> KProperty1<T, R?>.notEqual(x: R): Specifications<T> = spec { notEqual(it, x) }
+fun <T, R> KProperty1<T, R?>.equal(x: R): Specification<T> = spec { equal(it, x) }
+
+fun <T, R> KProperty1<T, R?>.notEqual(x: R): Specification<T> = spec { notEqual(it, x) }
 
 // Ignores empty collection otherwise an empty 'in' predicate will be generated which will never match any results
-fun <T, R: Any> KProperty1<T, R?>.`in`(values: Collection<R>): Specifications<T> = if (values.isNotEmpty()) spec { path ->
+fun <T, R : Any> KProperty1<T, R?>.`in`(values: Collection<R>): Specification<T> = if (values.isNotEmpty()) spec { path ->
     `in`(path).apply { values.forEach { this.value(it) } }
-} else Specifications.where<T>(null)
+} else Specification.where(null)!!
 
 // Comparison
 fun <T> KProperty1<T, Number?>.le(x: Number) = spec { le(it, x) }
+
 fun <T> KProperty1<T, Number?>.lt(x: Number) = spec { lt(it, x) }
 fun <T> KProperty1<T, Number?>.ge(x: Number) = spec { ge(it, x) }
 fun <T> KProperty1<T, Number?>.gt(x: Number) = spec { gt(it, x) }
@@ -41,49 +42,58 @@ fun <T, R : Comparable<R>> KProperty1<T, R?>.between(x: R, y: R) = spec { betwee
 
 // True/False
 fun <T> KProperty1<T, Boolean?>.isTrue() = spec { isTrue(it) }
+
 fun <T> KProperty1<T, Boolean?>.isFalse() = spec { isFalse(it) }
 
 // Null / NotNull
 fun <T, R> KProperty1<T, R?>.isNull() = spec { isNull(it) }
+
 fun <T, R> KProperty1<T, R?>.isNotNull() = spec { isNotNull(it) }
 
 // Collections
 fun <T, R : Collection<*>> KProperty1<T, R?>.isEmpty() = spec { isEmpty(it) }
+
 fun <T, R : Collection<*>> KProperty1<T, R?>.isNotEmpty() = spec { isNotEmpty(it) }
 fun <T, E, R : Collection<E>> KProperty1<T, R?>.isMember(elem: E) = spec { isMember(elem, it) }
 fun <T, E, R : Collection<E>> KProperty1<T, R?>.isNotMember(elem: E) = spec { isNotMember(elem, it) }
 
 // Strings
-fun <T> KProperty1<T, String?>.like(x: String): Specifications<T> = spec { like(it, x) }
-fun <T> KProperty1<T, String?>.like(x: String, escapeChar: Char): Specifications<T> = spec { like(it, x, escapeChar) }
-fun <T> KProperty1<T, String?>.notLike(x: String): Specifications<T> = spec { notLike(it, x) }
-fun <T> KProperty1<T, String?>.notLike(x: String, escapeChar: Char): Specifications<T> = spec { notLike(it, x, escapeChar) }
+fun <T> KProperty1<T, String?>.like(x: String): Specification<T> = spec { like(it, x) }
+
+fun <T> KProperty1<T, String?>.like(x: String, escapeChar: Char): Specification<T> = spec { like(it, x, escapeChar) }
+fun <T> KProperty1<T, String?>.notLike(x: String): Specification<T> = spec { notLike(it, x) }
+fun <T> KProperty1<T, String?>.notLike(x: String, escapeChar: Char): Specification<T> = spec { notLike(it, x, escapeChar) }
 
 // And
-infix fun <T> Specifications<T>.and(other: Specification<T>): Specifications<T> = this.and(other)
-inline fun <reified T> and(vararg specs: Specifications<T>?): Specifications<T> {
+infix fun <T> Specification<T>.and(other: Specification<T>): Specification<T> = this.and(other)!!
+
+inline fun <reified T> and(vararg specs: Specification<T>?): Specification<T> {
     return and(specs.toList())
 }
-inline fun <reified T> and(specs: Iterable<Specifications<T>?>): Specifications<T> {
-    return combineSpecifications(specs, Specifications<T>::and)
+
+inline fun <reified T> and(specs: Iterable<Specification<T>?>): Specification<T> {
+    return combineSpecification(specs, Specification<T>::and)
 }
 
 // Or
-infix fun <T> Specifications<T>.or(other: Specification<T>) : Specifications<T> = this.or(other)
-inline fun <reified T> or(vararg specs: Specifications<T>?): Specifications<T> {
+infix fun <T> Specification<T>.or(other: Specification<T>): Specification<T> = this.or(other)!!
+
+inline fun <reified T> or(vararg specs: Specification<T>?): Specification<T> {
     return or(specs.toList())
 }
-inline fun <reified T> or(specs: Iterable<Specifications<T>?>): Specifications<T> {
-    return combineSpecifications(specs, Specifications<T>::or)
+
+inline fun <reified T> or(specs: Iterable<Specification<T>?>): Specification<T> {
+    return combineSpecification(specs, Specification<T>::or)
 }
 
 // Not
-operator fun <T> Specifications<T>.not(): Specifications<T> = Specifications.not(this)
+operator fun <T> Specification<T>.not(): Specification<T> = Specification.not(this)
 
-// Combines Specifications with an operation
-inline fun <reified T> combineSpecifications(specs: Iterable<Specification<T>?>, operation: Specifications<T>.(Specification<T>) -> Specifications<T>): Specifications<T> {
+// Combines Specification with an operation
+inline fun <reified T> combineSpecification(specs: Iterable<Specification<T>?>,
+    operation: Specification<T>.(Specification<T>) -> Specification<T>): Specification<T> {
     return specs.filterNotNull().fold(emptySpecification()) { existing, new -> existing.operation(new) }
 }
 
 // Empty Specification
-inline fun <reified T> emptySpecification(): Specifications<T> = Specifications.where<T>(null)
+inline fun <reified T> emptySpecification(): Specification<T> = Specification.where(null)!!