WIP

.editorconfig

@@ -1,18 +0,0 @@
-# editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.{kt, kts}]
-indent_size = 4
-insert_final_newline = true
-continuation_indent_size=4
-max_line_length = 120
-disabled_rules = no-wildcard-imports
-kotlin_imports_layout = idea

.gitignore

@@ -38,5 +38,4 @@ node_modules/
 .yarn/install-state.gz
 .yarn-integrity
 yarn-debug.log*
-yarn-error.log*
+yarn-error.log*
-*.zip

Dockerfile

@@ -1,25 +0,0 @@
-FROM openjdk:14-alpine as jdkbuilder
-RUN apk add --no-cache binutils
-ENV MODULES java.base,java.xml,jdk.httpserver
-RUN jlink --output /myjdk --module-path $JAVA_HOME/jmods --add-modules $MODULES --no-header-files --no-man-pages --strip-debug --compress=2
-RUN strip -p --strip-unneeded /myjdk/lib/server/libjvm.so
-
-FROM maven:3.6.3-jdk-14 as builder
-WORKDIR /app
-COPY pom.xml .
-RUN mvn verify clean --fail-never
-COPY src/main src/main
-RUN mvn package
-
-FROM alpine
-ENV APPLICATION_USER app
-RUN adduser -D -g '' $APPLICATION_USER
-RUN mkdir /app
-RUN chown -R $APPLICATION_USER /app
-USER $APPLICATION_USER
-COPY --from=builder /app/target/kotlin-starter*.jar /app/app.jar
-COPY --from=jdkbuilder /myjdk /myjdk
-COPY config.toml /app/config.toml
-WORKDIR /app
-EXPOSE 7000
-CMD ["/myjdk/bin/java", "-server", "-Xmx64m", "-XX:+UseG1GC", "-XX:+UseStringDeduplication", "-jar", "app.jar"]

config.toml

@@ -16,128 +16,92 @@ display = "Java Version"
 default = "1.4.10"
 display = "Kotlin Version"
 
-[features]
-
-[features.ktlint]
-default = true
-
-[versions]
-http4k = "3.265.0"
-pebble = "3.1.4"
-caffeine = "2.8.5"
-logback = "1.2.3"
-mariadb = "2.6.2"
-h2 = "1.4.200"
-flyway = "7.0.0"
-hikaricp = "3.4.5"
-ktorm = "3.0.0"
-junit = "5.7.0"
-mockk = "1.10.0"
-hamkrest = "1.7.0.3"
-assertj = "3.17.2"
-kodein-di = "7.1.0"
-koin = "2.1.6"
-jackson = "2.11.2"
-kotlinx-serialization = "1.0-M1-1.4.0-rc"
-arrow-core = "0.10.5"
-
-[repositories]
-
-[repositories.jcenter]
-url = "https://jcenter.bintray.com"
-
-[repositories.arrow]
-url = "https://dl.bintray.com/arrow-kt/arrow-kt/"
-
 [dependencies]
 
 [dependencies.http4k]
 groupId = "org.http4k"
 artifactId = "http4k-core"
-category = "http4k"
+version = "3.260.0"
+category = "server"
 default = true
 
 [dependencies.http4k-server-jetty]
 groupId = "org.http4k"
-version = "http4k"
+artifactId = "http4k-server-jetty"
-category = "http4k"
+version = "3.260.0"
+category = "server"
 default = true
-logger = "org.eclipse.jetty"
 
 [dependencies.http4k-server-apache]
 groupId = "org.http4k"
-version = "http4k"
+artifactId = "http4k-server-apache"
-category = "http4k"
+version = "3.260.0"
+category = "server"
 
 [dependencies.http4k-client-apache]
 groupId = "org.http4k"
-version = "http4k"
+artifactId = "http4k-server-apache"
-category = "http4k"
+version = "3.260.0"
+category = "server"
 
-[dependencies.http4k-format-jackson]
+[dependencies.javalin]
-groupId = "org.http4k"
+groupId = "io.javalin"
-version = "http4k"
+artifactId = "javalin"
-category = "http4k"
+version = "3.10.1"
-
+category = "server"
-[dependencies.http4k-format-kotlinx-serialization]
-groupId = "org.http4k"
-version = "http4k"
-category = "http4k"
-
-[dependencies.http4k-contract]
-groupId = "org.http4k"
-version = "http4k"
-category = "http4k"
 
 [dependencies.pebble]
 groupId = "io.pebbletemplates"
+artifactId = "pebble"
+version = "3.1.4"
 default = true
-logger = "com.mitchellbosecke.pebble"
-
-[dependencies.caffeine]
-groupId = "com.github.ben-manes.caffeine"
 
 [dependencies.logback]
 groupId = "ch.qos.logback"
 artifactId = "logback-classic"
+version = "1.2.3"
 default = true
 
 [dependencies.mariadb]
 groupId = "org.mariadb.jdbc"
 artifactId = "mariadb-java-client"
+version = "2.6.2"
 category = "database"
 
 [dependencies.h2]
 groupId = "com.h2database"
+artifactId = "h2"
+version = "1.4.200"
 category = "database"
 
 [dependencies.flyway]
 groupId = "org.flywaydb"
 artifactId = "flyway-core"
+version = "6.5.4"
 category = "database"
-logger = "org.flywaydb.core"
 
-[dependencies.hikaricp]
+[dependencies.HikariCP]
 groupId = "com.zaxxer"
 artifactId = "HikariCP"
+version = "3.4.5"
 category = "database"
-logger = "com.zaxxer.hikari"
 
-[dependencies.ktorm]
+[dependencies.Ktorm]
 groupId = "me.liuwj.ktorm"
 artifactId = "ktorm-core"
+version = "3.0.0"
 category = "database"
-logger = "me.liuwj.ktorm.database"
 
-[dependencies.ktorm-mysql]
+[dependencies.Ktorm-Mysql]
 groupId = "me.liuwj.ktorm"
 artifactId = "ktorm-support-mysql"
-version = "ktorm"
+version = "3.0.0"
 category = "database"
 
 [dependencies.junit]
 groupId = "org.junit.jupiter"
 artifactId = "junit-jupiter"
+version = "5.6.2"
 scope = "test"
 category = "test"
 default = true
@@ -145,52 +109,42 @@ default = true
 [dependencies.junit-params]
 groupId = "org.junit.jupiter"
 artifactId = "junit-jupiter-params"
-version = "junit"
+version = "5.6.2"
 scope = "test"
 category = "test"
 default = true
 
-[dependencies.mockk]
+[dependencies.mokk]
 groupId = "io.mockk"
 artifactId = "mockk"
+version = "1.10.0"
 scope = "test"
 category = "test"
 
 [dependencies.hamkrest]
 groupId = "com.natpryce"
+artifactId = "hamkrest"
+version = "1.7.0.3"
 scope = "test"
 category = "test"
 
-[dependencies.assertj]
+[dependencies.assertJ]
 groupId = "org.assertj"
 artifactId = "assertj-core"
+version = "3.16.1"
 scope = "test"
 category = "test"
 default = true
 
-[dependencies.kodein-di]
+[dependencies.Kodein-DI]
 groupId = "org.kodein.di"
 artifactId = "kodein-di-jvm"
+version = "7.0.0"
 category = "injection"
-repository = "jcenter"
 
-[dependencies.koin]
+[dependencies.Koin]
 groupId = "org.koin"
 artifactId = "koin-core"
+version = "2.1.6"
 category = "injection"
-repository = "jcenter"
+default = true
-default = true
-
-[dependencies.jackson]
-groupId = "com.fasterxml.jackson.module"
-artifactId = "jackson-module-kotlin"
-category = "serialization"
-
-[dependencies.kotlinx-serialization]
-groupId = "org.jetbrains.kotlinx"
-artifactId = "kotlinx-serialization-runtime"
-category = "serialization"
-
-[dependencies.arrow-core]
-groupId = "io.arrow-kt"
-repository = "arrow"

pom.xml

@@ -6,11 +6,10 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.target>14</maven.compiler.target>
+        <maven.compiler.target>11</maven.compiler.target>
-        <maven.compiler.source>14</maven.compiler.source>
+        <maven.compiler.source>11</maven.compiler.source>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <kotlin.version>1.4.10</kotlin.version>
-        <kotlin.code.style>official</kotlin.code.style>
     </properties>
 
     <repositories>
@@ -27,6 +26,11 @@
             <artifactId>pebble</artifactId>
             <version>3.1.4</version>
         </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>1.2.3</version>
+        </dependency>
         <dependency>
             <groupId>com.electronwill.night-config</groupId>
             <artifactId>toml</artifactId>
@@ -38,9 +42,9 @@
             <version>${kotlin.version}</version>
         </dependency>
         <dependency>
-            <groupId>org.http4k</groupId>
+            <groupId>io.javalin</groupId>
-            <artifactId>http4k-core</artifactId>
+            <artifactId>javalin</artifactId>
-            <version>3.265.0</version>
+            <version>3.10.1</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
@@ -52,30 +56,6 @@
             <artifactId>koin-core</artifactId>
             <version>2.1.6</version>
         </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-simple</artifactId>
-            <version>1.7.30</version>
-        </dependency>
-
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <version>5.7.0</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-params</artifactId>
-            <version>5.7.0</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <version>3.17.2</version>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
     <build>
@@ -94,35 +74,13 @@
                             <goal>shade</goal>
                         </goals>
                         <configuration>
-                            <minimizeJar>true</minimizeJar>
+                            <minimizeJar>false</minimizeJar>
                             <transformers>
                                 <transformer
                                         implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                     <mainClass>starter.KotlinStarterKt</mainClass>
                                 </transformer>
                             </transformers>
-                            <filters>
-                                <filter>
-                                    <artifact>com.electronwill.night-config:*</artifact>
-                                    <includes>
-                                        <include>**</include>
-                                    </includes>
-                                </filter>
-                                <filter>
-                                    <artifact>*:*</artifact>
-                                    <excludes>
-                                        <exclude>META-INF/maven/**</exclude>
-                                        <exclude>META-INF/proguard/**</exclude>
-                                        <exclude>META-INF/*.kotlin_module</exclude>
-                                        <exclude>META-INF/DEPENDENCIES*</exclude>
-                                        <exclude>META-INF/NOTICE*</exclude>
-                                        <exclude>META-INF/LICENSE*</exclude>
-                                        <exclude>LICENSE*</exclude>
-                                        <exclude>META-INF/README*</exclude>
-                                        <exclude>META-INF/native-image/**</exclude>
-                                    </excludes>
-                                </filter>
-                            </filters>
                         </configuration>
                     </execution>
                 </executions>
@@ -148,7 +106,7 @@
                     </execution>
                 </executions>
                 <configuration>
-                    <jvmTarget>14</jvmTarget>
+                    <jvmTarget>11</jvmTarget>
                 </configuration>
             </plugin>
             <plugin>
@@ -156,51 +114,7 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.8.1</version>
             </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-antrun-plugin</artifactId>
-                <version>1.7</version>
-                <executions>
-                    <execution>
-                        <id>ktlint</id>
-                        <phase>verify</phase>
-                        <configuration>
-                            <target name="ktlint">
-                                <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
-                                      classname="com.pinterest.ktlint.Main" classpathref="maven.plugin.classpath">
-                                    <arg value="src/**/*.kt"/>
-                                </java>
-                            </target>
-                        </configuration>
-                        <goals>
-                            <goal>run</goal>
-                        </goals>
-                    </execution>
-                    <execution>
-                        <id>ktlint-format</id>
-                        <configuration>
-                            <target name="ktlint">
-                                <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
-                                      classname="com.pinterest.ktlint.Main" classpathref="maven.plugin.classpath">
-                                    <arg value="-F"/>
-                                    <arg value="src/**/*.kt"/>
-                                </java>
-                            </target>
-                        </configuration>
-                        <goals>
-                            <goal>run</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <dependencies>
-                    <dependency>
-                        <groupId>com.pinterest</groupId>
-                        <artifactId>ktlint</artifactId>
-                        <version>0.39.0</version>
-                    </dependency>
-                </dependencies>
-            </plugin>
         </plugins>
     </build>
 
-</project>
+</project>

src/css/tailwind.config.js

@@ -1,8 +1,7 @@
 module.exports = {
     purge: {
         content: [
-            '../main/resources/views/**/*.twig',
+            '../main/resources/views/**/*.twig'
-            '../main/kotlin/starter/PebbleModule.kt',
         ]
     },
     theme: {},

src/main/kotlin/starter/Config.kt

@@ -0,0 +1,35 @@
+package starter
+
+import com.electronwill.nightconfig.core.file.FileConfig
+import com.electronwill.nightconfig.core.Config as NightConfig
+
+data class StarterConfig(val dependencies: List<Dependency>, val inputs: List<Input>)
+
+class Config {
+    fun load(): StarterConfig {
+        val cfg = FileConfig.of("config.toml")
+        cfg.load()
+        val dependenciesNode: NightConfig = cfg["dependencies"]
+        @Suppress("UNCHECKED_CAST") val dependenciesMap = dependenciesNode.valueMap() as Map<String, NightConfig>
+        val dependencies = dependenciesMap.map { (name, values) ->
+            Dependency(
+                    name,
+                    values["groupId"],
+                    values["artifactId"],
+                    values["version"],
+                    values.getOrElse("default", false),
+                    values.getEnumOrElse("category", Category.Other),
+                    values.getEnumOrElse("scope", Scope.Compile),
+            )
+        }
+
+        val inputsNode: NightConfig = cfg["inputs"]
+        @Suppress("UNCHECKED_CAST") val inputMap = inputsNode.valueMap() as Map<String, NightConfig>
+        val inputs = inputMap.map { (name, values) ->
+            Input(name, values["display"], values["default"])
+        }
+
+        return StarterConfig(dependencies, inputs)
+    }
+
+}

src/main/kotlin/starter/KotlinStarter.kt

@@ -1,12 +1,21 @@
 package starter
 
 import org.koin.core.context.startKoin
-import org.koin.core.context.unloadKoinModules
+import org.koin.dsl.module
-import starter.modules.*
+
+val module = module {
+    single { Config().load() }
+    single { PebbleModule().engine() }
+    single { Server(get(), get(), get()) }
+    single { Templates(get()) }
+    single { Views(get()) }
+    single { ProjectZip(get()) }
+}
 
 fun main() {
-    startKoin {
+    val koin = startKoin {
-        modules(mainModule, pebbleModule, templateModule, configModule, routesModule)
+        modules(module)
-    }
+    }.koin
-    unloadKoinModules(configModule)
+    val server = koin.get<Server>()
+    server.run()
 }

src/main/kotlin/starter/Models.kt

@@ -1,7 +1,7 @@
 package starter
 
 enum class Category {
-    Http4k, Injection, Database, Serialization, Test, Other
+    Server, Injection, Database, Test, Other
 }
 
 enum class Scope {
@@ -9,30 +9,15 @@ enum class Scope {
 }
 
 data class Dependency(
-    val name: String,
+        val name: String,
-    val groupId: String,
+        val groupId: String,
-    val artifactId: String,
+        val artifactId: String,
-    val version: Version,
+        val version: String,
-    val default: Boolean,
+        val default: Boolean,
-    val category: Category,
+        val category: Category,
-    val scope: Scope,
+        val scope: Scope
-    val logger: String?,
-    val repository: Repository?,
 )
 
-data class Repository(val name: String, val url: String)
-
 data class Input(val name: String, val display: String, val value: String? = null)
 
-data class Feature(val name: String, val value: Boolean = false)
+data class Project(val name: String, val basePackage: String)
-
-data class Project(
-    val name: String,
-    val basePackage: String,
-    val inputs: List<Input>,
-    val features: List<Feature>,
-    val dependencies: List<Dependency>,
-    val repositories: Set<Repository>,
-)
-
-data class Version(val name: String, val value: String)

src/main/kotlin/starter/PebbleModule.kt

@@ -0,0 +1,15 @@
+package starter
+
+import com.mitchellbosecke.pebble.PebbleEngine
+import com.mitchellbosecke.pebble.loader.ClasspathLoader
+
+class PebbleModule {
+    fun engine(): PebbleEngine {
+        val loader = ClasspathLoader()
+        loader.suffix = ".twig"
+        return PebbleEngine.Builder()
+                .loader(loader)
+                .cacheActive(false)
+                .build()
+    }
+}

src/main/kotlin/starter/ProjectZip.kt

@@ -1,20 +1,23 @@
 package starter
 
-import starter.templates.Template
 import starter.utils.ZipOutput
+import starter.utils.prettyPrintXml
 import starter.utils.sanitizeFilename
-import java.io.ByteArrayOutputStream
 
-class ProjectZip(private val templates: List<Template>) {
+class ProjectZip(private val templates: Templates) {
 
-    fun createZip(project: Project): ByteArrayOutputStream {
+    fun createZip(project: Project, inputs: List<Input>, dependencies: List<Dependency>): String {
-        val projectName = sanitizeFilename(project.name)
+        val pom = templates.pom(dependencies, inputs)
-        val zipOutput = ZipOutput()
+        val prettyPom = prettyPrintXml(pom)
-        zipOutput.use { zip ->
+
-            templates.filter { it.enabled(project) }.forEach { template ->
+        val name: String
-                zip.write(projectName + "/" + template.path(project), template.render(project))
+
-            }
+        ZipOutput(sanitizeFilename(project.name)).use {
+            name = it.name
+            it.write("pom.xml", prettyPom)
         }
-        return zipOutput.outputStream
+
+        return name
     }
-}
+
+}

src/main/kotlin/starter/Server.kt

@@ -0,0 +1,46 @@
+package starter
+
+import io.javalin.Javalin
+import starter.utils.sanitizeFilename
+import java.io.File
+
+class Server(
+        private val views: Views,
+        private val conf: StarterConfig,
+        private val projectZip: ProjectZip,
+) {
+    fun run() {
+        val app = Javalin.create {
+            it.addStaticFiles("/assets")
+        }.start(7000)
+
+        app.get("/") { ctx ->
+            ctx.result(views.index(conf.dependencies, conf.inputs))
+            ctx.contentType("text/html")
+        }
+
+        app.post("/") { ctx ->
+            val deps = conf.dependencies.filter {
+                ctx.formParam(it.name) != null
+            }
+
+            val inputKeys = conf.inputs.map { it.name }
+            val inputs = ctx.formParamMap()
+                    .filter { it.key in inputKeys }
+                    .map { (name, value) ->
+                        conf.inputs.find { it.name == name }!!.copy(value = value.first())
+                    }
+
+            val projectName = inputs.find { it.name == "name" }!!.value!!
+            val basePackage = inputs.find { it.name == "basePackage" }!!.value!!
+            val project = Project(projectName, basePackage)
+
+
+            ctx.contentType("text/xml")
+            ctx.header("Content-Disposition", "attachment; filename=\"${sanitizeFilename(projectName)}.zip\"")
+            val zipFile = projectZip.createZip(project, inputs, deps)
+            ctx.result(File(zipFile).readBytes())
+        }
+    }
+
+}

src/main/kotlin/starter/Templates.kt

@@ -0,0 +1,25 @@
+package starter
+
+import com.mitchellbosecke.pebble.PebbleEngine
+import starter.utils.render
+
+class Templates(private val engine: PebbleEngine) {
+    fun pom(dependencies: List<Dependency>, inputs: List<Input>): String {
+
+        val args: MutableMap<String, Any?> = mutableMapOf(
+                "dependencies" to dependencies.sortedBy { it.scope },
+        )
+
+        inputs.forEach {
+            args[it.name] = it.value
+        }
+
+        return engine.render("starter/pom",
+                args
+        )
+    }
+
+    fun main(basePackage: String) {
+        
+    }
+}

src/main/kotlin/starter/Views.kt

@@ -0,0 +1,17 @@
+package starter
+
+import com.mitchellbosecke.pebble.PebbleEngine
+import org.slf4j.LoggerFactory
+import starter.utils.render
+
+class Views(private val engine: PebbleEngine) {
+    private val logger = LoggerFactory.getLogger(javaClass)
+
+    fun index(dependencies: List<Dependency>, inputs: List<Input>): String {
+        val dependenciesByCategory = dependencies.groupBy { it.category }.toSortedMap()
+        return engine.render("views/index",
+                mapOf("dependencies" to dependenciesByCategory, "inputs" to inputs)
+        )
+    }
+
+}

src/main/kotlin/starter/config/Config.kt

@@ -1,65 +0,0 @@
-package starter.config
-
-import com.electronwill.nightconfig.core.UnmodifiableConfig
-import starter.*
-import com.electronwill.nightconfig.core.Config as NightConfig
-
-data class StarterConfig(
-    val dependencies: List<Dependency>,
-    val inputs: List<Input>,
-    val features: List<Feature>,
-)
-
-class Config(private val cfg: NightConfig) {
-
-    @Suppress("UNCHECKED_CAST")
-    private fun NightConfig.configMap(key: String) = this.get<NightConfig>(key)
-        ?.valueMap() as Map<String, NightConfig>?
-        ?: emptyMap()
-
-    fun load(): StarterConfig {
-
-        @Suppress("UNCHECKED_CAST")
-        val versions = cfg.get<UnmodifiableConfig>("versions")
-            ?.valueMap() as Map<String, String>?
-            ?: emptyMap()
-
-        val repositories = cfg.configMap("repositories")
-            .map { (name, values) ->
-                Repository(name, values["url"])
-            }
-
-        val dependencies = cfg.configMap("dependencies")
-            .map { (name, values) ->
-                val versionKey: String = values["version"] ?: name
-                val version = versions[versionKey] ?: error("Missing version for $name")
-
-                val repositoryName: String? = values["repository"]
-                val repo = repositoryName?.let { repoName -> repositories.find { it.name == repoName } }
-
-                Dependency(
-                    name = name,
-                    groupId = values["groupId"],
-                    artifactId = values["artifactId"] ?: name,
-                    version = Version(versionKey, version),
-                    default = values.getOrElse("default", false),
-                    category = values.getEnumOrElse("category", Category.Other),
-                    scope = values.getEnumOrElse("scope", Scope.Compile),
-                    logger = values["logger"],
-                    repository = repo,
-                )
-            }
-
-        val inputs = cfg.configMap("inputs")
-            .map { (name, values) ->
-                Input(name, values["display"], values["default"])
-            }
-
-        val features = cfg.configMap("features")
-            .map { (name, values) ->
-                Feature(name, values["default"] ?: false)
-            }
-
-        return StarterConfig(dependencies, inputs, features)
-    }
-}

src/main/kotlin/starter/extensions/Http4kExtensions.kt

@@ -1,17 +0,0 @@
-@file:Suppress("NOTHING_TO_INLINE")
-
-package starter.extensions
-
-import org.http4k.core.Response
-import org.http4k.core.Status
-import starter.utils.sanitizeFilename
-import java.io.InputStream
-
-inline fun Response.Companion.ok() = Response(Status.OK)
-inline fun Response.Companion.badRequest() = Response(Status.BAD_REQUEST)
-
-fun attachment(value: InputStream, name: String, contentType: String) = { res: Response ->
-    res.header("Content-Type", contentType)
-        .header("Content-Disposition", "attachment; filename=\"${sanitizeFilename(name)}\"")
-        .body(value)
-}

src/main/kotlin/starter/modules/ConfigModule.kt

@@ -1,11 +0,0 @@
-package starter.modules
-
-import com.electronwill.nightconfig.core.file.FileConfig
-import org.koin.dsl.module
-import starter.config.Config
-import com.electronwill.nightconfig.core.Config as NightConfig
-
-val configModule = module {
-    single<NightConfig> { FileConfig.of("config.toml").apply { load() } }
-    single { Config(get()).load() }
-}

src/main/kotlin/starter/modules/MainModule.kt

@@ -1,22 +0,0 @@
-package starter.modules
-
-import org.http4k.routing.RoutingHttpHandler
-import org.http4k.server.SunHttp
-import org.http4k.server.asServer
-import org.koin.dsl.module
-import org.koin.dsl.onClose
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
-import starter.ProjectZip
-import starter.views.Views
-
-val mainModule = module {
-    single(createdAtStart = true) {
-        get<Logger>().info("Starting on http://localhost:7000")
-        get<RoutingHttpHandler>().asServer(SunHttp(7000)).start()
-    } onClose { it?.stop() }
-
-    single { LoggerFactory.getLogger("Starter") }
-    single { Views(get(), get()) }
-    single { ProjectZip(getAll()) }
-}

src/main/kotlin/starter/modules/PebbleModule.kt

@@ -1,24 +0,0 @@
-package starter.modules
-
-import org.koin.dsl.bind
-import org.koin.dsl.module
-import starter.pebble.DepAsXmlPebbleFunction
-import starter.pebble.HasFeatureFilter
-import starter.utils.PebbleEngineBuilder
-import starter.utils.PebbleEngineBuilder.CacheType.ConcurrentMap
-import starter.utils.PebbleFilter
-import starter.utils.PebbleFunction
-
-val pebbleModule = module {
-    single { DepAsXmlPebbleFunction() } bind PebbleFunction::class
-    single { HasFeatureFilter() } bind PebbleFilter::class
-
-    single {
-        PebbleEngineBuilder {
-            cache = ConcurrentMap
-            functions(getAll())
-            filters(getAll())
-            classPath { suffix = ".twig" }
-        }
-    }
-}

src/main/kotlin/starter/modules/RoutesModule.kt

@@ -1,29 +0,0 @@
-package starter.modules
-
-import org.http4k.core.then
-import org.http4k.filter.ServerFilters
-import org.http4k.routing.ResourceLoader
-import org.http4k.routing.routes
-import org.http4k.routing.static
-import org.koin.dsl.bind
-import org.koin.dsl.module
-import starter.routes.IndexRouteSupplier
-import starter.routes.RouteSupplier
-import starter.routes.ZipRouteSupplier
-import starter.routes.toRouter
-import starter.utils.ProjectExtractor
-import starter.utils.ProjectExtractorImpl
-
-val routesModule = module {
-    single { IndexRouteSupplier(get()) } bind RouteSupplier::class
-    single { ZipRouteSupplier(get(), get()) } bind RouteSupplier::class
-    single<ProjectExtractor> { ProjectExtractorImpl(get()) }
-    single {
-        ServerFilters.CatchAll().then(
-            routes(
-                static(ResourceLoader.Classpath("/assets")),
-                getAll<RouteSupplier>().toRouter()
-            )
-        )
-    }
-}

src/main/kotlin/starter/modules/TemplateModule.kt

@@ -1,14 +0,0 @@
-package starter.modules
-
-import org.koin.dsl.bind
-import org.koin.dsl.module
-import starter.templates.*
-
-val templateModule = module {
-    single { PomTemplate(get()) } bind Template::class
-    single { MainTemplate(get()) } bind Template::class
-    single { LogbackTemplate(get()) } bind Template::class
-    single { GitignoreTemplate(get()) } bind Template::class
-    single { JunitTemplate(get()) } bind Template::class
-    single { EditorConfigTemplate(get()) } bind Template::class
-}

src/main/kotlin/starter/pebble/DepAsXmlPebbleFunction.kt

@@ -1,51 +0,0 @@
-package starter.pebble
-
-import com.mitchellbosecke.pebble.extension.escaper.SafeString
-import com.mitchellbosecke.pebble.template.EvaluationContext
-import com.mitchellbosecke.pebble.template.PebbleTemplate
-import org.intellij.lang.annotations.Language
-import starter.Dependency
-import starter.utils.PebbleFunction
-
-// We need a custom function since pebble inserts whitespace everywhere
-class DepAsXmlPebbleFunction : PebbleFunction {
-    override val name = "depAsXml"
-    override fun getArgumentNames() = listOf("dependency")
-
-    override fun execute(
-        args: Map<String, Any>,
-        self: PebbleTemplate,
-        context: EvaluationContext,
-        lineNumber: Int,
-    ): SafeString {
-        val dep = args["dependency"] as Dependency
-
-        fun tagName(name: String) = """<span class="text-red-700">$name</span>"""
-
-        fun startTag(name: String): String {
-            @Language("html") @Suppress("UnnecessaryVariable")
-            val result = """<span class="text-gray-700">&lt;</span>""" +
-                """${tagName(name)}<span class="text-gray-700">&gt;</span>"""
-            return result
-        }
-
-        fun endTag(name: String): String {
-            @Language("html") @Suppress("UnnecessaryVariable")
-            val result = """<span class="text-gray-700">&lt;/</span>""" +
-                """${tagName(name)}<span class="text-gray-700">&gt;</span>"""
-            return result
-        }
-
-        fun tag(name: String, content: String) = """${startTag(name)}$content${endTag(name)}"""
-
-        val result = """
-            |${startTag("dependency")}
-            |   ${tag("groupId", dep.groupId)}
-            |   ${tag("artifactId", dep.artifactId)}
-            |   ${tag("version", dep.version.value)}
-            |${endTag("dependency")}
-        """.trimMargin()
-
-        return SafeString(result)
-    }
-}

src/main/kotlin/starter/pebble/HasFeatureFilter.kt

@@ -1,27 +0,0 @@
-package starter.pebble
-
-import com.mitchellbosecke.pebble.template.EvaluationContext
-import com.mitchellbosecke.pebble.template.PebbleTemplate
-import starter.Feature
-import starter.utils.PebbleFilter
-
-class HasFeatureFilter : PebbleFilter {
-    override val name = "hasFeature"
-
-    override fun getArgumentNames() = listOf("name")
-
-    override fun apply(
-        input: Any,
-        args: MutableMap<String, Any>,
-        self: PebbleTemplate,
-        context: EvaluationContext,
-        lineNumber: Int,
-    ): Boolean {
-        @Suppress("UNCHECKED_CAST")
-        val features = input as List<Feature>
-
-        val name = args["name"] as String
-
-        return features.any { it.name == name }
-    }
-}

src/main/kotlin/starter/routes/IndexRouteSupplier.kt

@@ -1,15 +0,0 @@
-package starter.routes
-
-import org.http4k.core.Method
-import org.http4k.core.Response
-import org.http4k.core.Status
-import org.http4k.routing.bind
-import starter.views.Views
-
-class IndexRouteSupplier(private val views: Views) : RouteSupplier {
-    override fun get() = "/" bind Method.GET to {
-        Response(Status.OK)
-            .body(views.index())
-            .header("Content-Type", "text/html")
-    }
-}

src/main/kotlin/starter/routes/RouteSupplier.kt

@@ -1,10 +0,0 @@
-package starter.routes
-
-import org.http4k.routing.RoutingHttpHandler
-import org.http4k.routing.routes
-
-interface RouteSupplier {
-    fun get(): RoutingHttpHandler
-}
-
-fun List<RouteSupplier>.toRouter() = routes(*map { it.get() }.toTypedArray())

src/main/kotlin/starter/routes/ZipRouteSupplier.kt

@@ -1,35 +0,0 @@
-package starter.routes
-
-import org.http4k.core.Method
-import org.http4k.core.Request
-import org.http4k.core.Response
-import org.http4k.core.with
-import org.http4k.routing.bind
-import starter.ProjectZip
-import starter.extensions.attachment
-import starter.extensions.badRequest
-import starter.extensions.ok
-import starter.utils.ProjectExtractor
-import java.io.ByteArrayInputStream
-
-class ZipRouteSupplier(
-    private val projectExtractor: ProjectExtractor,
-    private val projectZip: ProjectZip,
-) : RouteSupplier {
-
-    private fun handle(req: Request): Response {
-        val project = projectExtractor(req) ?: return Response.badRequest()
-
-        val outputStream = projectZip.createZip(project)
-
-        return Response.ok().with(
-            attachment(
-                value = ByteArrayInputStream(outputStream.toByteArray()),
-                name = "${project.name}.zip",
-                contentType = "application/zip"
-            )
-        )
-    }
-
-    override fun get() = "/" bind Method.POST to ::handle
-}

src/main/kotlin/starter/templates/EditorConfigTemplate.kt

@@ -1,15 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.render
-
-class EditorConfigTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) =
-        ".editorconfig"
-
-    override fun enabled(project: Project) = project.features.any { it.name == "ktlint" }
-
-    override fun render(project: Project) =
-        engine.render("starter/editorconfig/index")
-}

src/main/kotlin/starter/templates/GitignoreTemplate.kt

@@ -1,13 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.render
-
-class GitignoreTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) =
-        ".gitignore"
-
-    override fun render(project: Project) =
-        engine.render("starter/gitignore/index")
-}

src/main/kotlin/starter/templates/JunitTemplate.kt

@@ -1,11 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.render
-
-class JunitTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) = "src/test/resources/junit-platform.properties"
-    override fun enabled(project: Project) = project.dependencies.any { it.name == "junit" }
-    override fun render(project: Project) = engine.render("starter/junit/index")
-}

src/main/kotlin/starter/templates/LogbackTemplate.kt

@@ -1,20 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.prettyPrintXml
-import starter.utils.render
-
-class LogbackTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) = "src/main/resources/logback.xml"
-
-    override fun enabled(project: Project) = project.dependencies.any { it.name == "logback" }
-
-    override fun render(project: Project): String {
-        val args = mapOf(
-            "loggers" to project.dependencies.mapNotNull { it.logger }.toSet()
-        )
-        val rendered = engine.render("starter/logback/index", args)
-        return prettyPrintXml(rendered)
-    }
-}

src/main/kotlin/starter/templates/MainTemplate.kt

@@ -1,13 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.render
-
-class MainTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) =
-        "src/main/kotlin/" + project.name.toLowerCase().capitalize() + ".kt"
-
-    override fun render(project: Project) =
-        engine.render("starter/main/index", mapOf("basePackage" to project.basePackage))
-}

src/main/kotlin/starter/templates/PomTemplate.kt

@@ -1,27 +0,0 @@
-package starter.templates
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.Project
-import starter.utils.prettyPrintXml
-import starter.utils.render
-
-class PomTemplate(private val engine: PebbleEngine) : Template {
-    override fun path(project: Project) = "pom.xml"
-
-    override fun render(project: Project): String {
-        val args: MutableMap<String, Any?> = mutableMapOf(
-            "dependencies" to project.dependencies.sortedBy { it.scope },
-            "repositories" to project.repositories,
-            "kotlinxSerialization" to project.dependencies.any { it.name == "kotlinx-serialization" },
-            "features" to project.features,
-            "versions" to project.dependencies.map { it.version }.toSet()
-        )
-
-        project.inputs.forEach {
-            args[it.name] = it.value
-        }
-
-        val rendered = engine.render("starter/pom/index", args)
-        return prettyPrintXml(rendered)
-    }
-}

src/main/kotlin/starter/templates/Template.kt

@@ -1,9 +0,0 @@
-package starter.templates
-
-import starter.Project
-
-interface Template {
-    fun path(project: Project): String
-    fun enabled(project: Project): Boolean = true
-    fun render(project: Project): String
-}

src/main/kotlin/starter/utils/PebbleUtils.kt

@@ -1,91 +1,11 @@
 package starter.utils
 
 import com.mitchellbosecke.pebble.PebbleEngine
-import com.mitchellbosecke.pebble.cache.tag.CaffeineTagCache
-import com.mitchellbosecke.pebble.cache.tag.ConcurrentMapTagCache
-import com.mitchellbosecke.pebble.cache.tag.NoOpTagCache
-import com.mitchellbosecke.pebble.cache.template.CaffeineTemplateCache
-import com.mitchellbosecke.pebble.cache.template.ConcurrentMapTemplateCache
-import com.mitchellbosecke.pebble.cache.template.NoOpTemplateCache
-import com.mitchellbosecke.pebble.extension.AbstractExtension
-import com.mitchellbosecke.pebble.extension.Filter
-import com.mitchellbosecke.pebble.extension.Function
-import com.mitchellbosecke.pebble.loader.ClasspathLoader
 import java.io.StringWriter
 
-fun PebbleEngine.render(name: String, args: Map<String, Any?> = mapOf()) =
+fun PebbleEngine.render(name: String, args: Map<String, Any?> = mapOf()): String {
-    getTemplate(name).let { StringWriter().apply { it.evaluate(this, args) }.toString() }
+    val template = getTemplate(name)
-
+    val writer = StringWriter()
-fun PebbleEngine.render(name: String, vararg args: Pair<String, Any?>) =
+    template.evaluate(writer, args)
-    render(name, mapOf(*args))
+    return writer.toString()
-
+}
-interface PebbleFunction : Function {
-    val name: String
-}
-
-interface PebbleFilter : Filter {
-    val name: String
-}
-
-class PebbleEngineBuilder {
-    enum class CacheType {
-        None, Caffeine, ConcurrentMap
-    }
-
-    private var loader = ClasspathLoader()
-    var cache = CacheType.ConcurrentMap
-
-    private val functions = mutableListOf<PebbleFunction>()
-    private val filters = mutableListOf<PebbleFilter>()
-
-    fun function(function: PebbleFunction) {
-        functions.add(function)
-    }
-
-    fun functions(functions: Iterable<PebbleFunction>) {
-        this.functions.addAll(functions)
-    }
-
-    fun filter(filter: PebbleFilter) {
-        filters.add(filter)
-    }
-
-    fun filters(filters: Iterable<PebbleFilter>) {
-        this.filters.addAll(filters)
-    }
-
-    fun classPath(block: ClasspathLoader.() -> Unit) {
-        loader = ClasspathLoader().apply(block)
-    }
-
-    companion object {
-        operator fun invoke(block: PebbleEngineBuilder.() -> Unit): PebbleEngine =
-            PebbleEngineBuilder().apply(block).let { builder ->
-                PebbleEngine.Builder()
-                    .loader(builder.loader)
-                    .cacheActive(builder.cache != CacheType.None)
-                    .templateCache(
-                        when (builder.cache) {
-                            CacheType.None -> NoOpTemplateCache()
-                            CacheType.Caffeine -> CaffeineTemplateCache()
-                            CacheType.ConcurrentMap -> ConcurrentMapTemplateCache()
-                        }
-                    )
-                    .tagCache(
-                        when (builder.cache) {
-                            CacheType.None -> NoOpTagCache()
-                            CacheType.Caffeine -> CaffeineTagCache()
-                            CacheType.ConcurrentMap -> ConcurrentMapTagCache()
-                        }
-                    )
-                    .extension(object : AbstractExtension() {
-                        override fun getFunctions(): Map<String, Function>? =
-                            builder.functions.associateBy { it.name }.ifEmpty { null }
-
-                        override fun getFilters(): Map<String, Filter>? =
-                            builder.filters.associateBy { it.name }.ifEmpty { null }
-                    })
-                    .build()
-            }
-    }
-}

src/main/kotlin/starter/utils/ProjectExtractor.kt

@@ -1,44 +0,0 @@
-package starter.utils
-
-import org.http4k.core.Request
-import org.http4k.core.body.form
-import org.http4k.core.body.formAsMap
-import starter.Project
-import starter.config.StarterConfig
-
-interface ProjectExtractor {
-    operator fun invoke(request: Request): Project?
-}
-
-class ProjectExtractorImpl(private val conf: StarterConfig) : ProjectExtractor {
-    override fun invoke(request: Request): Project? {
-        val deps = conf.dependencies.filter {
-            request.form(it.name) != null
-        }
-
-        val formMap = request.formAsMap()
-
-        val inputKeys = conf.inputs.map { it.name }
-        val inputs = formMap
-            .filter { it.key in inputKeys }
-            .map { (name, value) ->
-                conf.inputs.find { it.name == name }!!.copy(value = value.first())
-            }
-
-        val features = formMap
-            .filter { it.key in conf.features.map { it.name } }
-            .map { (name, _) ->
-                conf.features.find { it.name == name }!!.copy(value = true)
-            }
-
-        val projectName = inputs.find { it.name == "name" }?.value ?: return null
-        val basePackage = inputs.find { it.name == "basePackage" }?.value ?: return null
-
-        return if (basePackage.contains("/") || basePackage.contains("..")) {
-            null
-        } else {
-            val repositories = deps.mapNotNull { it.repository }.toSet()
-            Project(projectName, basePackage, inputs, features, deps, repositories)
-        }
-    }
-}

src/main/kotlin/starter/utils/XmlUtils.kt

@@ -13,23 +13,22 @@ import javax.xml.transform.stream.StreamResult
 import javax.xml.xpath.XPathConstants
 import javax.xml.xpath.XPathFactory
 
+
 /*
     @see https://stackoverflow.com/a/33541820
  */
 fun prettyPrintXml(xml: String, indent: Int = 4): String {
     // Turn xml string into a document
     val document: Document = DocumentBuilderFactory.newInstance()
-        .newDocumentBuilder()
+            .newDocumentBuilder()
-        .parse(InputSource(ByteArrayInputStream(xml.encodeToByteArray())))
+            .parse(InputSource(ByteArrayInputStream(xml.encodeToByteArray())))
 
     // Remove whitespaces outside tags
     document.normalize()
     val xPath = XPathFactory.newInstance().newXPath()
-    val nodeList = xPath.evaluate(
+    val nodeList = xPath.evaluate("//text()[normalize-space()='']",
-        "//text()[normalize-space()='']",
+            document,
-        document,
+            XPathConstants.NODESET) as NodeList
-        XPathConstants.NODESET
-    ) as NodeList
     for (i in 0 until nodeList.length) {
         val node = nodeList.item(i)
         node.parentNode.removeChild(node)
@@ -47,4 +46,4 @@ fun prettyPrintXml(xml: String, indent: Int = 4): String {
     val stringWriter = StringWriter()
     transformer.transform(DOMSource(document), StreamResult(stringWriter))
     return stringWriter.toString()
-}
+}

src/main/kotlin/starter/utils/ZipOutput.kt

@@ -2,21 +2,28 @@ package starter.utils
 
 import org.apache.commons.compress.archivers.zip.ZipArchiveEntry
 import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream
-import java.io.ByteArrayOutputStream
+import java.io.File
+import java.nio.file.Paths
 
-class ZipOutput : AutoCloseable {
+class ZipOutput(name: String) : AutoCloseable {
-    val outputStream = ByteArrayOutputStream()
+    private val baseDir = File(".").canonicalFile
-    private val zipOutputStream = ZipArchiveOutputStream(outputStream)
+    private val zipPath = Paths.get(baseDir.path, "$name.zip")
+    private val zipFile = zipPath.toAbsolutePath().normalize().toFile().apply {
+        createNewFile()
+    }
+    private val outputStream = ZipArchiveOutputStream(zipFile.outputStream())
+    val name: String
+        get() = zipFile.name
 
     fun write(path: String, content: String) {
         val entry = ZipArchiveEntry(path)
-        zipOutputStream.putArchiveEntry(entry)
+        outputStream.putArchiveEntry(entry)
-        zipOutputStream.write(content.toByteArray())
+        outputStream.write(content.toByteArray())
-        zipOutputStream.closeArchiveEntry()
+        outputStream.closeArchiveEntry()
     }
 
     override fun close() {
-        zipOutputStream.finish()
+        outputStream.finish()
-        zipOutputStream.close()
+        outputStream.close()
     }
-}
+}

src/main/kotlin/starter/views/Views.kt

@@ -1,15 +0,0 @@
-package starter.views
-
-import com.mitchellbosecke.pebble.PebbleEngine
-import starter.config.StarterConfig
-import starter.utils.render
-
-class Views(private val engine: PebbleEngine, config: StarterConfig) {
-    private val args = mapOf(
-        "dependencies" to config.dependencies.groupBy { it.category }.toSortedMap(),
-        "inputs" to config.inputs,
-        "features" to config.features,
-    )
-
-    fun index() = engine.render("views/index", args)
-}

src/main/resources/logback.xml

@@ -9,7 +9,6 @@
     <root level="DEBUG">
         <appender-ref ref="STDOUT"/>
     </root>
-    {% for logger in loggers %}
+    <logger name="com.mitchellbosecke.pebble" level="INFO"/>
-        <logger name="{{ logger }}" level="INFO"/>
+    <logger name="org.eclipse.jetty" level="INFO"/>
-    {% endfor %}
 </configuration>

src/main/resources/starter/editorconfig/index.twig

@@ -1,18 +0,0 @@
-# editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.{kt, kts}]
-indent_size = 4
-insert_final_newline = true
-continuation_indent_size=4
-max_line_length = 120
-disabled_rules = no-wildcard-imports
-kotlin_imports_layout = idea

src/main/resources/starter/gitignore/index.twig

@@ -1,5 +0,0 @@
-target/
-.idea/
-*.iml
-*.ipr
-*.iws

src/main/resources/starter/junit/index.twig

@@ -1,4 +0,0 @@
-junit.jupiter.testinstance.lifecycle.default=per_class
-junit.jupiter.execution.parallel.enabled=true
-junit.jupiter.execution.parallel.mode.default=same_thread
-junit.jupiter.execution.parallel.mode.classes.default=concurrent

src/main/resources/starter/main/main.twig

@@ -1,6 +1,5 @@
 package {{ basePackage }}
 
-
 fun main() {
     println("Hello world!")
 }

src/main/resources/starter/pom/@dependencies.twig

@@ -1,16 +1,12 @@
 <dependencies>
-    <dependency>
-        <groupId>org.jetbrains.kotlin</groupId>
-        <artifactId>kotlin-stdlib-jdk8</artifactId>
-    </dependency>
 {% for dep in dependencies %}
     <dependency>
         <groupId>{{ dep.groupId }}</groupId>
         <artifactId>{{ dep.artifactId }}</artifactId>
-        <version>{{ "${" }}{{ dep.version.name }}{{ ".version}" }}</version>
+        <version>{{ dep.version }}</version>
         {% if dep.scope == "Test" %}
-            <scope>test</scope>
+        <scope>test</scope>
         {% endif %}
     </dependency>
 {% endfor %}
-</dependencies>
+</dependencies>

src/main/resources/starter/pom/@dependencyManagement.twig

@@ -1,11 +0,0 @@
-<dependencyManagement>
-    <dependencies>
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-bom</artifactId>
-            <version>${kotlin.version}</version>
-            <type>pom</type>
-            <scope>import</scope>
-        </dependency>
-    </dependencies>
-</dependencyManagement>

src/main/resources/starter/pom/@plugins.twig

@@ -10,7 +10,5 @@
 
         {% include "starter/pom/plugins/@shade" %}
 
-        {% include "starter/pom/plugins/@ktlint" %}
-
     </plugins>
-</build>
+</build>

src/main/resources/starter/pom/@repositories.twig

@@ -1,10 +1,7 @@
-{% if repositories is not empty %}
 <repositories>
-    {% for repo in repositories %}
+    <repository>
-        <repository>
+        <id>jcenter</id>
-            <id>{{ repo.name }}</id>
+        <name>jcenter</name>
-            <url>{{ repo.url }}</url>
+        <url>https://jcenter.bintray.com</url>
-        </repository>
+    </repository>
-    {% endfor %}
+</repositories>
-</repositories>
-{% endif %}

src/main/resources/starter/pom/plugins/@kotlin.twig

@@ -20,19 +20,5 @@
     </executions>
     <configuration>
         <jvmTarget>${java.version}</jvmTarget>
-        {% if kotlinxSerialization %}
-            <compilerPlugins>
-                <plugin>kotlinx-serialization</plugin>
-            </compilerPlugins>
-        {% endif %}
     </configuration>
-    {% if kotlinxSerialization %}
+</plugin>
-    <dependencies>
-        <dependency>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-maven-serialization</artifactId>
-            <version>${kotlin.version}</version>
-        </dependency>
-    </dependencies>
-    {% endif %}
-</plugin>

src/main/resources/starter/pom/plugins/@ktlint.twig

@@ -1,46 +0,0 @@
-{% if features | hasFeature("ktlint") %}
-<plugin>
-    <groupId>org.apache.maven.plugins</groupId>
-    <artifactId>maven-antrun-plugin</artifactId>
-    <version>1.7</version>
-    <executions>
-        <execution>
-            <id>ktlint</id>
-            <phase>verify</phase>
-            <configuration>
-                <target name="ktlint">
-                    <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
-                          classname="com.pinterest.ktlint.Main" classpathref="maven.plugin.classpath">
-                        <arg value="src/**/*.kt"/>
-                    </java>
-                </target>
-            </configuration>
-            <goals>
-                <goal>run</goal>
-            </goals>
-        </execution>
-        <execution>
-            <id>ktlint-format</id>
-            <configuration>
-                <target name="ktlint">
-                    <java taskname="ktlint" dir="${basedir}" fork="true" failonerror="true"
-                          classname="com.pinterest.ktlint.Main" classpathref="maven.plugin.classpath">
-                        <arg value="-F"/>
-                        <arg value="src/**/*.kt"/>
-                    </java>
-                </target>
-            </configuration>
-            <goals>
-                <goal>run</goal>
-            </goals>
-        </execution>
-    </executions>
-    <dependencies>
-        <dependency>
-            <groupId>com.pinterest</groupId>
-            <artifactId>ktlint</artifactId>
-            <version>0.39.0</version>
-        </dependency>
-    </dependencies>
-</plugin>
-{% endif %}

src/main/resources/starter/pom/plugins/@shade.twig

@@ -9,7 +9,6 @@
                 <goal>shade</goal>
             </goals>
             <configuration>
-                <createDependencyReducedPom>false</createDependencyReducedPom>
                 <minimizeJar>true</minimizeJar>
                 <transformers>
                     <transformer
@@ -20,4 +19,4 @@
             </configuration>
         </execution>
     </executions>
-</plugin>
+</plugin>

src/main/resources/starter/pom/pom.twig

@@ -8,24 +8,16 @@
     <properties>
         <java.version>{{ javaVersion }}</java.version>
         <kotlin.version>{{ kotlinVersion }}</kotlin.version>
-        <kotlin.code.style>official</kotlin.code.style>
         <maven.compiler.target>${java.version}</maven.compiler.target>
         <maven.compiler.source>${java.version}</maven.compiler.source>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <main.class>{{ basePackage }}.{{ name | lower | capitalize }}Kt</main.class>
+        <main.class>{{ basePackage }}/{{ name | lower | capitalize }}Kt</main.class>
-        <!-- versions -->
-        {% for version in versions %}
-            <{{version.name}}.version>{{version.value}}</{{version.name}}.version>
-        {% endfor %}
-
     </properties>
 
     {% include "starter/pom/@dependencies" %}
 
     {% include "starter/pom/@repositories" %}
 
-    {% include "starter/pom/@dependencyManagement" %}
-
     {% include "starter/pom/@plugins" %}
 
-</project>
+</project>

src/main/resources/views/#macros.twig

@@ -1,14 +1,9 @@
 {% macro dependency(dependency) %}
-    <details>
+    <label class="m-2">
-        <summary>
+        <input name="{{ dependency.name }}"
-            <label class="m-2">
+               type="checkbox"{% if dependency.default %} checked{% endif %}>
-                <input name="{{ dependency.name }}"
+        <span>{{ dependency.name }}</span>
-                       type="checkbox"{% if dependency.default %} checked{% endif %}>
+    </label>
-                <span>{{ dependency.name }}</span>
-            </label>
-        </summary>
-        <pre><code>{{ depAsXml(dependency) }}</code></pre>
-    </details>
 {% endmacro %}
 
 {% macro input(input) %}
@@ -22,4 +17,4 @@
             <input name="{{ input.name }}" id="{{ input.name }}" class="input"{% if input.value %} value="{{ input.value }}"{% endif %}>
         </div>
     </div>
-{% endmacro %}
+{% endmacro %}

src/main/resources/views/index.twig

@@ -10,19 +10,6 @@
         {% endfor %}
 
         <div class="mt-4">
-            <section>
-                <h2 class="category">Features</h2>
-                <ul>
-                    {% for feature in features %}
-                        <label class="m-2">
-                            <input name="{{ feature.name }}"
-                                   type="checkbox"{% if feature.value %} checked{% endif %}>
-                            <span>{{ feature.name }}</span>
-                        </label>
-                    {% endfor %}
-                </ul>
-            </section>
-
             {% for category in dependencies %}
                 <section>
                     <h2 class="category">{{ category.key }}</h2>
@@ -34,6 +21,6 @@
                 </section>
             {% endfor %}
         </div>
-        <button type="submit" class="my-4 w-full btn btn-purple">Submit</button>
+        <button type="submit" class="w-full btn btn-purple">Submit</button>
     </form>
 {% endblock %}

src/test/kotlin/starter/TestProject.kt

@@ -1,46 +0,0 @@
-package starter
-
-import starter.config.StarterConfig
-
-val testConfig = StarterConfig(
-    dependencies = listOf(
-        Dependency(
-            name = "h2",
-            groupId = "com.h2database",
-            artifactId = "h2",
-            version = Version("h2", "1.4.200"),
-            default = false,
-            category = Category.Database,
-            scope = Scope.Compile,
-            logger = null,
-            repository = null,
-        ),
-        Dependency(
-            name = "assertj",
-            groupId = "org.assertj",
-            artifactId = "assertj-core",
-            version = Version("assertj", "3.17.2"),
-            default = true,
-            category = Category.Test,
-            scope = Scope.Test,
-            logger = null,
-            repository = null,
-        ),
-        Dependency(
-            name = "koin",
-            groupId = "org.koin",
-            artifactId = "koin-core",
-            version = Version("koin", "2.1.6"),
-            default = true,
-            category = Category.Injection,
-            scope = Scope.Compile,
-            logger = null,
-            repository = Repository("jcenter", "https://jcenter.bintray.com"),
-        ),
-    ),
-    inputs = listOf(
-        Input(name = "name", display = "name", value = "example"),
-        Input(name = "basePackage", display = "Base package", value = "org.example"),
-    ),
-    features = listOf(Feature("ktlint", true))
-)

src/test/kotlin/starter/config/ConfigTest.kt

@@ -1,114 +0,0 @@
-package starter.config
-
-import com.electronwill.nightconfig.toml.TomlParser
-import org.assertj.core.api.Assertions.assertThat
-import org.intellij.lang.annotations.Language
-import org.junit.jupiter.api.Test
-import starter.*
-import java.io.StringReader
-
-internal class ConfigTest {
-    private val parser = TomlParser()
-    private fun parse(config: String) = parser.parse(StringReader(config))
-
-    @Test
-    fun inputs() {
-        @Language("toml")
-        val toml = """
-            [inputs]
-
-            [inputs.name]
-            default = "example"
-            display = "Project Name"
-
-            [inputs.basePackage]
-            default = "org.example"
-            display = "Base package"
-        """.trimIndent()
-
-        val starterConfig = Config(parse(toml)).load()
-
-        val expected = listOf(
-            Input("basePackage", "Base package", "org.example"),
-            Input("name", "Project Name", "example"),
-        )
-
-        assertThat(starterConfig.inputs).containsExactlyInAnyOrderElementsOf(expected)
-    }
-
-    @Test
-    fun dependencies() {
-        @Language("toml")
-        val toml = """
-            [versions]
-            assertj = "3.17.2"
-            koin = "2.1.6"
-            h2 = "1.4.200"
-
-            [repositories]
-
-            [repositories.jcenter]
-            url = "https://jcenter.bintray.com"
-
-            [dependencies]
-
-            [dependencies.assertj]
-            groupId = "org.assertj"
-            artifactId = "assertj-core"
-            scope = "test"
-            category = "test"
-            default = true
-
-            [dependencies.koin]
-            groupId = "org.koin"
-            artifactId = "koin-core"
-            category = "injection"
-            repository = "jcenter"
-            default = true
-
-            [dependencies.h2]
-            groupId = "com.h2database"
-            category = "database"
-        """.trimIndent()
-
-        val starterConfig = Config(parse(toml)).load()
-
-        val expected = listOf(
-            Dependency(
-                name = "h2",
-                groupId = "com.h2database",
-                artifactId = "h2",
-                version = Version("h2", "1.4.200"),
-                default = false,
-                category = Category.Database,
-                scope = Scope.Compile,
-                logger = null,
-                repository = null,
-            ),
-            Dependency(
-                name = "assertj",
-                groupId = "org.assertj",
-                artifactId = "assertj-core",
-                version = Version("assertj", "3.17.2"),
-                default = true,
-                category = Category.Test,
-                scope = Scope.Test,
-                logger = null,
-                repository = null,
-            ),
-            Dependency(
-                name = "koin",
-                groupId = "org.koin",
-                artifactId = "koin-core",
-                version = Version("koin", "2.1.6"),
-                default = true,
-                category = Category.Injection,
-                scope = Scope.Compile,
-                logger = null,
-                repository = Repository("jcenter", "https://jcenter.bintray.com"),
-            ),
-        )
-
-        assertThat(starterConfig.dependencies).containsExactlyInAnyOrderElementsOf(expected)
-    }
-}

src/test/kotlin/starter/templates/PomTemplateTest.kt

@@ -1,120 +0,0 @@
-package starter.templates
-
-import org.assertj.core.api.Assertions.assertThat
-import org.intellij.lang.annotations.Language
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.TestInstance
-import org.koin.dsl.koinApplication
-import org.w3c.dom.Node
-import org.w3c.dom.NodeList
-import starter.Project
-import starter.config.StarterConfig
-import starter.modules.configModule
-import starter.modules.pebbleModule
-import starter.modules.templateModule
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.xpath.XPathConstants
-import javax.xml.xpath.XPathFactory
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-internal class PomTemplateTest {
-
-    private val koin = koinApplication {
-        modules(configModule, pebbleModule, templateModule)
-    }.koin
-
-    private val pomTemplate = koin.get<PomTemplate>()
-    private val conf = koin.get<StarterConfig>()
-
-    private val project = Project(
-        name = "Test",
-        basePackage = "org.test",
-        inputs = conf.inputs,
-        features = emptyList(),
-        dependencies = conf.dependencies,
-        repositories = conf.dependencies.mapNotNull { it.repository }.toSet()
-    )
-
-    private val docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder()
-    private val xPath = XPathFactory.newInstance().newXPath()
-
-    // region xml utils
-    private fun String.extract(expression: String): String {
-        val doc = docBuilder.parse(this.byteInputStream())
-        xPath.compile(expression).evaluate(doc, XPathConstants.NODESET)
-        return xPath.compile(expression).evaluate(doc)
-    }
-
-    private fun <T> String.extractAll(expression: String, mapper: (Node) -> T): List<T> {
-        val doc = docBuilder.parse(this.byteInputStream())
-        val res = xPath.compile(expression).evaluate(doc, XPathConstants.NODESET) as NodeList
-        return res.asList().map(mapper)
-    }
-
-    private fun NodeList.asList(): List<Node> = (0 until length).map { item(it) }
-    // endregion
-
-    @Test
-    fun javaVersion() {
-        val xml = pomTemplate.render(project)
-        assertThat(xml.extract("/project/properties/java.version"))
-            .isEqualTo(project.inputs.find { it.name == "javaVersion" }?.value)
-
-        println(xml)
-    }
-
-    @Test
-    fun dependencies() {
-        val xml = pomTemplate.render(project)
-
-        val deps = xml.extractAll("/project/dependencies/dependency") {
-            val map = it.childNodes.asList()
-                .filter { it.nodeType == Node.ELEMENT_NODE }
-                .associate { it.nodeName to it.firstChild.nodeValue }
-
-            Triple(map["groupId"]!!, map["artifactId"]!!, map["version"] ?: "")
-        }.filterNot { it.second == "kotlin-stdlib-jdk8" }
-
-        println(deps.joinToString("\n"))
-
-        val expectedDependencies = project.dependencies
-            .map { Triple(it.groupId, it.artifactId, "\${" + it.version.name + ".version}") }
-
-        assertThat(expectedDependencies).containsExactlyInAnyOrderElementsOf(deps)
-    }
-
-    @Test
-    fun versions() {
-        val xml = pomTemplate.render(project)
-
-        val versions = xml.extractAll("/project/properties") {
-            it.childNodes.asList()
-                .filter { it.nodeType == Node.ELEMENT_NODE }
-                .filter { it.nodeName.endsWith(".version") }
-                .filterNot { it.nodeName in listOf("java.version", "kotlin.version") }
-                .associate { it.nodeName.substringBefore(".version") to it.firstChild.nodeValue }
-        }.first()
-
-        val expected = project.dependencies.associate { it.version.name to it.version.value }
-
-        assertThat(versions).containsExactlyInAnyOrderEntriesOf(expected)
-
-        println(versions)
-    }
-
-    @Test
-    fun kotlinxSerialization() {
-        val xml = pomTemplate.render(project)
-
-        @Language("XPath")
-        val kotlinMavenPlugin = "/project/build/plugins/plugin[artifactId='kotlin-maven-plugin']"
-
-        val kotlinxPlugin = "$kotlinMavenPlugin/configuration/compilerPlugins/plugin"
-        assertThat(xml.extract(kotlinxPlugin))
-            .isEqualTo("kotlinx-serialization")
-
-        val kotlinxPluginDep = "$kotlinMavenPlugin/dependencies/dependency/artifactId"
-        assertThat(xml.extract(kotlinxPluginDep))
-            .isEqualTo("kotlin-maven-serialization")
-    }
-}

src/test/kotlin/starter/utils/ProjectExtractorImplTest.kt

@@ -1,109 +0,0 @@
-package starter.utils
-
-import org.assertj.core.api.Assertions.assertThat
-import org.http4k.core.Method
-import org.http4k.core.Request
-import org.http4k.core.body.Form
-import org.http4k.core.body.toBody
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.MethodSource
-import org.koin.dsl.koinApplication
-import org.koin.dsl.module
-import starter.Feature
-import starter.Input
-import starter.Project
-import starter.modules.routesModule
-import starter.testConfig
-import java.util.stream.Stream
-
-internal class ProjectExtractorImplTest {
-
-    private val fakeModule = module {
-        single { testConfig }
-    }
-
-    private val koin = koinApplication {
-        modules(routesModule, fakeModule)
-    }.koin
-
-    private val projectExtractor = koin.get<ProjectExtractor>()
-
-    @Suppress("unused")
-    fun invalidProjectsSource(): Stream<Form> = Stream.of(
-        emptyList(),
-        listOf(
-            "basePackage" to "org.example",
-        ),
-        listOf(
-            "basePackage" to "org.example/a",
-            "name" to "test"
-        ),
-    )
-
-    @ParameterizedTest
-    @MethodSource("invalidProjectsSource")
-    fun invalidProjects(form: Form) {
-        val request = Request(Method.POST, "")
-            .body(form.toBody())
-
-        val project = projectExtractor(request)
-
-        assertThat(project).isNull()
-    }
-
-    @Suppress("unused")
-    fun validProjectsSource(): Stream<Pair<Form, Project>> = Stream.of(
-        listOf(
-            "name" to "Test",
-            "basePackage" to "org.example",
-            "ktlint" to "",
-        ) to Project(
-            name = "Test",
-            basePackage = "org.example",
-            inputs = listOf(
-                Input(name = "name", display = "name", value = "Test"),
-                Input(name = "basePackage", display = "Base package", value = "org.example"),
-            ),
-            features = listOf(
-                Feature(name = "ktlint", value = true)
-            ),
-            dependencies = listOf(),
-            repositories = setOf(),
-        ),
-        listOf(
-            "name" to "Test",
-            "basePackage" to "org.example",
-            "ktlint" to "",
-            "koin" to "",
-        ) to Project(
-            name = "Test",
-            basePackage = "org.example",
-            inputs = listOf(
-                Input(name = "name", display = "name", value = "Test"),
-                Input(name = "basePackage", display = "Base package", value = "org.example"),
-            ),
-            features = listOf(
-                Feature(name = "ktlint", value = true)
-            ),
-            dependencies = listOf(
-                testConfig.dependencies.find { it.name == "koin" }!!
-            ),
-            repositories = setOf(
-                testConfig.dependencies.find { it.name == "koin" }!!.repository!!
-            ),
-        ),
-    )
-
-    @ParameterizedTest
-    @MethodSource("validProjectsSource")
-    fun validProjects(pair: Pair<Form, Project>) {
-        val (form, expected) = pair
-
-        val request = Request(Method.POST, "")
-            .body(form.toBody())
-
-        val project = projectExtractor(request)
-
-        assertThat(project).isEqualTo(expected)
-    }
-}

src/test/resources/junit-platform.properties

@@ -1,4 +0,0 @@
-junit.jupiter.testinstance.lifecycle.default=per_class
-junit.jupiter.execution.parallel.enabled=true
-junit.jupiter.execution.parallel.mode.default=same_thread
-junit.jupiter.execution.parallel.mode.classes.default=concurrent