Initial commit - Builder annotation works for simple data classes

Author: YetAnotherMatt

.gitignore

@@ -0,0 +1,6 @@
+.gradle
+.idea
+**/build/
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Thinking Logic Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,7 @@
+# kotlin-builder-annotation
+A builder annotation for Kotlin interoperability with Java.
+This project aims to be a minimal viable replacement for the Lombok @Builder plugin for Kotlin code.
+
+Named constructor parameters with optional values mean that Kotlin code doesn't require the builder pattern any more,
+_unless_ you're writing code that will be used by Java projects 
+(else you consign your java clients to using unhelpful constructors with many parameters).

build.gradle

@@ -0,0 +1,40 @@
+
+buildscript {
+    ext.kotlin_version = '1.2.60'
+
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+
+allprojects{
+    apply plugin: "kotlin"
+    
+    repositories {
+        mavenCentral()
+    }
+
+    compileKotlin {
+        kotlinOptions {
+            jvmTarget = "1.8"
+            javaParameters = true
+        }
+    }
+
+    compileTestKotlin {
+        kotlinOptions {
+            jvmTarget = "1.8"
+            javaParameters = true
+        }
+    }
+
+    dependencies {
+        compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    }
+
+}

builder-annotation/build.gradle

@@ -0,0 +1,4 @@
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+}

builder-annotation/src/main/kotlin/com/thinkinglogic/builder/annotation/Builder.kt

@@ -0,0 +1,10 @@
+package com.thinkinglogic.builder.annotation
+
+/**
+ * A lightweight replacement for Lombok's @Builder annotation, decorating a class with @Builder will cause a
+ * {AnnotatedClassName}Builder class to be generated.
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.CLASS)
+annotation class Builder {
+}

builder-processor/build.gradle

@@ -0,0 +1,8 @@
+apply plugin: 'kotlin-kapt'
+
+dependencies {
+    implementation project(':builder-annotation')
+
+    implementation 'com.squareup:kotlinpoet:1.0.0-RC1'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+}

builder-processor/src/main/java/com/thinkinglogic/builder/processor/BuilderProcessor.kt

@@ -0,0 +1,151 @@
+package com.thinkinglogic.builder.processor
+
+import com.squareup.kotlinpoet.*
+import com.thinkinglogic.builder.annotation.Builder
+import org.jetbrains.annotations.NotNull
+import java.io.File
+import javax.annotation.processing.*
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.Element
+import javax.lang.model.element.Name
+import javax.lang.model.element.TypeElement
+import javax.lang.model.type.PrimitiveType
+import javax.lang.model.util.ElementFilter.fieldsIn
+import javax.tools.Diagnostic.Kind.*
+
+/**
+ * Kapt processor for the @Builder annotation.
+ * Constructs a Builder for the annotated class.
+ */
+@SupportedAnnotationTypes("com.thinkinglogic.builder.annotation.Builder")
+@SupportedSourceVersion(SourceVersion.RELEASE_8)
+@SupportedOptions(BuilderProcessor.KAPT_KOTLIN_GENERATED_OPTION_NAME)
+class BuilderProcessor : AbstractProcessor() {
+
+    companion object {
+        const val KAPT_KOTLIN_GENERATED_OPTION_NAME = "kapt.kotlin.generated"
+    }
+
+    override fun process(annotations: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {
+        val annotatedElements = roundEnv.getElementsAnnotatedWith(Builder::class.java)
+        if (annotatedElements.isEmpty()) {
+            processingEnv.noteMessage { "No classes annotated with @${Builder::class.java.simpleName} in this round ($roundEnv)" }
+            return false
+        }
+
+        val generatedSourcesRoot = processingEnv.options[KAPT_KOTLIN_GENERATED_OPTION_NAME] ?: run {
+            processingEnv.errorMessage { "Can't find the target directory for generated Kotlin files." }
+            return false
+        }
+
+        processingEnv.noteMessage { "Generating Builders for ${annotatedElements.size} classes in $generatedSourcesRoot" }
+
+        val sourceRootFile = File(generatedSourcesRoot)
+        sourceRootFile.mkdir()
+
+        annotatedElements.forEach { annotatedClass ->
+            if (annotatedClass !is TypeElement) {
+                annotatedClass.errorMessage { "Invalid element type, expected a class" }
+                return@forEach
+            }
+
+            writeBuilderForClass(annotatedClass, sourceRootFile)
+        }
+
+        return false
+    }
+
+    private fun writeBuilderForClass(annotatedClass: TypeElement, sourceRootFile: File) {
+        val packageName = processingEnv.elementUtils.getPackageOf(annotatedClass).toString()
+        val builderClassName = "${annotatedClass.simpleName}Builder"
+
+        processingEnv.noteMessage { "Writing $packageName.$builderClassName" }
+
+        val classBuilder = TypeSpec.classBuilder(builderClassName)
+        val builderClass = ClassName(packageName, builderClassName)
+        val fieldsInClass = fieldsIn(processingEnv.elementUtils.getAllMembers(annotatedClass))
+
+        fieldsInClass.forEach { field ->
+            processingEnv.noteMessage { "Adding field: $field" }
+            classBuilder.addProperty(field.asProperty())
+            classBuilder.addFunction(field.asSetterFunctionReturning(builderClass))
+        }
+
+        classBuilder.addFunction(createBuildFunction(fieldsInClass, annotatedClass.simpleName))
+
+        FileSpec.builder(packageName, builderClassName)
+                .addType(classBuilder.build())
+                .build()
+                .writeTo(sourceRootFile)
+    }
+
+    private fun createBuildFunction(fieldInClass: List<Element>, returnType: Name): FunSpec {
+        val buildFunctionContent = StringBuilder("return $returnType(")
+        val iterator = fieldInClass.listIterator()
+        while (iterator.hasNext()) {
+            val field = iterator.next()
+            buildFunctionContent.appendln().append("    ${field.simpleName} = ${field.simpleName}")
+            if (!field.isNullable()) {
+                buildFunctionContent.append("!!")
+            }
+            if (iterator.hasNext()) {
+                buildFunctionContent.append(",")
+            }
+        }
+        buildFunctionContent.appendln().append(")").appendln()
+
+        return FunSpec.builder("build")
+                .addCode(buildFunctionContent.toString())
+                .build()
+    }
+
+    private fun Element.className(): ClassName {
+        var className = this.asTypeElement().asClassName()
+        if (className.packageName == "java.lang") {
+            className = Class.forName(className.canonicalName).kotlin.asClassName()
+        }
+        return className
+    }
+
+    private fun Element.asTypeElement(): TypeElement {
+        val element = processingEnv.typeUtils.asElement(this.asType()) ?: processingEnv.typeUtils.boxedClass(this.asType() as PrimitiveType?)
+        return element as TypeElement
+    }
+
+    private fun Element.isNullable(): Boolean {
+        if (this.asType() is PrimitiveType) {
+            return false
+        }
+        return !this.annotationMirrors
+                .map { it.annotationType.toString() }
+                .toSet()
+                .contains(NotNull::class.java.name)
+    }
+
+    private fun Element.asProperty(): PropertySpec =
+        PropertySpec.varBuilder(simpleName.toString(), className().asNullable(), KModifier.PRIVATE)
+                .initializer("null")
+                .build()
+
+    private fun Element.asSetterFunctionReturning(returnType: ClassName): FunSpec {
+        val fieldClassName = className()
+        val parameterClass = (if (isNullable()) fieldClassName.asNullable() else fieldClassName)
+        return FunSpec.builder(simpleName.toString())
+                .addParameter(ParameterSpec.builder("value", parameterClass).build())
+                .returns(returnType)
+                .addCode("return apply { $simpleName = value }")
+                .build()
+    }
+
+    private fun Element.errorMessage(message: () -> String) {
+        processingEnv.messager.printMessage(ERROR, message(), this)
+    }
+}
+
+private fun ProcessingEnvironment.errorMessage(message: () -> String) {
+    this.messager.printMessage(ERROR, message())
+}
+
+private fun ProcessingEnvironment.noteMessage(message: () -> String) {
+    this.messager.printMessage(NOTE, message())
+}

builder-processor/src/main/resources/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1 @@
+com.thinkinglogic.builder.processor.BuilderProcessor

client/build.gradle

@@ -0,0 +1,13 @@
+apply plugin: 'kotlin-kapt'
+
+dependencies {
+    compile project(':builder-annotation')
+
+    kapt project(':builder-processor')
+
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+
+    testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.2.0'
+    testCompile group: 'com.willowtreeapps.assertk', name: 'assertk', version: '0.10'
+
+}

client/src/main/kotlin/com/thinkinglogic/example/CollectionsDataClass.kt

@@ -0,0 +1,30 @@
+package com.thinkinglogic.example
+
+import java.util.*
+
+data class CollectionsDataClass(
+        val listOfStrings: List<String>,
+        val arrayOfStrings: Array<String>,
+        val mapOfStrings: Map<String, String>
+
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as CollectionsDataClass
+
+        if (listOfStrings != other.listOfStrings) return false
+        if (!Arrays.equals(arrayOfStrings, other.arrayOfStrings)) return false
+        if (mapOfStrings != other.mapOfStrings) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = listOfStrings.hashCode()
+        result = 31 * result + Arrays.hashCode(arrayOfStrings)
+        result = 31 * result + mapOfStrings.hashCode()
+        return result
+    }
+}

client/src/main/kotlin/com/thinkinglogic/example/ConstructorArgDataClass.kt

@@ -0,0 +1,8 @@
+package com.thinkinglogic.example
+
+data class ConstructorArgDataClass(
+        val nonPropertyParam: String,
+        val otherProperty: String
+) {
+    private val propertyValue = nonPropertyParam
+}

client/src/main/kotlin/com/thinkinglogic/example/SimpleDataClass.kt

@@ -0,0 +1,13 @@
+package com.thinkinglogic.example
+
+import com.thinkinglogic.builder.annotation.Builder
+import java.time.LocalDate
+
+@Builder
+data class SimpleDataClass(
+        val notNullString: String = "withDefaultValue",
+        val nullableString: String?,
+        val notNullLong: Long,
+        val nullableLong: Long?,
+        val date: LocalDate
+)

client/src/test/kotlin/com/thinkinglogic/example/SimpleDataClassTest.kt

@@ -0,0 +1,33 @@
+package com.thinkinglogic.example
+
+import assertk.assert
+import assertk.assertions.isEqualTo
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+
+internal class SimpleDataClassTest {
+
+    @Test
+    fun `builder should create object with correct properties`() {
+        // given
+        val expected = SimpleDataClass(
+                nullableString = null,
+                notNullLong = 123,
+                nullableLong = 345,
+                date = LocalDate.now()
+        )
+
+        // when
+        val actual = SimpleDataClassBuilder()
+                .notNullString(expected.notNullString)
+                .notNullLong(expected.notNullLong)
+                .nullableLong(expected.nullableLong)
+                .date(expected.date)
+                .build()
+
+        // then
+        assert(actual).isEqualTo(expected)
+    }
+
+    // TODO create test that confirms a default value for notNullString property is correctly set
+}

gradle.properties

@@ -0,0 +1 @@
+kapt.verbose=true

gradle/wrapper/gradle-wrapper.jar

@@ -0,0 +1,6 @@
+#Sun Aug 05 16:37:36 BST 2018
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-all.zip