Version Bumps and auto discovering packages for schema creation

README.md

@@ -16,7 +16,7 @@ repositories {
 }
 
 dependencies {
-    compile('com.github.mduesterhoeft:spring-boot-starter-exposed:0.1.7')
+    compile('com.github.mduesterhoeft:spring-boot-starter-exposed:0.2.0')
 }
 ```
 
@@ -32,8 +32,15 @@ If you have the exposed module `org.jetbrains.exposed:spring-transaction` on the
 
 The starter can be used to initialize the database schema.
 
-To achieve this, a bean of type `com.github.mduesterhoeft.exposed.ExposedTables` is needed on the application context. This bean needs to contain all tables that should be created. The schema generation needs to be enabled like this:
+The schema generation needs to be enabled via application.properties:
 
 ```
 spring.exposed.generate-ddl=true
 ```
+
+Packages can be excluded from schema generation by supplying a comma seperated list in application.properties:
+
+```
+spring.exposed.excluded-packages=com.package.exclude,com.package.exclude2
+```
+

build.gradle

@@ -1,18 +1,18 @@
 buildscript {
-	ext {
-		kotlinVersion = '1.3.11'
-		springBootVersion = '2.1.1.RELEASE'
-	}
-	repositories {
-		mavenCentral()
-		maven { url "https://repo.spring.io/snapshot" }
-		maven { url "https://repo.spring.io/milestone" }
-	}
-	dependencies {
-		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
-		classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
-		classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
-	}
+    ext {
+        kotlinVersion = '1.3.31'
+        springBootVersion = '2.1.4.RELEASE'
+    }
+    repositories {
+        mavenCentral()
+        maven { url "https://repo.spring.io/snapshot" }
+        maven { url "https://repo.spring.io/milestone" }
+    }
+    dependencies {
+        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+        classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
+    }
 }
 
 apply plugin: 'maven'
@@ -25,49 +25,49 @@ group = 'com.md'
 sourceCompatibility = 1.8
 
 compileKotlin {
-	kotlinOptions {
-		freeCompilerArgs = ["-Xjsr305=strict"]
-		jvmTarget = "1.8"
-	}
+    kotlinOptions {
+        freeCompilerArgs = ["-Xjsr305=strict"]
+        jvmTarget = "1.8"
+    }
 }
 compileTestKotlin {
-	kotlinOptions {
-		freeCompilerArgs = ["-Xjsr305=strict"]
-		jvmTarget = "1.8"
-	}
+    kotlinOptions {
+        freeCompilerArgs = ["-Xjsr305=strict"]
+        jvmTarget = "1.8"
+    }
 }
 
 repositories {
-	mavenCentral()
+    mavenCentral()
     jcenter()
-	maven { url "https://repo.spring.io/snapshot" }
-	maven { url "https://repo.spring.io/milestone" }
-	maven { url  "https://dl.bintray.com/kotlin/exposed" }
+    maven { url "https://repo.spring.io/snapshot" }
+    maven { url "https://repo.spring.io/milestone" }
+    maven { url "https://dl.bintray.com/kotlin/exposed" }
 }
 
-ext['exposed.version'] = '0.11.2'
+ext['exposed.version'] = '0.13.7'
 
 dependencies {
-    compile("org.springframework.boot:spring-boot-starter:${project.ext.springBootVersion}")
-    compile("org.springframework.boot:spring-boot-starter-jdbc:${project.ext.springBootVersion}")
-    compile("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
-    compile("org.jetbrains.kotlin:kotlin-reflect")
-    compile("org.jetbrains.exposed:exposed:${project.ext['exposed.version']}")
-    compileOnly("org.jetbrains.exposed:spring-transaction:${project.ext['exposed.version']}")
+    implementation "org.springframework.boot:spring-boot-starter:${project.ext.springBootVersion}"
+    implementation "org.springframework.boot:spring-boot-starter-jdbc:${project.ext.springBootVersion}"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    implementation "org.jetbrains.kotlin:kotlin-reflect"
+    implementation "org.jetbrains.exposed:exposed:${project.ext['exposed.version']}"
+    compileOnly "org.jetbrains.exposed:spring-transaction:${project.ext['exposed.version']}"
 
-    testCompile("org.springframework.boot:spring-boot-starter-test:${project.ext.springBootVersion}")
-    testCompile("org.jetbrains.exposed:spring-transaction:${project.ext['exposed.version']}")
-    testCompile('org.amshove.kluent:kluent:1.35')
-    testRuntime('com.h2database:h2:1.4.197')
+    testCompile "org.springframework.boot:spring-boot-starter-test:${project.ext.springBootVersion}"
+    testCompile "org.jetbrains.exposed:spring-transaction:${project.ext['exposed.version']}"
+    testCompile 'org.amshove.kluent:kluent:1.49'
+    testRuntime 'com.h2database:h2:1.4.199'
 }
 
 task sourcesJar(type: Jar, dependsOn: classes) {
-	classifier = 'sources'
-	from sourceSets.main.allSource
+    archiveClassifier = 'sources'
+    from sourceSets.main.allSource
 }
 
 artifacts {
-	archives sourcesJar
+    archives sourcesJar
 }
 
 jacocoTestReport {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Tue Feb 06 12:27:20 CET 2018
+#Tue May 14 08:57:28 BST 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip

gradlew

@@ -28,16 +28,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"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn ( ) {
+warn () {
     echo "$*"
 }
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
@@ -155,7 +155,7 @@ if $cygwin ; then
 fi
 
 # Escape application args
-save ( ) {
+save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }

gradlew.bat

@@ -14,7 +14,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"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

src/main/kotlin/com/github/mduesterhoeft/exposed/DatabaseInitializer.kt

@@ -6,41 +6,69 @@ import org.jetbrains.exposed.sql.transactions.transaction
 import org.slf4j.LoggerFactory
 import org.springframework.boot.ApplicationArguments
 import org.springframework.boot.ApplicationRunner
+import org.springframework.boot.autoconfigure.AutoConfigurationPackages
+import org.springframework.context.ApplicationContext
+import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider
 import org.springframework.core.Ordered
+import org.springframework.core.type.filter.AssignableTypeFilter
+import org.springframework.core.type.filter.RegexPatternTypeFilter
 import org.springframework.transaction.annotation.Transactional
+import java.util.regex.Pattern
 
-
+@Deprecated("Annotation is no longer used", level = DeprecationLevel.ERROR)
 data class ExposedTables(val tables: List<Table>)
 
-interface DatabaseInitializer: ApplicationRunner, Ordered {
+interface DatabaseInitializer : ApplicationRunner, Ordered {
     override fun getOrder(): Int = DATABASE_INITIALIZER_ORDER
 
     companion object {
         const val DATABASE_INITIALIZER_ORDER = 0
     }
 }
 
-open class SimpleTransactionDatabaseInitializer(private val exposedTables: ExposedTables) : DatabaseInitializer {
+open class SimpleTransactionDatabaseInitializer(private val applicationContext: ApplicationContext, private val excludedPackages: List<String>) : DatabaseInitializer {
     private val log = LoggerFactory.getLogger(javaClass)
 
     override fun run(args: ApplicationArguments?) {
-        log.info("creating Schema for tables '{}'", exposedTables.tables.map { it.tableName })
+        val exposedTables = discoverExposedTables(applicationContext, excludedPackages)
+        log.info("creating Schema for tables '{}'", exposedTables.map { it.tableName })
         transaction {
-            log.info("ddl {}", exposedTables.tables.map { it.ddl }.joinToString())
-            SchemaUtils.create(*exposedTables.tables.toTypedArray())
+            log.info("ddl {}", exposedTables.map { it.ddl }.joinToString())
+            SchemaUtils.create(*exposedTables.toTypedArray())
         }
     }
 }
 
 @Transactional
-open class SpringTransactionDatabaseInitializer(private val exposedTables: ExposedTables): DatabaseInitializer {
+open class SpringTransactionDatabaseInitializer(private val applicationContext: ApplicationContext, private val excludedPackages: List<String>) : DatabaseInitializer {
     private val log = LoggerFactory.getLogger(javaClass)
 
     override fun run(args: ApplicationArguments?) {
-        log.info("creating Schema for tables '{}'", exposedTables.tables.map { it.tableName })
+        val exposedTables = discoverExposedTables(applicationContext, excludedPackages)
+        log.info("creating Schema for tables '{}'", exposedTables.map { it.tableName })
 
-        log.info("ddl {}", exposedTables.tables.map { it.ddl }.joinToString())
-        SchemaUtils.create(*exposedTables.tables.toTypedArray())
+        log.info("ddl {}", exposedTables.map { it.ddl }.joinToString())
+        SchemaUtils.create(*exposedTables.toTypedArray())
     }
 }
 
+/**
+ * Discovers any class that extends org.jetbrains.exposed.sql.Table unless package is excluded
+ */
+fun discoverExposedTables(applicationContext: ApplicationContext, excludedPackages: List<String>): List<Table> {
+    val provider = ClassPathScanningCandidateComponentProvider(false)
+    provider.addIncludeFilter(AssignableTypeFilter(Table::class.java))
+    excludedPackages
+            .forEach { pkg ->
+                provider
+                        .addExcludeFilter(RegexPatternTypeFilter(Pattern
+                                .compile(pkg.replace(".", "\\.") + ".*")))
+            }
+
+    val packages = AutoConfigurationPackages.get(applicationContext)
+
+    val components = packages.map { pkg -> provider.findCandidateComponents(pkg) }.flatten()
+
+    return components.map { component -> Class.forName(component.beanClassName).kotlin.objectInstance as Table }
+}
+

src/main/kotlin/com/github/mduesterhoeft/exposed/ExposedAutoConfiguration.kt

@@ -1,20 +1,25 @@
 package com.github.mduesterhoeft.exposed
 
 import org.jetbrains.exposed.sql.Database
+import org.springframework.beans.factory.annotation.Value
 import org.springframework.boot.autoconfigure.AutoConfigureAfter
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
+import org.springframework.context.ApplicationContext
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import javax.sql.DataSource
 
 
 @Configuration
 @AutoConfigureAfter(DataSourceAutoConfiguration::class)
-class ExposedAutoConfiguration {
+class ExposedAutoConfiguration(private val applicationContext: ApplicationContext) {
+
+    @Value("\${spring.exposed.excluded-packages:}#{T(java.util.Collections).emptyList()}")
+    private lateinit var excludedPackages: List<String>
 
     @Bean
     @ConditionalOnBean(DataSource::class)
@@ -24,10 +29,9 @@ class ExposedAutoConfiguration {
 
     @Bean
     @ConditionalOnMissingBean(DatabaseInitializer::class)
-    @ConditionalOnBean(ExposedTables::class)
     @ConditionalOnProperty("spring.exposed.generate-ddl", havingValue = "true", matchIfMissing = false)
     @ConditionalOnMissingClass("org.jetbrains.exposed.spring.SpringTransactionManager")
-    fun databaseInitializer(exposedTables: ExposedTables): DatabaseInitializer {
-        return SimpleTransactionDatabaseInitializer(exposedTables)
+    fun databaseInitializer(): DatabaseInitializer {
+        return SimpleTransactionDatabaseInitializer(this.applicationContext, excludedPackages)
     }
-}
+}

src/main/kotlin/com/github/mduesterhoeft/exposed/ExposedProperties.kt

@@ -4,4 +4,4 @@ import org.springframework.boot.context.properties.ConfigurationProperties
 
 
 @ConfigurationProperties(prefix = "spring.exposed")
-data class ExposedProperties(var generateDdl: Boolean)
+data class ExposedProperties(val generateDdl: Boolean, val excludedPackages: List<String>)

src/main/kotlin/com/github/mduesterhoeft/exposed/SpringTransactionExposedAutoConfiguration.kt

@@ -1,29 +1,32 @@
 package com.github.mduesterhoeft.exposed
 
 import org.jetbrains.exposed.spring.SpringTransactionManager
-import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
+import org.springframework.beans.factory.annotation.Value
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import org.springframework.context.ApplicationContext
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import javax.sql.DataSource
 
 
 @Configuration
 @ConditionalOnClass(SpringTransactionManager::class)
-class SpringTransactionExposedAutoConfiguration {
+class SpringTransactionExposedAutoConfiguration(private val applicationContext: ApplicationContext) {
+
+    @Value("\${spring.exposed.excluded-packages:}#{T(java.util.Collections).emptyList()}")
+    private lateinit var excludedPackages: List<String>
 
     @Bean
     fun springExposedTransactionManager(dataSource: DataSource): SpringTransactionManager {
         return SpringTransactionManager(dataSource)
     }
 
     @Bean
-    @ConditionalOnMissingBean(com.github.mduesterhoeft.exposed.DatabaseInitializer::class)
-    @ConditionalOnBean(com.github.mduesterhoeft.exposed.ExposedTables::class)
+    @ConditionalOnMissingBean(DatabaseInitializer::class)
     @ConditionalOnProperty("spring.exposed.generate-ddl", havingValue = "true", matchIfMissing = false)
-    fun databaseInitializer(exposedTables: com.github.mduesterhoeft.exposed.ExposedTables): com.github.mduesterhoeft.exposed.DatabaseInitializer {
-        return com.github.mduesterhoeft.exposed.SpringTransactionDatabaseInitializer(exposedTables)
+    fun databaseInitializer(): DatabaseInitializer {
+        return SpringTransactionDatabaseInitializer(this.applicationContext, this.excludedPackages)
     }
 }

src/test/kotlin/com/github/mduesterhoeft/exposed/Application.kt

@@ -7,5 +7,5 @@ import org.springframework.boot.runApplication
 class Application
 
 fun main(args: Array<String>) {
-    runApplication<com.github.mduesterhoeft.exposed.Application>(*args)
+    runApplication<Application>(*args)
 }