Added a parameter to the constructor of the builder to take default values from an instance

Author: YetAnotherMatt

README.md

@@ -26,7 +26,7 @@ dependencies {
     <dependency>
         <groupId>com.thinkinglogic.builder</groupId>
         <artifactId>kotlin-builder-annotation</artifactId>
-        <version>1.0.3</version>
+        <version>1.1.0</version>
     </dependency>
     ...
 </dependencies>
@@ -46,7 +46,7 @@ dependencies {
             <annotationProcessorPath>
                 <groupId>com.thinkinglogic.builder</groupId>
                 <artifactId>kotlin-builder-processor</artifactId>
-                <version>1.0.3</version>
+                <version>1.1.0</version>
             </annotationProcessorPath>
         </annotationProcessorPaths>
     </configuration>
@@ -87,6 +87,9 @@ The builder will check for required fields, so
  `new MyDataClassBuilder().notNullString("Foo").build();`  
  would return a new instance with a null value for 'nullableString'.
 
+To replace Kotlin's `copy()` (and Lombok's `toBuilder()`) method, clients can pass an instance of the annotated class when constructing a builder:
+`new MyDataClassBuilder(myDataClassInstance)` - the builder will be initialised with values from the instance.
+
 #### Default values
 Kotlin doesn't retain information about default values after compilation, so it cannot be accessed during annotation processing. 
 Instead we must use the `@DefaultValue` annotation to tell the builder about it: 

build.gradle

@@ -21,7 +21,7 @@ buildscript {
 
 allprojects {
     group = 'com.thinkinglogic.builder'
-    version = '1.0.3'
+    version = '1.1.0'
     apply plugin: "kotlin"
 
     repositories {

kotlin-builder-example-usage/src/main/kotlin/com/thinkinglogic/example/ClassWithConstructorParameters.kt

@@ -29,4 +29,8 @@ constructor(
         result = 31 * result + fullName.hashCode()
         return result
     }
+
+    override fun toString(): String {
+        return "ClassWithConstructorParameters(otherName=$otherName, fullName='$fullName')"
+    }
 }

kotlin-builder-example-usage/src/test/kotlin/com/thinkinglogic/example/ClassWithConstructorParametersTest.kt

@@ -46,4 +46,25 @@ internal class ClassWithConstructorParametersTest {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `builder should inherit values from source`() {
+        // given
+        val forename = "Jane"
+        val surname = "Smith"
+        val expected = ClassWithConstructorParameters(
+                forename = forename,
+                surname = surname,
+                otherName = "Jayne"
+        )
+
+        // when
+        val actual = ClassWithConstructorParametersBuilder(expected)
+                .forename(forename)
+                .surname(surname)
+                .build()
+
+        // then
+        assertThat(actual).isEqualTo(expected)
+    }
+
 }

kotlin-builder-example-usage/src/test/kotlin/com/thinkinglogic/example/DataClassWithAdditionalFieldsTest.kt

@@ -1,5 +1,9 @@
 package com.thinkinglogic.example
 
+import assertk.assertions.contains
+import assertk.assertions.isNotNull
+import assertk.assertions.message
+import assertk.catch
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
@@ -24,4 +28,22 @@ internal class DataClassWithAdditionalFieldsTest {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `builder should not inherit private properties from source object`() {
+        // given
+        val source = DataClassWithAdditionalFields(
+                constructorString = "foobar ",
+                privateString = "barfoo"
+        )
+
+        // when
+        var expected = catch { DataClassWithAdditionalFieldsBuilder(source).build() }
+
+        // then
+        assertk.assert(expected).isNotNull { e ->
+            e is IllegalStateException
+            e.message().isNotNull { it.contains("privateString") }
+        }
+    }
+
 }

kotlin-builder-example-usage/src/test/kotlin/com/thinkinglogic/example/SimpleDataClassTest.kt

@@ -1,7 +1,9 @@
 package com.thinkinglogic.example
 
 import assertk.assert
-import assertk.assertions.*
+import assertk.assertions.contains
+import assertk.assertions.isNotNull
+import assertk.assertions.message
 import assertk.catch
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
@@ -57,6 +59,47 @@ internal class SimpleDataClassTest {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `builder should inherit properties from source`() {
+        // given
+        val expected = SimpleDataClass(
+                notNullString = "not null",
+                nullableString = null,
+                notNullLong = 123,
+                nullableLong = 345,
+                date = LocalDate.now()
+        )
+
+        // when
+        val actual = SimpleDataClassBuilder(expected)
+                .build()
+
+        // then
+        assertThat(actual).isEqualTo(expected)
+    }
+
+    @Test
+    fun `builder should replace inherited properties`() {
+        // given
+        val original = SimpleDataClass(
+                notNullString = "not null",
+                nullableString = null,
+                notNullLong = 123,
+                nullableLong = 345,
+                date = LocalDate.now()
+        )
+        val newStringValue = "New value"
+
+        // when
+        val actual = SimpleDataClassBuilder(original)
+                .notNullString(newStringValue)
+                .build()
+
+        // then
+        assertThat(actual).isNotEqualTo(original)
+        assertThat(actual.notNullString).isEqualTo(newStringValue)
+    }
+
     @Test
     fun `build method should throw exception if required property not set`() {
         // given

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

@@ -17,8 +17,7 @@ import javax.lang.model.type.ArrayType
 import javax.lang.model.type.DeclaredType
 import javax.lang.model.type.PrimitiveType
 import javax.lang.model.type.TypeMirror
-import javax.lang.model.util.ElementFilter.constructorsIn
-import javax.lang.model.util.ElementFilter.fieldsIn
+import javax.lang.model.util.ElementFilter.*
 import javax.tools.Diagnostic.Kind.ERROR
 import javax.tools.Diagnostic.Kind.NOTE
 
@@ -96,6 +95,8 @@ class BuilderProcessor : AbstractProcessor() {
             builderSpec.addFunction(field.asSetterFunctionReturning(builderClass))
         }
 
+        builderSpec.primaryConstructor(FunSpec.constructorBuilder().build())
+        builderSpec.addFunction(createConstructor(fields, classToBuild))
         builderSpec.addFunction(createBuildFunction(fields, classToBuild))
         builderSpec.addFunction(createCheckRequiredFieldsFunction(fields))
 
@@ -117,6 +118,34 @@ class BuilderProcessor : AbstractProcessor() {
         return fields.filter { constructorParamNames.contains(it.simpleName.toString()) }
     }
 
+    /** Creates a constructor for [classType] that accepts an instance of the class to build, from which default values are obtained. */
+    private fun createConstructor(fields: List<Element>, classType: TypeElement): FunSpec {
+        val source = "source"
+        val sourceParameter = ParameterSpec.builder(source, classType.asKotlinTypeName()).build()
+        val getterFieldNames = classType.getterFieldNames()
+        val code = StringBuilder()
+        fields.forEach { field ->
+            if (getterFieldNames.contains(field.simpleName.toString())) {
+                code.append("    this.${field.simpleName} = $source.${field.simpleName}")
+                        .appendln()
+            }
+        }
+        return FunSpec.constructorBuilder()
+                .addParameter(sourceParameter)
+                .callThisConstructor()
+                .addCode(code.toString())
+                .build()
+    }
+
+    /** Returns a set of the names of fields with getters (actually the names of getter methods with 'get' removed and decapitalised). */
+    private fun TypeElement.getterFieldNames(): Set<String> {
+        val allMembers = processingEnv.elementUtils.getAllMembers(this)
+        return methodsIn(allMembers)
+                .filter { it.simpleName.startsWith("get") && it.parameters.isEmpty() }
+                .map { it.simpleName.toString().substringAfter("get").decapitalize() }
+                .toSet()
+    }
+
     /** Creates a 'build()' function that will invoke a constructor for [returnType], passing [fields] as arguments and returning the new instance. */
     private fun createBuildFunction(fields: List<Element>, returnType: TypeElement): FunSpec {
         val code = StringBuilder("$CHECK_REQUIRED_FIELDS_FUNCTION_NAME()")