RecordBuilder Enhancer

New module to Inject verification, defensive copying, null checks or
custom code into your Java Record constructors during compilation.

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: Randgalt

.github/workflows/maven_java16.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Maven Build - Java 16
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK
+      uses: actions/setup-java@v1
+      with:
+        java-version: 16
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.github/workflows/maven_java17.yml

@@ -0,0 +1,24 @@
+# This workflow will build a Java project with Maven
+# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
+
+name: Maven Build - Java 17
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK
+      uses: actions/setup-java@v1
+      with:
+        java-version: 17
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml

.mvn/jvm.config

@@ -1 +0,0 @@
---enable-preview

.travis.yml

@@ -1,3 +0,0 @@
-language: java
-jdk:
-  - openjdk15

README.md

@@ -1,13 +1,13 @@
-[![Build Status](https://travis-ci.org/Randgalt/record-builder.svg?branch=master)](https://travis-ci.org/Randgalt/record-builder)
-[![Maven Central](https://img.shields.io/maven-central/v/io.soabase.record-builder/record-builder.svg)](https://search.maven.org/search?q=g:io.soabase.record-builder%20a:record-builder)
+[![Build Status](https://github.com/Randgalt/record-builder/workflows/Java%20CI%20with%20Maven/badge.svg)](https://github.com/Randgalt/record-builder/actions)
+[![Maven Central](https://img.shields.io/maven-central/v/io.soabase.record-builder/record-builder.svg?sort=date)](https://search.maven.org/search?q=g:io.soabase.record-builder%20a:record-builder)
 
-# RecordBuilder - Early Access
+# RecordBuilder
 
 ## What is RecordBuilder
 
-Java 15 introduced [Records](https://cr.openjdk.java.net/~briangoetz/amber/datum.html) as a preview feature. Since Java 9, 
-features in Java are being released in stages. While the Java 15 version of records is fantastic, it's currently missing important features 
-for data classes: a builder and "with"ers. This project is an annotation processor that creates:
+Java 16 introduces [Records](https://openjdk.java.net/jeps/395). While this version of records is fantastic, 
+it's currently missing some important features normally found in data classes: a builder 
+and "with"ers. This project is an annotation processor that creates:
  
 - a companion builder class for Java records
 - an interface that adds "with" copy methods
@@ -19,6 +19,10 @@ _Details:_
 - [Wither Details](#Wither-Example)
 - [RecordBuilder Full Definition](#Builder-Class-Definition)
 - [Record From Interface Details](#RecordInterface-Example)
+- [Generation Via Includes](#generation-via-includes)
+- [Usage](#usage)
+- [Customizing](customizing.md) (e.g. add immutable collections, etc.)
+- **_NEW!!_** [RecordBuilder Enhancer](record-builder-enhancer/README.md) - Inject verification, defensive copying, null checks or custom code into your Java Record constructors during compilation!
 
 ## RecordBuilder Example
 
@@ -31,16 +35,21 @@ This will generate a builder class that can be used ala:
 
 ```java
 // build from components
-var n1 = NameAndAgeBuilder.builder().name(aName).age(anAge).build();
+NameAndAge n1 = NameAndAgeBuilder.builder().name(aName).age(anAge).build();
 
 // generate a copy with a changed value
-var n2 = NameAndAgeBuilder.builder(n1).age(newAge).build(); // name is the same as the name in n1
+NameAndAge n2 = NameAndAgeBuilder.builder(n1).age(newAge).build(); // name is the same as the name in n1
 
 // pass to other methods to set components
 var builder = new NameAndAgeBuilder();
 setName(builder);
 setAge(builder);
-var n3 = builder.build();
+NameAndAge n3 = builder.build();
+
+// use the generated static constructor/builder
+import static NameAndAgeBuilder.NameAndAge;
+...
+var n4 = NameAndAge("hey", 42);
 ```
 
 ## Wither Example
@@ -53,21 +62,36 @@ public record NameAndAge(String name, int age) implements NameAndAgeBuilder.With
 In addition to creating a builder, your record is enhanced by "wither" methods ala:
 
 ```java
-var r1 = new NameAndAge("foo", 123);
-var r2 = r1.withName("bar");
-var r3 = r2.withAge(456);
+NameAndAge r1 = new NameAndAge("foo", 123);
+NameAndAge r2 = r1.withName("bar");
+NameAndAge r3 = r2.withAge(456);
 
 // access the builder as well
-var r4 = r3.with().age(101).name("baz").build();
+NameAndAge r4 = r3.with().age(101).name("baz").build();
 
 // alternate method of accessing the builder (note: no need to call "build()")
-var r5 = r4.with(b -> b.age(200).name("whatever"));
+NameAndAge r5 = r4.with(b -> b.age(200).name("whatever"));
+
+// perform some logic in addition to changing values
+NameAndAge r5 = r4.with(b -> {
+   if (b.age() > 13) {
+       b.name("Teen " + b.name());
+   } else {
+       b.name("whatever"));
+   }
+});
+
+// or, if you cannot add the "With" interface to your record...
+NameAndAge r6 = NameAndAgeBuilder.from(r5).with(b -> b.age(200).name("whatever"));
+NameAndAge r7 = NameAndAgeBuilder.from(r5).withName("boop");
 ```
 
 _Hat tip to [Benji Weber](https://benjiweber.co.uk/blog/2020/09/19/fun-with-java-records/) for the Withers idea._
 
 ## Builder Class Definition
 
+(Note: you can see a builder class built using `@RecordBuilderFull` here: [FullRecordBuilder.java](https://gist.github.com/Randgalt/8aa487a847ea2acdd76d702f7cf17d6a))
+
 The full builder class is defined as:
 
 ```java
@@ -84,6 +108,13 @@ public class NameAndAgeBuilder {
         this.age = age;
     }
 
+    /**
+     * Static constructor/builder. Can be used instead of new NameAndAge(...)
+     */
+    public static NameAndAge NameAndAge(String name, int age) {
+        return new NameAndAge(name, age);
+    }
+
     /**
      * Return a new builder with all fields set to default Java values
      */
@@ -98,6 +129,21 @@ public class NameAndAgeBuilder {
         return new NameAndAgeBuilder(from.name(), from.age());
     }
 
+    /**
+     * Return a "with"er for an existing record instance
+     */
+    public static NameAndAgeBuilder.With from(NameAndAge from) {
+        return new _FromWith(from);
+    }
+
+    /**
+     * Return a stream of the record components as map entries keyed with the component name and the value as the component value
+     */
+    public static Stream<Map.Entry<String, Object>> stream(NameAndAge record) {
+        return Stream.of(new AbstractMap.SimpleImmutableEntry<>("name", record.name()),
+                 new AbstractMap.SimpleImmutableEntry<>("age", record.age()));
+    }
+
     /**
      * Return a new record instance with all fields set to the current values in this builder
      */
@@ -105,6 +151,23 @@ public class NameAndAgeBuilder {
         return new NameAndAge(name, age);
     }
 
+    @Override
+    public String toString() {
+        return "NameAndAgeBuilder[name=" + name + ", age=" + age + "]";
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, age);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        return (this == o) || ((o instanceof NameAndAgeBuilder r)
+                && Objects.equals(name, r.name)
+                && (age == r.age));
+    }
+
     /**
      * Set a new value for the {@code name} record component in the builder
      */
@@ -135,49 +198,32 @@ public class NameAndAgeBuilder {
         return age;
     }
 
-    /**
-     * Return a stream of the record components as map entries keyed with the component name and the value as the component value
-     */
-    public static Stream<Map.Entry<String, Object>> stream(NameAndAge record) {
-        return Stream.of(new AbstractMap.SimpleEntry<>("name", record.name()),
-                 new AbstractMap.SimpleEntry<>("age", record.age()));
-    }
-
-    @Override
-    public String toString() {
-        return "NameAndAgeBuilder[name=" + name + ", age=" + age + "]";
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(name, age);
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        return (this == o) || ((o instanceof NameAndAgeBuilder b)
-                && Objects.equals(name, b.name)
-                && (age == b.age));
-    }
-
     /**
      * Add withers to {@code NameAndAge}
      */
     public interface With {
+        /**
+         * Return the current value for the {@code name} record component in the builder
+         */
+        String name();
+
+        /**
+         * Return the current value for the {@code age} record component in the builder
+         */
+        int age();
+
         /**
          * Return a new record builder using the current values
          */
         default NameAndAgeBuilder with() {
-            var r = (NameAndAge)(Object)this;
-            return NameAndAgeBuilder.builder(r);
+            return new NameAndAgeBuilder(name(), age());
         }
 
         /**
          * Return a new record built from the builder passed to the given consumer
          */
         default NameAndAge with(Consumer<NameAndAgeBuilder> consumer) {
-            var r = (NameAndAge)(Object)this;
-            NameAndAgeBuilder builder = NameAndAgeBuilder.builder(r);
+            NameAndAgeBuilder builder = with();
             consumer.accept(builder);
             return builder.build();
         }
@@ -186,16 +232,32 @@ public class NameAndAgeBuilder {
          * Return a new instance of {@code NameAndAge} with a new value for {@code name}
          */
         default NameAndAge withName(String name) {
-            var r = (NameAndAge)(Object)this;
-            return new NameAndAge(name, r.age());
+            return new NameAndAge(name, age());
         }
 
         /**
          * Return a new instance of {@code NameAndAge} with a new value for {@code age}
          */
         default NameAndAge withAge(int age) {
-            var r = (NameAndAge)(Object)this;
-            return new NameAndAge(r.name(), age);
+            return new NameAndAge(name(), age);
+        }
+    }
+
+    private static final class _FromWith implements NameAndAgeBuilder.With {
+        private final NameAndAge from;
+
+        private _FromWith(NameAndAge from) {
+            this.from = from;
+        }
+
+        @Override
+        public String name() {
+            return from.name();
+        }
+
+        @Override
+        public int age() {
+            return from.age();
         }
     }
 }
@@ -230,74 +292,65 @@ Notes:
   - ...cannot have type parameters
 - Methods with default implementations are used in the generation unless they are annotated with `@IgnoreDefaultMethod`
 - If you do not want a record builder generated, annotate your interface as `@RecordInterface(addRecordBuilder = false)`
+- If your interface is a JavaBean (e.g. `getThing()`, `isThing()`) the "get" and "is" prefixes are
+stripped and forwarding methods are added.
+
+## Generation Via Includes
+
+An alternate method of generation is to use the Include variants of the annotations. These variants
+act on lists of specified classes. This allows the source classes to be pristine or even come from
+libraries where you are not able to annotate the source. 
+
+E.g.
+
+```java
+import some.library.code.ImportedRecord
+import some.library.code.ImportedInterface
+
+@RecordBuilder.Include({
+    ImportedRecord.class    // generates a record builder for ImportedRecord  
+})
+@RecordInterface.Include({
+    ImportedInterface.class // generates a record interface for ImportedInterface 
+})
+public void Placeholder {
+}
+```
+
+`@RecordBuilder.Include` also supports a `packages` attribute that includes all records
+in the listed packages.
+
+The target package for generation is the same as the package that contains the "Include"
+annotation. Use `packagePattern` to change this (see Javadoc for details).  
+
+## Enhancer
+
+[RecordBuilder Enhancer](record-builder-enhancer/README.md) - Inject verification, defensive copying, null 
+checks or custom code into your Java Record constructors during compilation. 
 
 ## Usage
 
 ### Maven
 
-1\. Add the dependency that contains the `@RecordBuilder` annotation.
+Add a dependency that contains the discoverable annotation processor:
 
-```
+```xml
 <dependency>
     <groupId>io.soabase.record-builder</groupId>
-    <artifactId>record-builder-core</artifactId>
-    <version>set-version-here</version>
+    <artifactId>record-builder-processor</artifactId>
+    <version>${record.builder.version}</version>
+    <scope>provided</scope>
 </dependency>
-
 ```
 
-2\. Enable the annotation processing for the Maven Compiler Plugin:
-
-```
-<plugin>
-    <groupId>org.apache.maven.plugins</groupId>
-    <artifactId>maven-compiler-plugin</artifactId>
-    <version>set-version-here</version>
-    <configuration>
-        <annotationProcessorPaths>
-            <annotationProcessorPath>
-                <groupId>io.soabase.record-builder</groupId>
-                <artifactId>record-builder-processor</artifactId>
-                <version>set-version-here</version>
-            </annotationProcessorPath>
-        </annotationProcessorPaths>
-        <annotationProcessors>
-            <annotationProcessor>io.soabase.recordbuilder.processor.RecordBuilderProcessor</annotationProcessor>
-        </annotationProcessors>
-
-        
-        <!-- "release" and "enable-preview" are required while records are preview features -->
-        <release>15</release>
-        <compilerArgs>
-            <arg>--enable-preview</arg>
-        </compilerArgs>
-
-        ... any other options here ...
-    </configuration>
-</plugin>
-```
-
-3\. Enable Preview for Maven
-
-Create a file in your project's root named `.mvn/jvm.config`. The file should have 1 line with the value: `--enable-preview`. (see: https://stackoverflow.com/questions/58023240)
-
 ### Gradle
 
 Add the following to your build.gradle file:
 
-```
+```groovy
 dependencies {
     annotationProcessor 'io.soabase.record-builder:record-builder-processor:$version-goes-here'
-    implementation 'io.soabase.record-builder:record-builder-core:$version-goes-here'
-}
-
-tasks.withType(JavaCompile) {
-    options.fork = true
-    options.forkOptions.jvmArgs += '--enable-preview'
-    options.compilerArgs += '--enable-preview'
-}
-tasks.withType(Test) {
-    jvmArgs += "--enable-preview"
+    compileOnly 'io.soabase.record-builder:record-builder-core:$version-goes-here'
 }
 ```
 
@@ -305,34 +358,8 @@ tasks.withType(Test) {
 
 Depending on your IDE you are likely to need to enable Annotation Processing in your IDE settings.
 
-## Enable Preview
-
-Note: records are a preview feature only. You'll need take a number of steps in order to try RecordBuilder:
-
-- Install and make active Java 15 or later
-- Make sure your development tool is using Java 15 or later and is configured to enable preview features (for Maven I've documented how to do this here: [https://stackoverflow.com/a/59363152/2048051](https://stackoverflow.com/a/59363152/2048051))
-- Bear in mind that this is not yet meant for production and there are numerous bugs in the tools and JDKs.
-
-Note: I've seen some very odd compilation bugs with the current Java 15 and Maven. If you get internal Javac errors I suggest rebuilding with `mvn clean package` and/or `mvn clean install`.
-
 ## Customizing
 
-The names of the generated methods, etc. are determined by [RecordBuilderMetaData](https://github.com/Randgalt/record-builder/blob/master/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderMetaData.java). If you want to use your own meta data instance:
-
-- Create a class that implements RecordBuilderMetaData
-- When compiling, make sure that the compiled class is in the processor path
-- Add a "metaDataClass" compiler option with the class name. E.g. `javac ... -AmetaDataClass=foo.bar.MyMetaData`
-
-Alternatively, you can provide values for each individual meta data (or combinations):
-
-- `javac ... -Asuffix=foo`
-- `javac ... -AinterfaceSuffix=foo`
-- `javac ... -AcopyMethodName=foo`
-- `javac ... -AbuilderMethodName=foo`
-- `javac ... -AbuildMethodName=foo`
-- `javac ... -AcomponentsMethodName=foo`
-- `javac ... -AwithClassName=foo`
-- `javac ... -AwithClassMethodPrefix=foo`
-- `javac ... -AfileComment=foo`
-- `javac ... -AfileIndent=foo`
-- `javac ... -AprefixEnclosingClassNames=foo`
+RecordBuilder can be customized to your needs and you can even create your
+own custom RecordBuilder annotations. See [Customizing RecordBuilder](customizing.md)
+for details.

customizing.md

@@ -0,0 +1,95 @@
+[◀︎ RecordBuilder](README.md) • Customizing RecordBuilder
+
+# RecordBuilderFull
+
+Note: `@RecordBuilderFull` has most optional features enabled. It's an alternate
+form of `@RecordBuilder` that uses the [templating mechanism](#create-a-custom-annotation) to
+enable optional features.
+
+# Customizing RecordBuilder
+
+RecordBuilder can be customized in a number of ways. The types of customizations will change over time. See
+[@RecordBuilder.Options](record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java)
+for the current set of customizations and their default values. For example, the `useImmutableCollections` option
+adds special handling for record components of type `java.util.List`, `java.util.Set`, `java.util.Map` and `java.util.Collection`. When the record is built, any components of these types are passed through an added shim method that uses the corresponding immutable collection (e.g. `List.copyOf(o)`) or an empty immutable collection if the component is `null`.
+
+You can:
+
+- [Customize an entire build](#customize-an-entire-build) - all uses of `@RecordBuilder` in your project
+- [Customize a single record](#customize-a-single-record) annotated with `@RecordBuilder`
+- [Create a custom annotation](#create-a-custom-annotation) that specifies your options and use that instead of `@RecordBuilder`
+
+## Customize an entire build
+
+To customize an entire build, use javac's annotation processor options via `-A` on the command line.
+The options available are the same as the attributes in [@RecordBuilder.Options](record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java).
+i.e. to disable "prefixing enclosing class names", compile with:
+
+```shell
+javac -AprefixEnclosingClassNames=false ...
+```
+
+_Note: use a separate `-A` for each option._
+
+#### Maven
+
+If you are using Maven, specify the options in the compiler plugin:
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-compiler-plugin</artifactId>
+    <version>${maven-compiler-plugin-version}</version>
+    <configuration>
+        <compilerArgs>
+            <arg>-AprefixEnclosingClassNames=false</arg>
+            <arg>-AfileComment="something different"</arg>
+        </compilerArgs>
+    </configuration>
+</plugin>
+```
+
+#### Gradle
+
+For Gradle, specify the options:
+
+```groovy
+compilerArgs.addAll(['-AprefixEnclosingClassNames=false', '-AfileComment="something different"'])
+```
+
+## Customize a single record
+
+To customize a single record, add `@RecordBuilder.Options` in addition to
+`@RecordBuilder`.
+
+E.g.
+
+```java
+@RecordBuilder.Options(withClassName = "Wither")
+@RecordBuilder
+public record MyRecord(String s){}
+```
+
+## Create a custom annotation
+
+Using `@RecordBuilder.Template` you can create your own RecordBuilder annotation
+that uses the set of options you want. E.g. to create a custom annotation that
+uses an alternate file comment and an alternate With classname:
+
+```java
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "MyCo license",
+        withClassName = "Wither"
+))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface MyCoRecordBuilder {
+}
+```
+
+Now, you can use `@MyCoRecordBuilder` instead of `@RecordBuilder` and the record
+will be built with options as specified.
+
+Note: the template mechanism also supports `@RecordInterface` templates via the `asRecordInterface` attribute.
+When it is set a `@RecordInterface` template is created instead.

pom.xml

@@ -5,12 +5,16 @@
     <groupId>io.soabase.record-builder</groupId>
     <artifactId>record-builder</artifactId>
     <packaging>pom</packaging>
-    <version>1.11.ea-SNAPSHOT</version>
+    <version>34-SNAPSHOT</version>
 
     <modules>
         <module>record-builder-core</module>
         <module>record-builder-processor</module>
         <module>record-builder-test</module>
+        <module>record-builder-validator</module>
+        <module>record-builder-enhancer</module>
+        <module>record-builder-test-custom-enhancer</module> <!-- must be set to ignore in IntelliJ -->
+        <module>record-builder-enhancer-core</module> <!-- must be set to ignore in IntelliJ -->
     </modules>
 
     <properties>
@@ -18,7 +22,7 @@
         <project.build.resourceEncoding>UTF-8</project.build.resourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
-        <jdk-version>15</jdk-version>
+        <jdk-version>16</jdk-version>
 
         <maven-compiler-plugin-version>3.8.1</maven-compiler-plugin-version>
         <maven-source-plugin-version>3.2.0</maven-source-plugin-version>
@@ -28,13 +32,24 @@
         <maven-gpg-plugin-version>1.6</maven-gpg-plugin-version>
         <maven-javadoc-plugin-version>3.1.1</maven-javadoc-plugin-version>
         <maven-clean-plugin-version>3.1.0</maven-clean-plugin-version>
-        <maven-shade-plugin-version>3.2.1</maven-shade-plugin-version>
+        <maven-shade-plugin-version>3.3.0</maven-shade-plugin-version>
         <maven-release-plugin-version>2.5.3</maven-release-plugin-version>
+        <maven-jar-plugin-version>3.2.0</maven-jar-plugin-version>
         <maven-surefire-plugin-version>3.0.0-M5</maven-surefire-plugin-version>
 
+        <jacoco-maven-plugin-version>0.8.7</jacoco-maven-plugin-version>
+
+        <license-file-path>src/etc/header.txt</license-file-path>
+
         <javapoet-version>1.12.1</javapoet-version>
         <junit-jupiter-version>5.5.2</junit-jupiter-version>
-        <asm-version>7.2</asm-version>
+        <asm-version>9.3</asm-version>
+        <validation-api-version>2.0.1.Final</validation-api-version>
+        <hibernate-validator-version>6.0.20.Final</hibernate-validator-version>
+        <javax-el-version>3.0.1-b09</javax-el-version>
+        <byte-buddy.version>1.12.10</byte-buddy.version>
+        <guava.version>31.1-jre</guava.version>
+        <picocli.version>4.6.3</picocli.version>
     </properties>
 
     <name>Record Builder</name>
@@ -71,7 +86,7 @@
         <url>https://github.com/randgalt/record-builder</url>
         <connection>scm:git:https://github.com/randgalt/record-builder.git</connection>
         <developerConnection>scm:git:git@github.com:randgalt/record-builder.git</developerConnection>
-        <tag>HEAD</tag>
+        <tag>record-builder-1.16</tag>
     </scm>
 
     <issueManagement>
@@ -94,6 +109,18 @@
 
     <dependencyManagement>
         <dependencies>
+            <dependency>
+                <groupId>net.bytebuddy</groupId>
+                <artifactId>byte-buddy</artifactId>
+                <version>${byte-buddy.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>net.bytebuddy</groupId>
+                <artifactId>byte-buddy-agent</artifactId>
+                <version>${byte-buddy.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>com.squareup</groupId>
                 <artifactId>javapoet</artifactId>
@@ -106,26 +133,101 @@
                 <version>${project.version}</version>
             </dependency>
 
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-enhancer</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-enhancer-core</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-processor</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-test-custom-enhancer</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-validator</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+
             <dependency>
                 <groupId>org.junit.jupiter</groupId>
                 <artifactId>junit-jupiter</artifactId>
                 <version>${junit-jupiter-version}</version>
             </dependency>
+
+            <dependency>
+                <groupId>javax.validation</groupId>
+                <artifactId>validation-api</artifactId>
+                <version>${validation-api-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.hibernate.validator</groupId>
+                <artifactId>hibernate-validator</artifactId>
+                <version>${hibernate-validator-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.glassfish</groupId>
+                <artifactId>javax.el</artifactId>
+                <version>${javax-el-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>com.google.guava</groupId>
+                <artifactId>guava</artifactId>
+                <version>${guava.version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.ow2.asm</groupId>
+                <artifactId>asm</artifactId>
+                <version>${asm-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>org.ow2.asm</groupId>
+                <artifactId>asm-tree</artifactId>
+                <version>${asm-version}</version>
+            </dependency>
+
+            <dependency>
+                <groupId>info.picocli</groupId>
+                <artifactId>picocli</artifactId>
+                <version>${picocli.version}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
     <build>
         <pluginManagement>
             <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>${maven-surefire-plugin-version}</version>
+                </plugin>
+
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>${maven-compiler-plugin-version}</version>
                     <configuration>
                         <release>${jdk-version}</release>
-                        <compilerArgs>
-                            <arg>--enable-preview</arg>
-                        </compilerArgs>
                     </configuration>
                 </plugin>
 
@@ -157,7 +259,7 @@
                     <artifactId>maven-license-plugin</artifactId>
                     <version>${maven-license-plugin-version}</version>
                     <configuration>
-                        <header>src/etc/header.txt</header>
+                        <header>${license-file-path}</header>
                         <excludes>
                             <exclude>**/*.apt</exclude>
                             <exclude>**/*.md</exclude>
@@ -180,9 +282,12 @@
                             <exclude>**/io/soabase/com/google/**</exclude>
                             <exclude>**/com/company/**</exclude>
                             <exclude>**/META-INF/services/**</exclude>
+                            <exclude>**/safe/**</exclude>
                             <exclude>**/jvm.config</exclude>
                             <exclude>**/.java-version</exclude>
                             <exclude>**/.travis.yml</exclude>
+                            <exclude>**/gradlew</exclude>
+                            <exclude>**/.github/**</exclude>
                         </excludes>
                         <strictCheck>true</strictCheck>
                     </configuration>
@@ -223,44 +328,6 @@
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-shade-plugin</artifactId>
                     <version>${maven-shade-plugin-version}</version>
-                    <configuration>
-                        <createDependencyReducedPom>true</createDependencyReducedPom>
-                        <dependencyReducedPomLocation>${project.build.outputDirectory}/META-INF/reduced-pom.xml</dependencyReducedPomLocation>
-                        <filters>
-                            <filter>
-                                <excludes>
-                                    <exclude>META-INF/*.SF</exclude>
-                                    <exclude>META-INF/*.DSA</exclude>
-                                    <exclude>META-INF/*.RSA</exclude>
-                                </excludes>
-                            </filter>
-                        </filters>
-                    </configuration>
-                    <executions>
-                        <execution>
-                            <phase>package</phase>
-                            <goals>
-                                <goal>shade</goal>
-                            </goals>
-                            <configuration>
-                                <transformers>
-                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
-                                </transformers>
-                            </configuration>
-                        </execution>
-                    </executions>
-                    <dependencies>
-                        <dependency>
-                            <groupId>org.ow2.asm</groupId>
-                            <artifactId>asm</artifactId>
-                            <version>${asm-version}</version>
-                        </dependency>
-                        <dependency>
-                            <groupId>org.ow2.asm</groupId>
-                            <artifactId>asm-commons</artifactId>
-                            <version>${asm-version}</version>
-                        </dependency>
-                    </dependencies>
                 </plugin>
 
                 <plugin>
@@ -275,11 +342,20 @@
 
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
-                    <artifactId>maven-surefire-plugin</artifactId>
-                    <version>${maven-surefire-plugin-version}</version>
-                    <configuration>
-                        <argLine>--enable-preview</argLine>
-                    </configuration>
+                    <artifactId>maven-jar-plugin</artifactId>
+                    <version>${maven-jar-plugin-version}</version>
+                </plugin>
+
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-gpg-plugin</artifactId>
+                    <version>${maven-gpg-plugin-version}</version>
+                </plugin>
+
+                <plugin>
+                    <groupId>org.jacoco</groupId>
+                    <artifactId>jacoco-maven-plugin</artifactId>
+                    <version>${jacoco-maven-plugin-version}</version>
                 </plugin>
             </plugins>
         </pluginManagement>
@@ -314,6 +390,11 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-release-plugin</artifactId>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+            </plugin>
         </plugins>
     </build>
 
@@ -324,7 +405,6 @@
                 <plugins>
                     <plugin>
                         <artifactId>maven-gpg-plugin</artifactId>
-                        <version>${maven-gpg-plugin-version}</version>
                         <configuration>
                             <passphrase>${gpg.passphrase}</passphrase>
                             <useAgent>true</useAgent>

record-builder-core/pom.xml

@@ -3,9 +3,29 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.11.ea-SNAPSHOT</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-core</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifestEntries>
+                            <Automatic-Module-Name>io.soabase.recordbuilder.core</Automatic-Module-Name>
+                        </manifestEntries>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 </project>

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java

@@ -15,12 +15,251 @@
  */
 package io.soabase.recordbuilder.core;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
+@Inherited
 public @interface RecordBuilder {
+    @Target({ElementType.TYPE, ElementType.PACKAGE})
+    @Retention(RetentionPolicy.SOURCE)
+    @Inherited
+    @interface Include {
+        /**
+         * @return list of classes to include
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * Synonym for {@code value()}. When using the other attributes it maybe more clear to
+         * use {@code classes()} instead of {@code value()}. Note: both attributes are applied
+         * (i.e. a union of classes from both attributes).
+         *
+         * @return list of classes
+         */
+        Class<?>[] classes() default {};
+
+        /**
+         * Optional list of package names. All records in the packages will get processed as
+         * if they were listed as classes to include.
+         *
+         * @return list of package names
+         */
+        String[] packages() default {};
+
+        /**
+         * Pattern used to generate the package for the generated class. The value
+         * is the literal package name however two replacement values can be used. '@'
+         * is replaced with the package of the {@code Include} annotation. '*' is replaced with
+         * the package of the included class.
+         *
+         * @return package pattern
+         */
+        String packagePattern() default "@";
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @Target(ElementType.TYPE)
+    @Inherited
+    @interface Options {
+        /**
+         * The builder class name will be the name of the record (prefixed with any enclosing class) plus this suffix. E.g.
+         * if the record name is "Foo", the builder will be named "FooBuilder".
+         */
+        String suffix() default "Builder";
+
+        /**
+         * Used by {@code RecordInterface}. The generated record will have the same name as the annotated interface
+         * plus this suffix. E.g. if the interface name is "Foo", the record will be named "FooRecord".
+         */
+        String interfaceSuffix() default "Record";
+
+        /**
+         * The name to use for the copy builder
+         */
+        String copyMethodName() default "builder";
+
+        /**
+         * The name to use for the builder
+         */
+        String builderMethodName() default "builder";
+
+        /**
+         * The name to use for the build method
+         */
+        String buildMethodName() default "build";
+
+        /**
+         * The name to use for the from-to-wither method
+         */
+        String fromMethodName() default "from";
+
+        /**
+         * The name to use for the method that returns the record components as a stream
+         */
+        String componentsMethodName() default "stream";
+
+        /**
+         * If true, a "With" interface is generated and an associated static factory
+         */
+        boolean enableWither() default true;
+
+        /**
+         * The name to use for the nested With class
+         */
+        String withClassName() default "With";
+
+        /**
+         * The prefix to use for the methods in the With class
+         */
+        String withClassMethodPrefix() default "with";
+
+        /**
+         * Return the comment to place at the top of generated files. Return null or an empty string for no comment.
+         */
+        String fileComment() default "Auto generated by io.soabase.recordbuilder.core.RecordBuilder: https://github.com/Randgalt/record-builder";
+
+        /**
+         * Return the file indent to use
+         */
+        String fileIndent() default "    ";
+
+        /**
+         * If the record is declared inside of another class, the outer class's name will
+         * be prefixed to the builder name if this returns true.
+         */
+        boolean prefixEnclosingClassNames() default true;
+
+        /**
+         * If true, any annotations (if applicable) on record components are copied
+         * to the builder methods
+         *
+         * @return true/false
+         */
+        boolean inheritComponentAnnotations() default true;
+
+        /**
+         * Set the default value of {@code Optional} record components to
+         * {@code Optional.empty()}
+         */
+        boolean emptyDefaultForOptional() default true;
+
+        /**
+         * Add non-optional setter methods for optional record components.
+         */
+        boolean addConcreteSettersForOptional() default false;
+
+        /**
+         * Add not-null checks for record components annotated with any annotation named either "NotNull",
+         * "NoNull", or "NonNull" (see {@link #interpretNotNullsPattern()} for the actual regex matching pattern).
+         */
+        boolean interpretNotNulls() default false;
+
+        /**
+         * If {@link #interpretNotNulls()} is true, this is the regex pattern used to determine if an annotation name
+         * means "not null"
+         */
+        String interpretNotNullsPattern() default "(?i)((notnull)|(nonnull)|(nonull))";
+
+        /**
+         * <p>Pass built records through the Java Validation API if it's available in the classpath.</p>
+         *
+         * <p>IMPORTANT:
+         * if this option is enabled you must include the {@code record-builder-validator} dependency in addition
+         * to {@code record-builder-core}. {@code record-builder-validator} is implemented completely via reflection and
+         * does not require other dependencies. Alternatively, you can define your own class with the package {@code package io.soabase.recordbuilder.validator;}
+         * named {@code RecordBuilderValidator} which has a public static method: {@code public static <T> T validate(T o)}.</p>
+         */
+        boolean useValidationApi() default false;
+
+        /**
+         * Adds special handling for record components of type {@link java.util.List}, {@link java.util.Set},
+         * {@link java.util.Map} and {@link java.util.Collection}. When the record is built, any components
+         * of these types are passed through an added shim method that uses the corresponding immutable collection
+         * (e.g. {@code List.copyOf(o)}) or an empty immutable collection if the component is {@code null}.
+         */
+        boolean useImmutableCollections() default false;
+
+        /**
+         * When enabled, collection types ({@code List}, {@code Set} and {@code Map}) are handled specially.
+         * The setters for these types now create an internal collection and items are added to that
+         * collection. Additionally, "adder" methods prefixed with {@link #singleItemBuilderPrefix()} are created
+         * to add single items to these collections.
+         */
+        boolean addSingleItemCollectionBuilders() default false;
+
+        /**
+         * The prefix for adder methods when {@link #addSingleItemCollectionBuilders()} is enabled
+         */
+        String singleItemBuilderPrefix() default "add";
+
+        /**
+         * When enabled, adds functional methods to the nested "With" class (such as {@code map()} and {@code accept()}).
+         */
+        boolean addFunctionalMethodsToWith() default false;
+
+        /**
+         * If set, all builder setter methods will be prefixed with this string. Camel-casing will
+         * still be enforced, so if this option is set to "set" a field named "myField" will get
+         * a corresponding setter named "setMyField".
+         */
+        String setterPrefix() default "";
+
+        /**
+         * If true, getters will be generated for the Builder class.
+         */
+        boolean enableGetters() default true;
+
+        /**
+         * If set, all builder getter methods will be prefixed with this string. Camel-casing will
+         * still be enforced, so if this option is set to "get", a field named "myField" will get
+         * a corresponding getter named "getMyField".
+         */
+        String getterPrefix() default "";
+
+        /**
+         * If set, all boolean builder getter methods will be prefixed with this string.
+         * Camel-casing will still be enforced, so if this option is set to "is", a field named
+         * "myField" will get a corresponding getter named "isMyField".
+         */
+        String booleanPrefix() default "";
+
+        /**
+         * If set, the Builder will contain an internal interface with this name. This interface
+         * contains getters for all the fields in the Record prefixed with the value supplied in
+         * {@link this.getterPrefix} and {@link this.booleanPrefix}. This interface can be
+         * implemented by the original Record to have proper bean-style prefixed getters.
+         *
+         * Please note that unless either of the aforementioned prefixes are set,
+         * this option does nothing.
+         */
+        String beanClassName() default "";
+
+        /**
+         * If true, generated classes are annotated with {@code RecordBuilderGenerated} which has a retention
+         * policy of {@code CLASS}. This ensures that analyzers such as Jacoco will ignore the generated class.
+         */
+        boolean addClassRetainedGenerated() default false;
+
+        /**
+         * The {@link #fromMethodName} method instantiates an internal private class. This is the
+         * name of that class.
+         */
+        String fromWithClassName() default "_FromWith";
+
+        /**
+         * If true, a functional-style builder is added so that record instances can be instantiated
+         * without {@code new}.
+         */
+        boolean addStaticBuilder() default true;
+    }
+
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    @interface Template {
+        RecordBuilder.Options options();
+
+        boolean asRecordInterface() default false;
+    }
 }

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderFull.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.core;
+
+import java.lang.annotation.*;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        interpretNotNulls = true,
+        useImmutableCollections = true,
+        addSingleItemCollectionBuilders = true,
+        addFunctionalMethodsToWith = true,
+        addClassRetainedGenerated = true
+))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+/**
+ * An alternate form of {@code @RecordBuilder} that has most
+ * optional features turned on
+ */
+public @interface RecordBuilderFull {
+}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderGenerated.java

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.core;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+
+/**
+ * Jacoco ignores classes and methods annotated with `*Generated`
+ */
+@Target({PACKAGE, TYPE, METHOD, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, PARAMETER})
+@Retention(RetentionPolicy.CLASS)
+public @interface RecordBuilderGenerated {
+}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderMetaData.java

@@ -1,135 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.core;
-
-public interface RecordBuilderMetaData {
-    /**
-     * If you want to use your own meta data instance:
-     * <ul>
-     *     <li>create a class that implements {@code RecordBuilderMetaData}</li>
-     *     <li>When compiling, make sure that compiled class is in the processor path</li>
-     *     <li>Add a "metaDataClass" compiler option with the class name. E.g. {@code javac ... -AmetaDataClass=foo.bar.MyMetaData}</li>
-     * </ul>
-     */
-    String JAVAC_OPTION_NAME = "metaDataClass";
-
-    /**
-     * The default meta data instance
-     */
-    RecordBuilderMetaData DEFAULT = new RecordBuilderMetaData() {};
-
-    /**
-     * The builder class name will be the name of the record (prefixed with any enclosing class) plus this suffix. E.g.
-     * if the record name is "Foo", the builder will be named "FooBuilder".
-     *
-     * @return suffix
-     */
-    default String suffix() {
-        return "Builder";
-    }
-
-    /**
-     * Used by {@code RecordInterface}. The generated record will have the same name as the annotated interface
-     * plus this suffix. E.g. if the interface name is "Foo", the record will be named "FooRecord".
-     *
-     * @return suffix
-     */
-    default String interfaceSuffix() {
-        return "Record";
-    }
-
-    /**
-     * The name to use for the copy builder
-     *
-     * @return copy builder name
-     */
-    default String copyMethodName() {
-        return builderMethodName();
-    }
-
-    /**
-     * The name to use for the builder
-     *
-     * @return builder name
-     */
-    default String builderMethodName() {
-        return "builder";
-    }
-
-    /**
-     * The name to use for the build method
-     *
-     * @return build method
-     */
-    default String buildMethodName() {
-        return "build";
-    }
-
-    /**
-     * The name to use for the method that returns the record components as a stream
-     *
-     * @return build method
-     */
-    default String componentsMethodName() {
-        return "stream";
-    }
-
-    /**
-     * The name to use for the nested With class
-     *
-     * @return with class name
-     */
-    default String withClassName() {
-        return "With";
-    }
-
-    /**
-     * The prefix to use for the methods in the With class
-     *
-     * @return prefix
-     */
-    default String withClassMethodPrefix() {
-        return "with";
-    }
-
-    /**
-     * Return the comment to place at the top of generated files. Return null or an empty string for no comment.
-     *
-     * @return comment or empty
-     */
-    default String fileComment() {
-        return "Auto generated by io.soabase.recordbuilder.core.RecordBuilder: https://github.com/Randgalt/record-builder";
-    }
-
-    /**
-     * Return the file indent to use
-     *
-     * @return file index
-     */
-    default String fileIndent() {
-        return "    ";
-    }
-
-    /**
-     * If the record is declared inside of another class, the outer class's name will
-     * be prefixed to the builder name if this returns true.
-     *
-     * @return true/false
-     */
-    default boolean prefixEnclosingClassNames() {
-        return true;
-    }
-}

record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordInterface.java

@@ -15,13 +15,47 @@
  */
 package io.soabase.recordbuilder.core;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.lang.annotation.*;
 
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
+@Inherited
 public @interface RecordInterface {
     boolean addRecordBuilder() default true;
+
+    @Target({ElementType.TYPE, ElementType.PACKAGE})
+    @Retention(RetentionPolicy.SOURCE)
+    @Inherited
+    @interface Include {
+        /**
+         * @return list of classes to include
+         */
+        Class<?>[] value() default {};
+
+        /**
+         * Synonym for {@code value()}. When using the other attributes it maybe more clear to
+         * use {@code classes()} instead of {@code value()}. Note: both attributes are applied
+         * (i.e. a union of classes from both attributes).
+         *
+         * @return list of classes
+         */
+        Class<?>[] classes() default {};
+
+        /**
+         * If true the generated record is annotated with {@code @RecordBuilder}
+         *
+         * @return true/false
+         */
+        boolean addRecordBuilder() default true;
+
+        /**
+         * Pattern used to generate the package for the generated class. The value
+         * is the literal package name however two replacement values can be used. '@'
+         * is replaced with the package of the {@code Include} annotation. '*' is replaced with
+         * the package of the included class.
+         *
+         * @return package pattern
+         */
+        String packagePattern() default "@";
+    }
 }

record-builder-enhancer-core/pom.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-enhancer-core</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm-tree</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <createDependencyReducedPom>true</createDependencyReducedPom>
+                    <dependencyReducedPomLocation>${project.build.directory}/dependency-reduced-pom.xml</dependencyReducedPomLocation>
+                    <useDependencyReducedPomInJar>true</useDependencyReducedPomInJar>
+                    <relocations>
+                        <relocation>
+                            <pattern>org.objectweb</pattern>
+                            <shadedPattern>recordbuilder.org.objectweb</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <transformers>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+                    </transformers>
+                    <filters>
+                        <filter>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhance.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface RecordBuilderEnhance {
+    Class<? extends RecordBuilderEnhancer>[] enhancers();
+
+    RecordBuilderEnhanceArguments[] arguments() default {};
+
+    @Retention(RetentionPolicy.CLASS)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    @interface Template {
+        Class<? extends RecordBuilderEnhancer>[] enhancers();
+
+        RecordBuilderEnhanceArguments[] arguments() default {};
+    }
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhanceArguments.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface RecordBuilderEnhanceArguments {
+    Class<? extends RecordBuilderEnhancer> enhancer();
+
+    String[] arguments();
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/Entry.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import javax.lang.model.element.RecordComponentElement;
+import javax.lang.model.type.TypeMirror;
+
+public record Entry(int parameterIndex, RecordComponentElement element, TypeMirror erasedType) {
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/Processor.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import java.util.List;
+
+public interface Processor {
+    Elements elements();
+
+    Types types();
+
+    boolean hasEnhancer(Class<? extends RecordBuilderEnhancer> enhancer);
+
+    boolean verboseRequested();
+
+    void logInfo(CharSequence msg);
+
+    void logWarning(CharSequence msg);
+
+    void logError(CharSequence msg);
+
+    List<Entry> asEntries(TypeElement element);
+}

record-builder-enhancer-core/src/main/java/io/soabase/recordbuilder/enhancer/spi/RecordBuilderEnhancer.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.spi;
+
+import org.objectweb.asm.tree.InsnList;
+
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+
+@FunctionalInterface
+public interface RecordBuilderEnhancer {
+    InsnList enhance(Processor processor, TypeElement element, List<String> arguments);
+}

record-builder-enhancer/README.md

@@ -0,0 +1,454 @@
+# RecordBuilder Enhancer
+
+## What is RecordBuilder Enhancer
+
+Inject verification, defensive copying, null checks or custom code into your Java Record constructors during compilation.
+
+#### Features:
+
+- [Builtin enhancers](#builtin-enhancers) to help with null checks and defensive copying
+- [SPI](#write-your-own-custom-enhancer) for writing your own [custom enhancers](#write-your-own-custom-enhancer)
+- [Create a custom annotation](#create-a-custom-annotation) that specifies a custom set of enhancers
+ 
+#### Is it safe? Does it use undocumented features of Java?
+
+- The Enhancer modifies your Java class files. There are some inherent safety concerns with this. However:
+  - The industry standard [ASM](https://asm.ow2.io) library is used to do the modifications. ASM is even used in the JDK itself.
+  - The Enhancer only inserts code in the default constructor of Java records. The code is inserted just after the
+    call to `super()` and before any existing code in the constructor.
+  - It's implemented as a standard [javac plugin](https://docs.oracle.com/en/java/javase/16/docs/api/jdk.compiler/com/sun/source/util/Plugin.html) and uses no undocumented features
+- If you don't like the builtin enhancers you can [write your own](#write-your-own-custom-enhancer)
+
+#### How does it relate to [RecordBuilder](../README.md)?
+
+They aren't directly related but they share some code and both work on java records.
+
+#### Why RecordBuilder Enhancer?
+
+Java Records are fantastic data carriers and solve much of the pain of the lack of these types of classes
+in older versions of Java. [RecordBuilder](../README.md) adds builders and withers to records. However,
+records are still missing simple `null` checks and a few other niceties. This means boilerplate
+for every record. RecordBuilder Enhancer is targeted at being able to write Java records without having to add
+any additional code.
+
+## How to Use RecordBuilder Enhancer
+
+First, configure your build environment: see [details below](#javac-plugin). Then, use the Enhancer's
+annotations to specify Java records that you want to be enhanced.
+
+```java
+@RecordBuilderEnhance(enhancers = RequireNonNull.class)
+public record MyRecord(String s, List<String> l) {
+}
+```
+
+Enhancer inserts code into the default constructor as if you wrote this:
+
+```java
+public record MyRecord(String s, List<String> l) {
+    public MyRecord {
+        Objects.requireNonNull(s, "s is null");
+        Objects.requireNonNull(l, "l is null");
+    }
+}
+```
+
+The class file will be updated like this:
+
+![](disassembly1.png)
+
+Enhancers are applied in the order listed in the annotation. E.g.
+
+```java
+// will apply RequireNonNull and then CopyCollection
+@RecordBuilderEnhance(enhancers = {RequireNonNull.class, CopyCollection.class})
+public record MyRecord(List<String> l) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(List<String> l) {
+    Objects.requireNonNull(l);
+    l = List.copyOf(l);
+}
+```
+
+#### Arguments
+
+Enhancers can optional receive arguments (the builtin [NotNullAnnotations](#notnullannotations) does). Use `@RecordBuilderEnhanceArguments`
+to pass arguments. E.g.
+
+```java
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class, 
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "altnonnull"))
+public record MyRecord(@AltNonNull List<String> l) {}
+```
+
+
+## Builtin Enhancers
+
+| ID                                                                    | Arguments             | Description                                                                                                                                                                                                                                                   |
+|-----------------------------------------------------------------------|-----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [EmptyNullOptional](#emptynulloptional)                               | -                     | Use `empty()` for null Optional/OptionalInt/OptionalLong/OptionalDouble record components                                                                                                                                                                     |
+| [EmptyNullString](#emptynullstring)                                   | -                     | Use `""` for null String record components                                                                                                                                                                                                                    |
+| [CopyCollection](#copycollection)                                     | -                     | Make defensive copies of Collection, List and Map record components                                                                                                                                                                                           |
+| [CopyCollectionNullableEmpty](#copycollectionnullableempty)           | -                     | Make defensive copies of Collection, List and Map record components or empty collections when `null`                                                                                                                                                          |
+| [GuavaCopyCollection](#guavacopycollection)                           | -                     | Same as CopyCollection but uses Google Guava collections                                                                                                                                                                                                      |
+| [GuavaCopyCollectionNullableEmpty](#guavacopycollectionnullableempty) | -                     | Same as CopyCollectionNullableEmpty but uses Google Guava collections                                                                                                                                                                                         |
+| [RequireNonNull](#requirenonnull)                                     | -                     | Call `requireNonNull()` on all non-primitive record components - note: checks other enhancers and doesn't apply to Strings if EmptyNullString is being used, etc.                                                                                             |
+| [NotNullAnnotations](#notnullannotations)                             | expression (optional) | Any parameter with an annotation whose name matches this enhancer's regular expression argument will be passed to `requireNonNull()`. The argument is optional. If not supplied then _(notnull)&#124;(nonnull)_ is used. Matching is always case insensitive. |
+
+### Examples
+
+#### EmptyNullOptional
+
+```java
+@RecordBuilderEnhance(enhancers = EmptyNullOptional.class)
+public record MyRecord(Optional<String> s, OptionalInt i) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(Optional<String> s, OptionalInt i) {
+    public MyRecord {
+        s = (s != null) ? s : Optional.empty();
+        i = (i != null) ? i : OptionalInt.empty();
+    }
+}
+```
+
+-------
+
+#### EmptyNullString
+
+```java
+@RecordBuilderEnhance(enhancers = EmptyNullString.class)
+public record MyRecord(String s) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        s = (s != null) ? s : "";
+    }
+}
+```
+
+-------
+
+#### CopyCollection
+
+```java
+@RecordBuilderEnhance(enhancers = CopyCollection.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = Set.copyOf(c);
+        s = Set.copyOf(s);
+        l = List.copyOf(l);
+        m = Map.copyOf(m);
+    }
+}
+```
+
+-------
+
+#### CopyCollectionNullableEmpty
+
+```java
+@RecordBuilderEnhance(enhancers = CopyCollectionNullableEmpty.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = (c != null) ? Set.copyOf(c) : Set.of();
+        s = (s != null) ? Set.copyOf(s) : Set.of();
+        l = (l != null) ? List.copyOf(l) : List.of();
+        m = (m != null) ? Map.copyOf(m) : Map.of();
+    }
+}
+```
+
+-------
+
+#### GuavaCopyCollection
+
+```java
+@RecordBuilderEnhance(enhancers = GuavaCopyCollection.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = ImmutableSet.copyOf(c);
+        s = ImmutableSet.copyOf(s);
+        l = ImmutableList.copyOf(l);
+        m = Map.copyOf(m);
+    }
+}
+```
+
+-------
+
+#### GuavaCopyCollectionNullableEmpty
+
+```java
+@RecordBuilderEnhance(enhancers = GuavaCopyCollectionNullableEmpty.class)
+public record MyRecord(Collection<String> c, Set<String> s, List<String> l, Map<String, String> m) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s) {
+    public MyRecord {
+        c = (c != null) ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+        s = (s != null) ? ImmutableSet.copyOf(s) : ImmutableSet.of();
+        l = (l != null) ? ImmutableList.copyOf(l) : ImmutableList.of();
+        m = (m != null) ? ImmutableMap.copyOf(m) : ImmutableMap.of();
+    }
+}
+```
+
+-------
+
+#### RequireNonNull
+
+```java
+@RecordBuilderEnhance(enhancers = RequireNonNull.class)
+public record MyRecord(String s, Instant t) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s, Instant t) {
+    public MyRecord {
+        Objects.requireNonNull(s, "s is null");
+        Objects.requireNonNull(t, "t is null");
+    }
+}
+```
+
+-------
+
+#### NotNullAnnotations
+
+```java
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class,
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "(notnull)|(mynil)"))
+public record MyRecord(String s, @NotNull Instant t, @MyNil Thing thing) {}
+```
+
+_becomes_
+
+```java
+public record MyRecord(String s, @NotNull Instant t, @MyNil Thing thing) {
+    public MyRecord {
+        Objects.requireNonNull(t, "t is null");
+        Objects.requireNonNull(thing, "thing is null");
+    }
+}
+```
+
+## Create A Custom Annotation
+
+Using `@RecordBuilderEnhance.Template` you can create your own RecordBuilderEnhance annotation that always uses the set of enhancers that you want. 
+
+```java
+@RecordBuilderEnhance.Template(enhancers = {RequireNonNull.class, NotNullAnnotations.class},
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = "altnonnull.*"))
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface MyCoEnhance {
+}
+```
+
+Now, you can use `@MyCoEnhance` instead of `@RecordBuilderEnhance` and the record will be enhanced with the enhancers specified.
+
+## Javac Plugin
+
+Add a dependency that contains the discoverable javac plugin to your build tool (see below for [Maven](#maven) or [Gradle](#gradle)). javac will
+auto discover the Enhancer plugin. By default the enhancer assumes the standard directory layout used by
+most Java build systems. i.e. if a Java source file is at `/foo/bar/myproject/src/main/java/my/package/MyClass.java`
+the Enhancer will assume that the compiled class file for that source file will be found at
+`/foo/bar/myproject/target/classes/my/package/MyClass.class`. If your build system does not use this method then
+the Enhancer will need additional configuration ([see below](#options)). You can also 
+configure some of the behavior of the Enhancer ([see below](#options)).
+
+### Maven
+
+```xml
+<!-- only needed during compilation -->
+<dependency>
+    <groupId>io.soabase.record-builder</groupId>
+    <artifactId>record-builder-enhancer</artifactId>
+    <version>${record.builder.version}</version>
+    <scope>provided</scope>
+</dependency>
+
+<!-- contains the annotations -->
+<dependency>
+    <groupId>io.soabase.record-builder</groupId>
+    <artifactId>record-builder-enhancer-core</artifactId>
+    <version>${record.builder.version}</version>
+</dependency>
+```
+
+### Gradle
+
+```groovy
+dependencies {
+  compileOnly 'io.soabase.record-builder:record-builder-enhancer:$version-goes-here'
+  api 'io.soabase.record-builder:record-enhancer-core:$version-goes-here'
+}
+```
+
+### Options
+
+For normal usage you won't need to set any options for the Enhancer. The following options are available if you need them:
+
+```text
+[-hv] [--disable] [--dryRun] [--outputDirectory=<outputTo>] [DIRECTORY]
+
+      [DIRECTORY]   The build's output directory - i.e. where javac writes generated classes. 
+                    The value can be a full path or a relative path. If not provided the Enhancer 
+                    plugin will attempt to use standard directories.
+      --disable     Deactivate/disable the plugin
+      --dryRun      Dry run only - doesn't modify any classes. You should enable verbose as well via: -v
+  -h, --help        Outputs this help
+      --outputDirectory=<outputTo>
+                    Optional alternate output directory for enhanced class files
+  -v, --verbose     Verbose output during compilation
+```
+
+javac plugin options are specifed on the javac command line or as part of your build tool. On the command line:
+
+```shell
+javac -Xplugin:"recordbuilderenhancer ...arguments..."
+```
+
+In Maven:
+
+```xml
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-compiler-plugin</artifactId>
+    <configuration>
+        <compilerArgument>-Xplugin:recordbuilderenhancer ...arguments...</compilerArgument>
+    </configuration>
+</plugin>
+```
+
+## Write Your Own Custom Enhancer
+
+Notes on writing your own enhancer:
+
+- Custom Enhancers must be built as separate modules from the code base you want to enhance. This is because
+the enhancers must be available during compilation.
+- You should somewhat be familiar with Java's AST classes though they are not hard to understand for newcomers
+- Enhancers use the [ASM library](https://asm.ow2.io) to produce a list of statements to be inserted into Java record constructors
+- You will need some knowledge of Java bytecode specifics and the Java Language specification. However, it's pretty simple
+to use javac and javap to show you what bytecodes you need to specify ([see below](#how-to-get-the-bytecodes-for-your-enhancer))
+- **IMPORTANT** - the ASM library has been shaded into the RecordBuilder Enhancer JAR. Make sure your custom enhancer uses the ASM classes
+that are in the package `recordbuilder.org.objectweb.asm.*`. Many libraries use ASM and you may see the same classes in multiple packages.
+
+For reference look at the implementation of the builtin enhancers to see exactly how to write one. [EmptyNullString](src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java)
+is a simple one to use as an example.
+
+#### Add the SPI to your build
+
+The RecordBuilder Enhancer SPI must be added to the module for your custom enhancer. It's artifact ID is `record-builder-enhancer-core`.
+Your enhancer module can contain as many enhancers as you want. Each enhancer must implement the following interface:
+
+```java
+public interface RecordBuilderEnhancer {
+    InsnList enhance(Processor processor, TypeElement element, List<String> arguments);
+}
+```
+
+Your custom enhancer is called for Java records that are annotated to list your enhancer class.
+Your enhancer is created once during the start of the build process and will be called multiple times for each Java record
+that is annotated with your enhancer. Your enhancer must return a list of instructions to insert or an empty list.
+The `element` parameter refers to the Java record being currently compiled. `arguments` are any arguments specified in the annotation
+for the Java record. `Processor` holds utilities useful during enhancing. Look at the builtin enhancers to see details on how to write
+them - [EmptyNullString](src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java) is a good one to start with.
+
+Build and install your enhancer JAR and you can then use your new custom enhancer as a dependency in other projects and it will be available as an enhancer.
+Alternatively, if you have a multi-module build your enhancer can be a module and used to enhance the other modules in the
+project. The [record-builder-test-custom-enhancer](../record-builder-test-custom-enhancer) does this.
+
+#### How to get the bytecodes for your enhancer
+
+The trick for getting the bytecodes for your enhancer is to write a simple Java source file that does what you want and then 
+use the java tools to get the bytecodes. For example, let's say you want a custom enhancer that outputs the current date and time to standard 
+out.
+
+Create a text file called "Temp.java" ala:
+
+```java
+import java.time.Instant;
+
+public class Temp {
+  public Temp() {
+    System.out.println(Instant.now());
+  }
+}
+```
+
+From a terminal compile the class:
+
+```shell
+javac Temp.java
+```
+
+Then dump the java bytecodes from the compiled class:
+
+```shell
+javap -c Temp.class
+```
+
+You will see:
+
+```text
+Compiled from "Temp.java"
+public class Temp {
+  public Temp();
+    Code:
+       0: aload_0
+       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
+       4: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
+       7: invokestatic  #13                 // Method java/time/Instant.now:()Ljava/time/Instant;
+      10: invokevirtual #19                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
+      13: return
+}
+```
+
+The first two lines are the call to `super()`. The lines labeld `4`, `7`, and `10` are the bytecodes that you want for your enhancer.
+
+Your enhance() implementation would look like this:
+
+```java
+InsnList insnList = new InsnList();
+insnList.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"));
+insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/time/Instant", "now", "()Ljava/time/Instant;"));
+insnList.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/Object;)V"));
+return insnList;
+```

record-builder-enhancer/pom.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-enhancer</artifactId>
+
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>info.picocli</groupId>
+            <artifactId>picocli</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <createDependencyReducedPom>true</createDependencyReducedPom>
+                    <dependencyReducedPomLocation>${project.build.directory}/dependency-reduced-pom.xml</dependencyReducedPomLocation>
+                    <useDependencyReducedPomInJar>true</useDependencyReducedPomInJar>
+                    <relocations>
+                        <relocation>
+                            <pattern>picocli</pattern>
+                            <shadedPattern>recordbuilder.picocli</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>safe</pattern>
+                            <shadedPattern>META-INF.services</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <transformers>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                            <manifestEntries>
+                                <Main-Class>io.soabase.recordbuilder.enhancer.Main</Main-Class>
+                            </manifestEntries>
+                        </transformer>
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
+                    </transformers>
+                    <filters>
+                        <filter>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/EnhancersController.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.soabase.recordbuilder.enhancer.RecordBuilderEnhancerPlugin.adjustedClassName;
+
+class EnhancersController {
+    private final Map<String, Optional<RecordBuilderEnhancer>> enhancers = new ConcurrentHashMap<>();
+
+    record EnhancerAndArgs(RecordBuilderEnhancer enhancer, List<String> arguments) {}
+
+    List<EnhancerAndArgs> getEnhancers(ProcessorImpl processor, TypeElement typeElement) {
+        return internalGetEnhancers(processor, typeElement).flatMap(spec -> toEnhancer(processor, spec)).toList();
+    }
+
+    private Stream<EnhancerSpec> internalGetEnhancers(ProcessorImpl processor, TypeElement typeElement) {
+        Optional<? extends AnnotationMirror> recordBuilderEnhance = getAnnotationMirror(processor, typeElement);
+        Optional<? extends AnnotationMirror> recordBuilderEnhanceTemplate = getTemplateAnnotationMirror(processor, typeElement);
+        if (recordBuilderEnhance.isPresent() && recordBuilderEnhanceTemplate.isPresent()) {
+            processor.logError("RecordBuilderEnhance and RecordBuilderEnhance.Template cannot be combined.");
+            return Stream.of();
+        }
+        return Stream.concat(recordBuilderEnhance.stream().flatMap(this::getEnhancersAnnotationValue), recordBuilderEnhanceTemplate.stream().flatMap(this::getEnhancersAnnotationValue));
+    }
+
+    private Map<String, Object> getAnnotationValueMap(AnnotationMirror annotationMirror)
+    {
+        return annotationMirror.getElementValues().entrySet().stream()
+                .collect(Collectors.toMap(entry -> entry.getKey().getSimpleName().toString(), entry -> entry.getValue().getValue()));
+    }
+
+    private record EnhancerSpec(String enhancerClass, List<String> arguments) {}
+
+    @SuppressWarnings("unchecked")
+    private Stream<EnhancerSpec> getEnhancersAnnotationValue(AnnotationMirror annotationMirror)
+    {
+        Map<String, Object> annotationValueMap = getAnnotationValueMap(annotationMirror);
+
+        List<? extends AnnotationValue> argumentsValue = (List<? extends AnnotationValue>) annotationValueMap.getOrDefault("arguments", List.of()); // list of RecordBuilderEnhanceArguments mirrors
+        Map<String, List<String>> argumentsMap = argumentsValue.stream()
+                .flatMap(argumentMirror -> {
+                    Map<String, Object> argumentMap = getAnnotationValueMap((AnnotationMirror) argumentMirror.getValue());
+                    Object enhancer = argumentMap.get("enhancer");
+                    Object arguments = argumentMap.get("arguments");
+                    if ((enhancer != null) && (arguments != null)) {
+                        List<String> argumentList = ((List<? extends AnnotationValue>) arguments).stream().map(value -> value.getValue().toString()).toList();
+                        return Stream.of(Map.entry(enhancer.toString(), argumentList));
+                    }
+                    return Stream.of();
+                })
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        List<? extends AnnotationValue> enhancers = (List<? extends AnnotationValue>) annotationValueMap.get("enhancers");
+        if (enhancers != null) {
+            return enhancers.stream().map(annotationValue -> {
+                TypeMirror typeMirror = (TypeMirror) annotationValue.getValue();
+                return new EnhancerSpec(typeMirror.toString(), argumentsMap.getOrDefault(typeMirror.toString(), List.of()));
+            });
+        }
+        return Stream.of();
+    }
+
+    @SuppressWarnings("unchecked")
+    private Map<String, ? extends AnnotationValue> getArgumentsAnnotations(AnnotationMirror annotationMirror)
+    {
+        return annotationMirror.getElementValues().entrySet().stream()
+                .filter(entry -> entry.getKey().getSimpleName().contentEquals("arguments"))
+                .flatMap(entry -> ((List<? extends AnnotationValue>) entry.getValue().getValue()).stream())
+                .flatMap(annotationValue -> ((AnnotationMirror) annotationValue.getValue()).getElementValues().entrySet().stream()) // now as RecordBuilderEnhanceArguments
+
+                .collect(Collectors.toMap(entry -> entry.getKey().getSimpleName().toString(), Map.Entry::getValue));
+    }
+
+    private Optional<? extends AnnotationMirror> getAnnotationMirror(ProcessorImpl processor, TypeElement typeElement) {
+        return processor.elements().getAllAnnotationMirrors(typeElement).stream()
+                .filter(annotationMirror -> annotationMirror.getAnnotationType().toString().equals(adjustedClassName(RecordBuilderEnhance.class)))
+                .findFirst();
+    }
+
+    private Optional<? extends AnnotationMirror> getTemplateAnnotationMirror(ProcessorImpl processor, TypeElement typeElement) {
+        return processor.elements().getAllAnnotationMirrors(typeElement).stream()
+                .flatMap(annotationMirror -> processor.elements().getAllAnnotationMirrors(annotationMirror.getAnnotationType().asElement()).stream())
+                .filter(annotationMirror -> annotationMirror.getAnnotationType().toString().equals(adjustedClassName(RecordBuilderEnhance.Template.class)))
+                .findFirst();
+    }
+
+    private Stream<EnhancerAndArgs> toEnhancer(ProcessorImpl processor, EnhancerSpec spec)
+    {
+        return enhancers.computeIfAbsent(spec.enhancerClass(), __ -> newEnhancer(processor, spec.enhancerClass()))
+                .stream()
+                .map(enhancer -> new EnhancerAndArgs(enhancer, spec.arguments()));
+    }
+
+    private Optional<RecordBuilderEnhancer> newEnhancer(ProcessorImpl processor, String enhancerClass)
+    {
+        try {
+            Class<?> clazz = Class.forName(enhancerClass, true, RecordBuilderEnhancerPlugin.class.getClassLoader());
+            Object enhancer = clazz.getConstructor().newInstance();
+            return Optional.of((RecordBuilderEnhancer) enhancer);
+        } catch (Exception e) {
+            processor.logError("Could not create enhancer instance. type=%s exception=%s message=%s".formatted(enhancerClass, e.getClass().getSimpleName(), e.getMessage()));
+            return Optional.empty();
+        }
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/Main.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import picocli.CommandLine;
+
+public class Main {
+    public static void main(String[] args) {
+        CommandLine commandLine = new CommandLine(new PluginOptions());
+        commandLine.usage(System.out);
+    }
+
+    private Main() {
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/PluginOptions.java

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Parameters;
+
+import java.io.File;
+
+@Command(name = "RecordBuilder Enhancer",
+        description = "Enhances Java record class files with validations, preconditions, etc. See https://github.com/Randgalt/record-builder for details",
+        usageHelpAutoWidth = true)
+class PluginOptions {
+    @Parameters(paramLabel = "DIRECTORY", arity = "0..1", description = "The build's output directory - i.e. where javac writes generated classes. The value can be a full path or a relative path. If not provided the Enhancer plugin will attempt to use standard directories.")
+    String directory = "";
+
+    @Option(names = {"-h", "--help"}, description = "Outputs this help")
+    boolean helpRequested = false;
+
+    @Option(names = {"-v", "--verbose"}, description = "Verbose output during compilation")
+    boolean verbose = false;
+
+    @Option(names = {"--disable"}, description = "Deactivate/disable the plugin")
+    boolean disable = false;
+
+    @Option(names = {"--dryRun"}, description = "Dry run only - doesn't modify any classes. You should enable verbose as well via: -v")
+    boolean dryRun = false;
+
+    @Option(names = {"--outputDirectory"}, description = "Optional alternate output directory for enhanced class files")
+    File outputTo = null;
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/ProcessorImpl.java

@@ -0,0 +1,110 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.util.Trees;
+import io.soabase.recordbuilder.enhancer.EnhancersController.EnhancerAndArgs;
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.element.RecordComponentElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+class ProcessorImpl
+    implements Processor {
+    private final Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancers;
+    private final Elements elements;
+    private final Types types;
+    private final Trees trees;
+    private final CompilationUnitTree compilationUnit;
+    private final boolean verboseRequested;
+
+    ProcessorImpl(Elements elements, Types types, Trees trees, CompilationUnitTree compilationUnit, boolean verboseRequested) {
+        this(Set.of(), elements, types, trees, compilationUnit, verboseRequested);
+    }
+
+    private ProcessorImpl(Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancers, Elements elements, Types types, Trees trees, CompilationUnitTree compilationUnit, boolean verboseRequested) {
+        this.enhancers = enhancers;
+        this.elements = elements;
+        this.types = types;
+        this.trees = trees;
+        this.compilationUnit = compilationUnit;
+        this.verboseRequested = verboseRequested;
+    }
+
+    ProcessorImpl withEnhancers(List<EnhancerAndArgs> enhancers)
+    {
+        Collection<? extends Class<? extends RecordBuilderEnhancer>> enhancersList = enhancers.stream().map(enhancerAndArgs -> enhancerAndArgs.enhancer().getClass()).toList();
+        return new ProcessorImpl(enhancersList, elements, types, trees, compilationUnit, verboseRequested);
+    }
+
+    @Override
+    public boolean verboseRequested() {
+        return verboseRequested;
+    }
+
+    @Override
+    public List<Entry> asEntries(TypeElement element) {
+        List<? extends RecordComponentElement> recordComponents = element.getRecordComponents();
+        return IntStream.range(0, recordComponents.size())
+                .mapToObj(index -> new Entry(index + 1, recordComponents.get(index), types().erasure(recordComponents.get(index).asType())))
+                .toList();
+    }
+
+    @Override
+    public boolean hasEnhancer(Class<? extends RecordBuilderEnhancer> enhancer) {
+        return enhancers.contains(enhancer);
+    }
+
+    @Override
+    public void logInfo(CharSequence msg) {
+        printMessage(Diagnostic.Kind.NOTE, msg);
+    }
+
+    @Override
+    public void logWarning(CharSequence msg) {
+        printMessage(Diagnostic.Kind.MANDATORY_WARNING, msg);
+    }
+
+    @Override
+    public void logError(CharSequence msg) {
+        msg += " - Use -h for help in your -Xplugin arguments";
+        printMessage(Diagnostic.Kind.ERROR, msg);
+    }
+
+    @Override
+    public Elements elements() {
+        return elements;
+    }
+
+    @Override
+    public Types types() {
+        return types;
+    }
+
+    private void printMessage(Diagnostic.Kind kind, CharSequence msg) {
+        trees.printMessage(kind, "[RecordBuilder Enhancer] " + msg, compilationUnit, compilationUnit);
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/RecordBuilderEnhancerPlugin.java

@@ -0,0 +1,139 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import io.soabase.recordbuilder.enhancer.EnhancersController.EnhancerAndArgs;
+import io.soabase.recordbuilder.enhancer.Session.FileStreams;
+import picocli.CommandLine;
+import recordbuilder.org.objectweb.asm.ClassReader;
+import recordbuilder.org.objectweb.asm.ClassWriter;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class RecordBuilderEnhancerPlugin
+        implements Plugin, TaskListener {
+    private volatile Session session;
+
+    @Override
+    public String getName() {
+        return "recordbuilderenhancer";
+    }
+
+    @Override
+    public boolean autoStart() {
+        return true;
+    }
+
+    @Override
+    public void init(JavacTask task, String... args) {
+        PluginOptions pluginOptions = new PluginOptions();
+        CommandLine commandLine = new CommandLine(pluginOptions);
+        commandLine.parseArgs(args);
+        if (!pluginOptions.disable) {
+            session = new Session(task, this, pluginOptions, commandLine);
+        }
+    }
+
+    @Override
+    public void finished(TaskEvent taskEvent) {
+        if (taskEvent.getKind() == TaskEvent.Kind.GENERATE) {
+            TypeElement typeElement = taskEvent.getTypeElement();
+            ProcessorImpl processor = session.newProcessor(taskEvent);
+            session.checkPrintHelp(processor);
+            List<EnhancerAndArgs> enhancers = session.enhancersController().getEnhancers(processor, typeElement);
+            if (!enhancers.isEmpty()) {
+                if (typeElement.getRecordComponents().isEmpty()) {
+                    processor.logError(typeElement.getQualifiedName() + " is not a record");
+                } else {
+                    if (processor.verboseRequested()) {
+                        processor.logWarning("Enhancing %s with %s".formatted(typeElement.getSimpleName(), enhancers.stream().map(enhancer -> enhancer.getClass().getName()).collect(Collectors.joining(","))));
+                    }
+                    session.getFileStreams(processor, typeElement, taskEvent.getCompilationUnit().getSourceFile().toUri()).ifPresent(fileStreams -> enhance(typeElement, processor.withEnhancers(enhancers), enhancers, fileStreams));
+                }
+            }
+        }
+    }
+
+    private boolean removeAndSaveSuperCall(MethodNode constructor, InsnList insnList) {
+        ListIterator<AbstractInsnNode> iterator = constructor.instructions.iterator();
+        while (iterator.hasNext()) {
+            AbstractInsnNode node = iterator.next();
+            iterator.remove();
+            insnList.add(node);
+            if ((node.getOpcode() == Opcodes.INVOKESPECIAL) && ((MethodInsnNode) node).owner.equals("java/lang/Record") && ((MethodInsnNode) node).name.equals("<init>")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void enhance(TypeElement typeElement, ProcessorImpl processor, List<EnhancerAndArgs> specs, FileStreams fileStreams) {
+        try {
+            ClassNode classNode = new ClassNode();
+            try (InputStream in = fileStreams.openInputStream()) {
+                ClassReader classReader = new ClassReader(in);
+                classReader.accept(classNode, 0);
+            }
+            InsnList insnList = new InsnList();
+            MethodNode constructor = findConstructor(classNode).orElseThrow(() -> new IllegalStateException("Could not find default constructor"));
+            if (!removeAndSaveSuperCall(constructor, insnList)) {
+                processor.logError("Unrecognized constructor - missing super() call.");
+                return;
+            }
+            specs.stream()
+                    .map(spec -> spec.enhancer().enhance(processor, typeElement, spec.arguments()))
+                    .forEach(insnList::add);
+            constructor.instructions.insert(insnList);
+
+            ClassWriter classWriter = new ClassWriter(Opcodes.ASM9 | ClassWriter.COMPUTE_FRAMES);
+            classNode.accept(classWriter);
+
+            if (!session.isDryRun()) {
+                try (OutputStream out = fileStreams.openOutputStream()) {
+                    out.write(classWriter.toByteArray());
+                }
+            }
+        } catch (IOException e) {
+            processor.logError("Could not process " + typeElement.getQualifiedName() + " - " + e.getMessage());
+        }
+    }
+
+    static String adjustedClassName(Class<?> clazz) {
+        return clazz.getName().replace('$', '.');
+    }
+
+    private static Optional<MethodNode> findConstructor(ClassNode classNode) {
+        String defaultConstructorDescription = classNode.recordComponents.stream()
+                .map(recordComponentNode -> recordComponentNode.descriptor)
+                .collect(Collectors.joining("", "(", ")V"));
+        return classNode.methods.stream()
+                .filter(methodNode -> methodNode.name.equals("<init>") && methodNode.desc.equals(defaultConstructorDescription))
+                .findFirst();
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/Session.java

@@ -0,0 +1,186 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.source.util.Trees;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import picocli.CommandLine;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.*;
+import java.io.*;
+import java.net.URI;
+import java.util.List;
+import java.util.Optional;
+
+public class Session implements SessionFlag {
+    private final JavacTask task;
+    private final StandardJavaFileManager fileManager;
+    private final Trees trees;
+    private final EnhancersController enhancersController;
+    private final PluginOptions pluginOptions;
+    private final CommandLine commandLine;
+
+    public Session(JavacTask task, TaskListener taskListener, PluginOptions pluginOptions, CommandLine commandLine) {
+        this.task = task;
+        this.pluginOptions = pluginOptions;
+        this.commandLine = commandLine;
+        task.addTaskListener(taskListener);
+        enhancersController = new EnhancersController();
+        //PluginOptions.setupCommandLine(this.commandLine, enhancersController.enhancers(), true);
+        fileManager = ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null);
+        try {
+            fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(new File(this.pluginOptions.directory).getAbsoluteFile()));
+        } catch (IOException e) {
+            throw new RuntimeException("Could not set the class output path", e);
+        }
+
+        trees = Trees.instance(task);
+
+        if (pluginOptions.outputTo != null) {
+            if (!pluginOptions.outputTo.isDirectory() && !pluginOptions.outputTo.exists() && !pluginOptions.outputTo.mkdirs()) {
+                throw new RuntimeException("Could not create directory: " + pluginOptions.outputTo);
+            }
+        }
+    }
+
+    public boolean enabled()
+    {
+        return !pluginOptions.disable;
+    }
+
+    public boolean isDryRun()
+    {
+        return pluginOptions.dryRun;
+    }
+
+    public JavacTask task() {
+        return task;
+    }
+
+    public interface FileStreams
+    {
+        InputStream openInputStream() throws IOException;
+
+        OutputStream openOutputStream() throws IOException;
+    }
+
+    public Optional<FileStreams> getFileStreams(Processor processor, TypeElement element, URI fileUri) {
+        String directory = pluginOptions.directory;
+        if (directory.isEmpty()) {
+            String pathToFile = fileUri.getPath();
+            int srcMainJavaIndex = pathToFile.indexOf("src/main/java");
+            if (srcMainJavaIndex >= 0) {
+                directory = pathToFile.substring(0, srcMainJavaIndex) + "target/classes";
+            }
+            else {
+                directory = ".";
+            }
+        }
+        String className = getClassName(element);
+        File absoluteDirectory = new File(directory).getAbsoluteFile();
+        if (pluginOptions.verbose) {
+            processor.logWarning("Using classPath %s for class %s".formatted(absoluteDirectory, className));
+        }
+        try {
+            fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(absoluteDirectory));
+            JavaFileObject inputJavaFile = fileManager.getJavaFileForOutput(StandardLocation.CLASS_OUTPUT, className, JavaFileObject.Kind.CLASS, null);
+            JavaFileObject outputJavaFile;
+            if (pluginOptions.outputTo != null) {
+                fileManager.setLocation(StandardLocation.CLASS_OUTPUT, List.of(pluginOptions.outputTo));
+                outputJavaFile = fileManager.getJavaFileForOutput(StandardLocation.CLASS_OUTPUT, className, JavaFileObject.Kind.CLASS, null);
+            }
+            else {
+                outputJavaFile = inputJavaFile;
+            }
+            FileStreams fileStreams = new FileStreams() {
+                @Override
+                public InputStream openInputStream() throws IOException {
+                    return inputJavaFile.openInputStream();
+                }
+
+                @Override
+                public OutputStream openOutputStream() throws IOException {
+                    return outputJavaFile.openOutputStream();
+                }
+            };
+            return Optional.of(fileStreams);
+        } catch (IOException e) {
+            processor.logError("Could not set classpath to %s for class %s: %s".formatted(absoluteDirectory, className, e.getMessage()));
+            return Optional.empty();
+        }
+    }
+
+    public EnhancersController enhancersController() {
+        return enhancersController;
+    }
+
+    public ProcessorImpl newProcessor(TaskEvent taskEvent)
+    {
+        return new ProcessorImpl(task.getElements(), task.getTypes(), trees, taskEvent.getCompilationUnit(), pluginOptions.verbose);
+    }
+
+    public void checkPrintHelp(Processor processor)
+    {
+        if (pluginOptions.helpRequested && getAndSetFlag("show-help")) {
+            StringWriter help = new StringWriter();
+            help.write('\n');
+            commandLine.usage(new PrintWriter(help));
+            processor.logError(help.toString());
+        }
+    }
+
+    @Override
+    public boolean getAndSetFlag(String name)
+    {
+        boolean wasSet = isSet(name);
+        if (!wasSet) {
+            set(name);
+            return true;
+        }
+        return false;
+    }
+
+    private String getClassName(TypeElement typeElement) {
+        return task.getElements().getPackageOf(typeElement).getQualifiedName() + "." + getClassName(typeElement, "");
+    }
+
+    private static String getClassName(Element element, String separator) {
+        // prefix enclosing class names if nested in a class
+        if (element instanceof TypeElement) {
+            return getClassName(element.getEnclosingElement(), "$") + element.getSimpleName().toString() + separator;
+        }
+        return "";
+    }
+
+    private boolean isSet(String name)
+    {
+        return Boolean.parseBoolean(System.getProperty(toKey(name)));
+    }
+
+    private void set(String name)
+    {
+        System.setProperty(toKey(name), "true");
+    }
+
+    private String toKey(String name) {
+        return Session.class.getName() + ":" + name;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/SessionFlag.java

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer;
+
+@FunctionalInterface
+public interface SessionFlag {
+    boolean getAndSetFlag(String name);
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollection.java

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class CopyCollection extends CopyCollectionBase {
+    @Override
+    protected boolean isInterface() {
+        return true;
+    }
+
+    @Override
+    protected String mapMethod() {
+        return "(Ljava/util/Map;)Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/List;";
+    }
+
+    @Override
+    protected String map() {
+        return "java/util/Map";
+    }
+
+    @Override
+    protected String set() {
+        return "java/util/Set";
+    }
+
+    @Override
+    protected String list() {
+        return "java/util/List";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionBase.java

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+import recordbuilder.org.objectweb.asm.tree.MethodInsnNode;
+import recordbuilder.org.objectweb.asm.tree.VarInsnNode;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public abstract class CopyCollectionBase
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element).stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), collectionType) || processor.types().isAssignable(entry.erasedType(), mapType))
+                .forEach(entry -> {
+                    // aload_1
+                    // invokestatic  #7                  // InterfaceMethod java/util/List.copyOf:(Ljava/util/Collection;)Ljava/util/Set;
+                    // astore_1
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "copyOf", listMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "copyOf", setMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "copyOf", mapMethod(), isInterface()));
+                    }
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+
+    abstract protected boolean isInterface();
+
+    abstract protected String mapMethod();
+
+    abstract protected String setMethod();
+
+    abstract protected String listMethod();
+
+    abstract protected String map();
+
+    abstract protected String set();
+
+    abstract protected String list();
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionNullableEmpty.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class CopyCollectionNullableEmpty extends CopyCollectionNullableEmptyBase {
+    @Override
+    protected boolean isInterface() {
+        return true;
+    }
+
+    @Override
+    protected String mapEmptyMethod() {
+        return "()Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setEmptyMethod() {
+        return "()Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listEmptyMethod() {
+        return "()Ljava/util/List;";
+    }
+
+    @Override
+    protected String mapCopyMethod() {
+        return "(Ljava/util/Map;)Ljava/util/Map;";
+    }
+
+    @Override
+    protected String setCopyMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/Set;";
+    }
+
+    @Override
+    protected String listCopyMethod() {
+        return "(Ljava/util/Collection;)Ljava/util/List;";
+    }
+
+    @Override
+    protected String map() {
+        return "java/util/Map";
+    }
+
+    @Override
+    protected String set() {
+        return "java/util/Set";
+    }
+
+    @Override
+    protected String list() {
+        return "java/util/List";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/CopyCollectionNullableEmptyBase.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public abstract class CopyCollectionNullableEmptyBase
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element).stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), collectionType) || processor.types().isAssignable(entry.erasedType(), mapType))
+                .forEach(entry -> {
+                    /*
+                       4: aload_1
+                       5: ifnull        15
+                       8: aload_1
+                       9: invokestatic  #7                  // InterfaceMethod java/util/Set.copyOf:(Ljava/util/Collection;)Ljava/util/Set;
+                      12: goto          18
+                      15: invokestatic  #13                 // InterfaceMethod java/util/Set.of:()Ljava/util/Set;
+                      18: astore_1
+                     */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doCopylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "copyOf", listCopyMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "copyOf", setCopyMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "copyOf", mapCopyMethod(), isInterface()));
+                    }
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    if (processor.types().isAssignable(entry.erasedType(), listType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, list(), "of", listEmptyMethod(), isInterface()));
+                    } else if (processor.types().isAssignable(entry.erasedType(), collectionType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, set(), "of", setEmptyMethod(), isInterface()));
+                    } else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, map(), "of", mapEmptyMethod(), isInterface()));
+                    }
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+
+    abstract protected boolean isInterface();
+
+    abstract protected String mapEmptyMethod();
+
+    abstract protected String setEmptyMethod();
+
+    abstract protected String listEmptyMethod();
+
+    abstract protected String mapCopyMethod();
+
+    abstract protected String setCopyMethod();
+
+    abstract protected String listCopyMethod();
+
+    abstract protected String map();
+
+    abstract protected String set();
+
+    abstract protected String list();
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullOptional.java

@@ -0,0 +1,74 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public class EmptyNullOptional
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror optionalType = processor.elements().getTypeElement("java.util.Optional").asType();
+        TypeMirror optionalIntType = processor.elements().getTypeElement("java.util.OptionalInt").asType();
+        TypeMirror optionalLongType = processor.elements().getTypeElement("java.util.OptionalLong").asType();
+        TypeMirror optionalDouble = processor.elements().getTypeElement("java.util.OptionalDouble").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), optionalType) || processor.types().isAssignable(entry.erasedType(), optionalIntType) || processor.types().isAssignable(entry.erasedType(), optionalLongType) || processor.types().isAssignable(entry.erasedType(), optionalDouble))
+                .forEach(entry -> {
+                    /*
+                       4: aload         5
+                       6: ifnull        14
+                       9: aload         5
+                      11: goto          17
+                      14: invokestatic  #7                  // Method java/util/Optional.empty:()Ljava/util/Optional;
+                      17: astore        5
+                    */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    if (processor.types().isAssignable(entry.erasedType(), optionalIntType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalInt", "empty", "()Ljava/util/OptionalInt;"));
+                    }
+                    else if (processor.types().isAssignable(entry.erasedType(), optionalLongType)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalLong", "empty", "()Ljava/util/OptionalLong;"));
+                    }
+                    else if (processor.types().isAssignable(entry.erasedType(), optionalDouble)) {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/OptionalDouble", "empty", "()Ljava/util/OptionalDouble;"));
+                    }
+                    else {
+                        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/Optional", "empty", "()Ljava/util/Optional;"));
+                    }
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/EmptyNullString.java

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Label;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+public class EmptyNullString
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror stringType = processor.elements().getTypeElement("java.lang.String").asType();
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> processor.types().isAssignable(entry.erasedType(), stringType))
+                .forEach(entry -> {
+                    /*
+                       4: aload_1
+                       5: ifnull        12
+                       8: aload_1
+                       9: goto          14
+                      12: ldc           #7                  // String
+                      14: astore_1
+                    */
+                    LabelNode doEmptylabel = new LabelNode(new Label());
+                    LabelNode doAssignlabel = new LabelNode(new Label());
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.IFNULL, doEmptylabel));
+                    insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+                    insnList.add(new JumpInsnNode(Opcodes.GOTO, doAssignlabel));
+                    insnList.add(doEmptylabel);
+                    insnList.add(new LdcInsnNode(""));
+                    insnList.add(doAssignlabel);
+                    insnList.add(new VarInsnNode(Opcodes.ASTORE, entry.parameterIndex()));
+                });
+        return insnList;
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/GuavaCopyCollection.java

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class GuavaCopyCollection extends CopyCollectionBase {
+    @Override
+    protected boolean isInterface() {
+        return false;
+    }
+
+    @Override
+    protected String mapMethod() {
+        return "(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String map() {
+        return "com/google/common/collect/ImmutableMap";
+    }
+
+    @Override
+    protected String set() {
+        return "com/google/common/collect/ImmutableSet";
+    }
+
+    @Override
+    protected String list() {
+        return "com/google/common/collect/ImmutableList";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/GuavaCopyCollectionNullableEmpty.java

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+public class GuavaCopyCollectionNullableEmpty extends CopyCollectionNullableEmptyBase {
+    @Override
+    protected boolean isInterface() {
+        return false;
+    }
+
+    @Override
+    protected String mapEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listEmptyMethod() {
+        return "()Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String mapCopyMethod() {
+        return "(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;";
+    }
+
+    @Override
+    protected String setCopyMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableSet;";
+    }
+
+    @Override
+    protected String listCopyMethod() {
+        return "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;";
+    }
+
+    @Override
+    protected String map() {
+        return "com/google/common/collect/ImmutableMap";
+    }
+
+    @Override
+    protected String set() {
+        return "com/google/common/collect/ImmutableSet";
+    }
+
+    @Override
+    protected String list() {
+        return "com/google/common/collect/ImmutableList";
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/NotNullAnnotations.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+import java.util.stream.Stream;
+
+public class NotNullAnnotations
+        implements RecordBuilderEnhancer
+{
+    public static final String DEFAULT_EXPRESSION = "(notnull)|(nonnull)";
+
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        InsnList insnList = new InsnList();
+        if (arguments.size() > 1) {
+            processor.logError("Too many arguments to NotNullAnnotations.");
+        } else {
+            String expression = arguments.isEmpty() ? DEFAULT_EXPRESSION : arguments.get(0);
+            try {
+                Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
+                processor.asEntries(element)
+                        .stream()
+                        .filter(entry -> !entry.erasedType().getKind().isPrimitive())
+                        .filter(entry -> hasMatchingAnnotation(entry, pattern))
+                        .forEach(entry -> RequireNonNull.enhance(insnList, entry));
+            } catch (PatternSyntaxException e) {
+                processor.logError("Bad argument to NotNullAnnotations: " + e.getMessage());
+            }
+        }
+        return insnList;
+    }
+
+    private boolean hasMatchingAnnotation(Entry entry, Pattern pattern)
+    {
+        Stream<? extends AnnotationMirror> typeMirrors = entry.element().asType().getAnnotationMirrors().stream();
+        Stream<? extends AnnotationMirror> elementMirrors = entry.element().getAnnotationMirrors().stream();
+        return Stream.concat(typeMirrors, elementMirrors)
+                .anyMatch(mirror -> pattern.matcher(mirror.getAnnotationType().asElement().getSimpleName().toString()).matches());
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/ProcessorUtil.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+
+import javax.lang.model.type.TypeMirror;
+import java.util.stream.Stream;
+
+class ProcessorUtil {
+    private ProcessorUtil() {
+    }
+
+    static boolean isNotHandledByOthers(Class<? extends RecordBuilderEnhancer> enhancer, Processor processor, Entry entry, TypeMirror... types)
+    {
+        if (!processor.hasEnhancer(enhancer)) {
+            return true;
+        }
+        if (types == null) {
+            return true;
+        }
+        return Stream.of(types).noneMatch(type -> processor.types().isAssignable(entry.erasedType(), type));
+    }
+}

record-builder-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/enhancers/RequireNonNull.java

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.enhancers;
+
+import io.soabase.recordbuilder.enhancer.spi.Entry;
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.*;
+
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.List;
+
+import static io.soabase.recordbuilder.enhancer.enhancers.ProcessorUtil.isNotHandledByOthers;
+
+public class RequireNonNull
+        implements RecordBuilderEnhancer {
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments) {
+        TypeMirror optionalType = processor.elements().getTypeElement("java.util.Optional").asType();
+        TypeMirror stringType = processor.elements().getTypeElement("java.lang.String").asType();
+        TypeMirror collectionType = processor.elements().getTypeElement("java.util.Collection").asType();
+        TypeMirror listType = processor.elements().getTypeElement("java.util.List").asType();
+        TypeMirror mapType = processor.elements().getTypeElement("java.util.Map").asType();
+
+        InsnList insnList = new InsnList();
+        processor.asEntries(element)
+                .stream()
+                .filter(entry -> !entry.erasedType().getKind().isPrimitive())
+                .filter(entry -> isNotHandledByOthers(EmptyNullOptional.class, processor, entry, optionalType))
+                .filter(entry -> isNotHandledByOthers(EmptyNullString.class, processor, entry, stringType))
+                .filter(entry -> isNotHandledByOthers(CopyCollectionNullableEmpty.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(CopyCollection.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(GuavaCopyCollectionNullableEmpty.class, processor, entry, collectionType, listType, mapType))
+                .filter(entry -> isNotHandledByOthers(GuavaCopyCollection.class, processor, entry, collectionType, listType, mapType))
+                .forEach(entry -> enhance(insnList, entry));
+        return insnList;
+    }
+
+    static void enhance(InsnList insnList, Entry entry) {
+        // java.util.Objects.requireNonNull(var1, "<name> is null");
+                    /*
+                        ALOAD 1
+                        LDC "X is null"
+                        INVOKESTATIC java/util/Objects.requireNonNull (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+                        POP
+                    */
+        insnList.add(new VarInsnNode(Opcodes.ALOAD, entry.parameterIndex()));
+        insnList.add(new LdcInsnNode("%s is null".formatted(entry.element().getSimpleName())));
+        insnList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/util/Objects", "requireNonNull", "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;"));
+        insnList.add(new InsnNode(Opcodes.POP));
+    }
+}

record-builder-enhancer/src/main/resources/safe/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+io.soabase.recordbuilder.enhancer.RecordBuilderEnhancerPlugin

record-builder-processor/pom.xml

@@ -3,12 +3,16 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.11.ea-SNAPSHOT</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-processor</artifactId>
 
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>com.squareup</groupId>

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/CollectionBuilderUtils.java

@@ -0,0 +1,228 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import com.squareup.javapoet.*;
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.lang.model.element.Modifier;
+import java.util.*;
+
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;
+
+class CollectionBuilderUtils {
+    private final boolean useImmutableCollections;
+    private final boolean addSingleItemCollectionBuilders;
+    private final String listShimName;
+    private final String mapShimName;
+    private final String setShimName;
+    private final String collectionShimName;
+
+    private boolean needsListShim;
+    private boolean needsMapShim;
+    private boolean needsSetShim;
+    private boolean needsCollectionShim;
+
+    private static final TypeName listType = TypeName.get(List.class);
+    private static final TypeName mapType = TypeName.get(Map.class);
+    private static final TypeName setType = TypeName.get(Set.class);
+    private static final TypeName collectionType = TypeName.get(Collection.class);
+
+    private static final TypeVariableName tType = TypeVariableName.get("T");
+    private static final TypeVariableName kType = TypeVariableName.get("K");
+    private static final TypeVariableName vType = TypeVariableName.get("V");
+    private static final ParameterizedTypeName parameterizedListType = ParameterizedTypeName.get(ClassName.get(List.class), tType);
+    private static final ParameterizedTypeName parameterizedMapType = ParameterizedTypeName.get(ClassName.get(Map.class), kType, vType);
+    private static final ParameterizedTypeName parameterizedSetType = ParameterizedTypeName.get(ClassName.get(Set.class), tType);
+    private static final ParameterizedTypeName parameterizedCollectionType = ParameterizedTypeName.get(ClassName.get(Collection.class), tType);
+
+    CollectionBuilderUtils(List<RecordClassType> recordComponents, RecordBuilder.Options metaData) {
+        useImmutableCollections = metaData.useImmutableCollections();
+        addSingleItemCollectionBuilders = metaData.addSingleItemCollectionBuilders();
+
+        listShimName = adjustShimName(recordComponents, "__list", 0);
+        mapShimName = adjustShimName(recordComponents, "__map", 0);
+        setShimName = adjustShimName(recordComponents, "__set", 0);
+        collectionShimName = adjustShimName(recordComponents, "__collection", 0);
+    }
+
+    enum SingleItemsMetaDataMode {
+        STANDARD,
+        STANDARD_FOR_SETTER,
+        EXCLUDE_WILDCARD_TYPES
+    }
+
+    record SingleItemsMetaData(Class<?> singleItemCollectionClass, List<TypeName> typeArguments, TypeName wildType) {}
+
+    Optional<SingleItemsMetaData> singleItemsMetaData(RecordClassType component, SingleItemsMetaDataMode mode) {
+        if (addSingleItemCollectionBuilders && (component.typeName() instanceof ParameterizedTypeName parameterizedTypeName)) {
+            Class<?> collectionClass = null;
+            ClassName wildcardClass = null;
+            int typeArgumentQty = 0;
+            if (isList(component)) {
+                collectionClass = ArrayList.class;
+                wildcardClass = ClassName.get(Collection.class);
+                typeArgumentQty = 1;
+            } else if (isSet(component)) {
+                collectionClass = HashSet.class;
+                wildcardClass = ClassName.get(Collection.class);
+                typeArgumentQty = 1;
+            } else if (isMap(component)) {
+                collectionClass = HashMap.class;
+                wildcardClass = (ClassName) component.rawTypeName();
+                typeArgumentQty = 2;
+            }
+            var hasWildcardTypeArguments = hasWildcardTypeArguments(parameterizedTypeName, typeArgumentQty);
+            if (collectionClass != null) {
+                return switch (mode) {
+                    case STANDARD -> singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+
+                    case STANDARD_FOR_SETTER -> {
+                        if (hasWildcardTypeArguments) {
+                            yield Optional.of(new SingleItemsMetaData(collectionClass, parameterizedTypeName.typeArguments, component.typeName()));
+                        }
+                        yield singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+                    }
+
+                    case EXCLUDE_WILDCARD_TYPES -> {
+                        if (hasWildcardTypeArguments) {
+                            yield Optional.empty();
+                        }
+                        yield singleItemsMetaDataWithWildType(parameterizedTypeName, collectionClass, wildcardClass, typeArgumentQty);
+                    }
+                };
+            }
+        }
+        return Optional.empty();
+    }
+
+    boolean isImmutableCollection(RecordClassType component) {
+        return useImmutableCollections && (isList(component) || isMap(component) || isSet(component) || component.rawTypeName().equals(collectionType));
+    }
+
+    boolean isList(RecordClassType component) {
+        return component.rawTypeName().equals(listType);
+    }
+
+    boolean isMap(RecordClassType component) {
+        return component.rawTypeName().equals(mapType);
+    }
+
+    boolean isSet(RecordClassType component) {
+        return component.rawTypeName().equals(setType);
+    }
+
+    void add(CodeBlock.Builder builder, RecordClassType component) {
+        if (useImmutableCollections) {
+            if (isList(component)) {
+                needsListShim = true;
+                builder.add("$L($L)", listShimName, component.name());
+            } else if (isMap(component)) {
+                needsMapShim = true;
+                builder.add("$L($L)", mapShimName, component.name());
+            } else if (isSet(component)) {
+                needsSetShim = true;
+                builder.add("$L($L)", setShimName, component.name());
+            } else if (component.rawTypeName().equals(collectionType)) {
+                needsCollectionShim = true;
+                builder.add("$L($L)", collectionShimName, component.name());
+            } else {
+                builder.add("$L", component.name());
+            }
+        } else {
+            builder.add("$L", component.name());
+        }
+    }
+
+    void addShims(TypeSpec.Builder builder) {
+        if (!useImmutableCollections) {
+            return;
+        }
+
+        if (needsListShim) {
+            builder.addMethod(buildMethod(listShimName, listType, parameterizedListType, tType));
+        }
+        if (needsSetShim) {
+            builder.addMethod(buildMethod(setShimName, setType, parameterizedSetType, tType));
+        }
+        if (needsMapShim) {
+            builder.addMethod(buildMethod(mapShimName, mapType, parameterizedMapType, kType, vType));
+        }
+        if (needsCollectionShim) {
+            builder.addMethod(buildCollectionsMethod());
+        }
+    }
+
+    private Optional<SingleItemsMetaData> singleItemsMetaDataWithWildType(ParameterizedTypeName parameterizedTypeName, Class<?> collectionClass, ClassName wildcardClass, int typeArgumentQty) {
+        TypeName wildType;
+        if (typeArgumentQty == 1) {
+            wildType = ParameterizedTypeName.get(wildcardClass, WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(0)));
+        } else { // if (typeArgumentQty == 2)
+            wildType = ParameterizedTypeName.get(wildcardClass, WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(0)), WildcardTypeName.subtypeOf(parameterizedTypeName.typeArguments.get(1)));
+        }
+        return Optional.of(new SingleItemsMetaData(collectionClass, parameterizedTypeName.typeArguments, wildType));
+    }
+
+    private boolean hasWildcardTypeArguments(ParameterizedTypeName parameterizedTypeName, int argumentCount) {
+        for (int i = 0; i < argumentCount; ++i) {
+            if (parameterizedTypeName.typeArguments.size() > i) {
+                if (parameterizedTypeName.typeArguments.get(i) instanceof WildcardTypeName) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private String adjustShimName(List<RecordClassType> recordComponents, String baseName, int index) {
+        var name = (index == 0) ? baseName : (baseName + index);
+        if (recordComponents.stream().anyMatch(component -> component.name().equals(name))) {
+            return adjustShimName(recordComponents, baseName, index + 1);
+        }
+        return name;
+    }
+
+    private MethodSpec buildMethod(String name, TypeName mainType, ParameterizedTypeName parameterizedType, TypeVariableName... typeVariables) {
+        var code = CodeBlock.of("return (o != null) ? $T.copyOf(o) : $T.of()", mainType, mainType);
+        return MethodSpec.methodBuilder(name)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+                .addTypeVariables(Arrays.asList(typeVariables))
+                .returns(parameterizedType)
+                .addParameter(parameterizedType, "o")
+                .addStatement(code)
+                .build();
+    }
+
+    private MethodSpec buildCollectionsMethod() {
+        var code = CodeBlock.builder()
+                .add("if (o instanceof Set) {\n")
+                .indent()
+                .addStatement("return $T.copyOf(o)", setType)
+                .unindent()
+                .addStatement("}")
+                .addStatement("return (o != null) ? $T.copyOf(o) : $T.of()", listType, listType)
+                .build();
+        return MethodSpec.methodBuilder(collectionShimName)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .addModifiers(Modifier.PRIVATE, Modifier.STATIC)
+                .addTypeVariable(tType)
+                .returns(parameterizedCollectionType)
+                .addParameter(parameterizedCollectionType, "o")
+                .addCode(code)
+                .build();
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/ElementUtils.java

@@ -19,15 +19,72 @@ import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.ParameterizedTypeName;
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeVariableName;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
+import io.soabase.recordbuilder.core.RecordBuilder;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.RecordComponentElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.TypeMirror;
+import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 public class ElementUtils {
+    public static Optional<? extends AnnotationMirror> findAnnotationMirror(ProcessingEnvironment processingEnv, Element element, String annotationClass) {
+        return processingEnv.getElementUtils().getAllAnnotationMirrors(element).stream()
+            .filter(e -> e.getAnnotationType().toString().equals(annotationClass))
+            .findFirst();
+    }
+
+    public static Optional<? extends AnnotationValue> getAnnotationValue(Map<? extends ExecutableElement, ? extends AnnotationValue> values, String name) {
+        return values.entrySet()
+            .stream()
+            .filter(e -> e.getKey().getSimpleName().toString().equals(name))
+            .map(Map.Entry::getValue)
+            .findFirst();
+    }
+
+    @SuppressWarnings("unchecked")
+    public static List<TypeMirror> getAttributeTypeMirrorList(AnnotationValue attribute)
+    {
+        List<? extends AnnotationValue> values = (attribute != null) ? (List<? extends AnnotationValue>)attribute.getValue() : Collections.emptyList();
+        return values.stream().map(v -> (TypeMirror)v.getValue()).collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static List<String> getAttributeStringList(AnnotationValue attribute)
+    {
+        List<? extends AnnotationValue> values = (attribute != null) ? (List<? extends AnnotationValue>)attribute.getValue() : Collections.emptyList();
+        return values.stream().map(v -> (String)v.getValue()).collect(Collectors.toList());
+    }
+
+    public static boolean getBooleanAttribute(AnnotationValue attribute)
+    {
+        Object value = (attribute != null) ? attribute.getValue() : null;
+        if ( value != null )
+        {
+            return Boolean.parseBoolean(String.valueOf(value));
+        }
+        return false;
+    }
+
+    public static String getStringAttribute(AnnotationValue attribute, String defaultValue)
+    {
+        Object value = (attribute != null) ? attribute.getValue() : null;
+        if ( value != null )
+        {
+            return String.valueOf(value);
+        }
+        return defaultValue;
+    }
+
     public static String getPackageName(TypeElement typeElement) {
         while (typeElement.getNestingKind().isNested()) {
             Element enclosingElement = typeElement.getEnclosingElement();
@@ -37,8 +94,9 @@ public class ElementUtils {
                 break;
             }
         }
-        String name = typeElement.getEnclosingElement().toString();
-        return !name.equals("unnamed package") ? name : "";
+        String name = typeElement.getQualifiedName().toString();
+        int index = name.lastIndexOf(".");
+        return (index > -1) ? name.substring(0, index) : "";
     }
 
     public static ClassType getClassType(String packageName, String simpleName, List<? extends TypeParameterElement> typeParameters) {
@@ -57,8 +115,10 @@ public class ElementUtils {
         return new ClassType(ParameterizedTypeName.get(builderClassName, typeNames), builderClassName.simpleName());
     }
 
-    public static ClassType getClassType(RecordComponentElement recordComponent) {
-        return new ClassType(TypeName.get(recordComponent.asType()), recordComponent.getSimpleName().toString());
+    public static RecordClassType getRecordClassType(ProcessingEnvironment processingEnv, RecordComponentElement recordComponent, List<? extends AnnotationMirror> accessorAnnotations, List<? extends AnnotationMirror> canonicalConstructorAnnotations) {
+        var typeName = TypeName.get(recordComponent.asType());
+        var rawTypeName = TypeName.get(processingEnv.getTypeUtils().erasure(recordComponent.asType()));
+        return new RecordClassType(typeName, rawTypeName, recordComponent.getSimpleName().toString(), accessorAnnotations, canonicalConstructorAnnotations);
     }
 
     public static String getWithMethodName(ClassType component, String prefix) {
@@ -69,12 +129,29 @@ public class ElementUtils {
         return prefix + Character.toUpperCase(name.charAt(0)) + name.substring(1);
     }
 
-    public static String getBuilderName(TypeElement element, RecordBuilderMetaData metaData, ClassType classType, String suffix) {
+    public static String getBuilderName(TypeElement element, RecordBuilder.Options metaData, ClassType classType, String suffix) {
         // generate the class name
         var baseName = classType.name() + suffix;
         return metaData.prefixEnclosingClassNames() ? (getBuilderNamePrefix(element.getEnclosingElement()) + baseName) : baseName;
     }
 
+    public static Optional<? extends Element> findCanonicalConstructor(TypeElement record) {
+        if ( record.getKind() != ElementKind.RECORD ) {
+            return Optional.empty();
+        }
+
+        // based on https://github.com/openjdk/jdk/pull/3556/files#diff-a6270f4b50989abe733607c69038b2036306d13f77276af005d023b7fc57f1a2R2368
+        var componentList = record.getRecordComponents().stream().map(e -> e.asType().toString()).collect(Collectors.toList());
+        return record.getEnclosedElements().stream()
+            .filter(element -> element.getKind() == ElementKind.CONSTRUCTOR)
+            .filter(element -> {
+                var parameters = ((ExecutableElement)element).getParameters();
+                var parametersList = parameters.stream().map(e -> e.asType().toString()).collect(Collectors.toList());
+                return componentList.equals(parametersList);
+            })
+            .findFirst();
+    }
+
     private static String getBuilderNamePrefix(Element element) {
         // prefix enclosing class names if nested in a class
         if (element instanceof TypeElement) {

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/IncludeHelper.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.*;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+class IncludeHelper {
+    private final boolean isValid;
+    private final List<TypeElement> classTypeElements;
+    private final Map<? extends ExecutableElement, ? extends AnnotationValue> annotationValues;
+
+    IncludeHelper(ProcessingEnvironment processingEnv, Element element, AnnotationMirror annotationMirror, boolean packagesSupported) {
+        annotationValues = processingEnv.getElementUtils().getElementValuesWithDefaults(annotationMirror);
+        var value = ElementUtils.getAnnotationValue(annotationValues, "value");
+        var classes = ElementUtils.getAnnotationValue(annotationValues, "classes");
+        var packages = ElementUtils.getAnnotationValue(annotationValues, "packages");
+        var isValid = true;
+        var classTypeElements = new ArrayList<TypeElement>();
+        if (value.isPresent() || classes.isPresent() || packages.isPresent()) {
+            var valueList = value.map(ElementUtils::getAttributeTypeMirrorList).orElseGet(List::of);
+            var classesList = classes.map(ElementUtils::getAttributeTypeMirrorList).orElseGet(List::of);
+            var packagesList = packages.map(ElementUtils::getAttributeStringList).orElseGet(List::of);
+            if (valueList.isEmpty() && classesList.isEmpty() && packagesList.isEmpty()) {
+                if (packagesSupported) {
+                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "At least one of \"value\", \"classes\" or \"packages\" required", element);
+                } else {
+                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "At least one of \"value\" or \"classes\" required", element);
+                }
+                isValid = false;
+            }
+            isValid = processList(processingEnv, isValid, element, valueList, classTypeElements);
+            isValid = processList(processingEnv, isValid, element, classesList, classTypeElements);
+            packages.ifPresent(annotationValue -> processPackages(processingEnv, classTypeElements, packagesList));
+        } else {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not read attribute for annotation", element);
+            isValid = false;
+        }
+        this.isValid = isValid;
+        this.classTypeElements = List.copyOf(classTypeElements);
+    }
+
+    Map<? extends ExecutableElement, ? extends AnnotationValue> getAnnotationValues() {
+        return annotationValues;
+    }
+
+    boolean isValid() {
+        return isValid;
+    }
+
+    List<TypeElement> getClassTypeElements() {
+        return classTypeElements;
+    }
+
+    private boolean processList(ProcessingEnvironment processingEnv, boolean isValid, Element element, List<TypeMirror> list, ArrayList<TypeElement> classTypeElements) {
+        for (var typeMirror : list) {
+            TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(typeMirror);
+            if (typeElement == null) {
+                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get element for: " + typeMirror, element);
+                isValid = false;
+            } else {
+                classTypeElements.add(typeElement);
+            }
+        }
+        return isValid;
+    }
+
+    private void processPackages(ProcessingEnvironment processingEnv, List<TypeElement> classTypeElements, List<String> packagesList) {
+        for (var packageName : packagesList) {
+            var packageElement = processingEnv.getElementUtils().getPackageElement(packageName);
+            for (var child : packageElement.getEnclosedElements()) {
+                if (child.getKind() == ElementKind.RECORD) {
+                    classTypeElements.add((TypeElement) child);
+                }
+            }
+        }
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordInterfaceProcessor.java

@@ -16,10 +16,8 @@
 package io.soabase.recordbuilder.processor;
 
 import com.squareup.javapoet.*;
-import io.soabase.recordbuilder.core.RecordBuilder;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-import io.soabase.recordbuilder.core.RecordInterface;
 import io.soabase.recordbuilder.core.IgnoreDefaultMethod;
+import io.soabase.recordbuilder.core.RecordBuilder;
 
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.ElementKind;
@@ -35,20 +33,27 @@ import java.util.stream.Collectors;
 
 import static io.soabase.recordbuilder.processor.ElementUtils.getBuilderName;
 import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordInterfaceAnnotation;
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.recordBuilderGeneratedAnnotation;
 
 class InternalRecordInterfaceProcessor {
     private final ProcessingEnvironment processingEnv;
     private final String packageName;
     private final TypeSpec recordType;
-    private final List<ExecutableElement> recordComponents;
+    private final List<Component> recordComponents;
     private final TypeElement iface;
     private final ClassType recordClassType;
+    private final List<String> alternateMethods;
 
     private static final String FAKE_METHOD_NAME = "__FAKE__";
 
-    InternalRecordInterfaceProcessor(ProcessingEnvironment processingEnv, TypeElement iface, RecordInterface recordInterface, RecordBuilderMetaData metaData) {
+    private static final Set<String> javaBeanPrefixes = Set.of("get", "is");
+
+    private record Component(ExecutableElement element, Optional<String> alternateName) {
+    }
+
+    InternalRecordInterfaceProcessor(ProcessingEnvironment processingEnv, TypeElement iface, boolean addRecordBuilder, RecordBuilder.Options metaData, Optional<String> packageNameOpt, boolean fromTemplate) {
         this.processingEnv = processingEnv;
-        packageName = ElementUtils.getPackageName(iface);
+        packageName = packageNameOpt.orElseGet(() -> ElementUtils.getPackageName(iface));
         recordComponents = getRecordComponents(iface);
         this.iface = iface;
 
@@ -64,18 +69,30 @@ class InternalRecordInterfaceProcessor {
                 .addModifiers(Modifier.PUBLIC)
                 .addAnnotation(generatedRecordInterfaceAnnotation)
                 .addTypeVariables(typeVariables);
+        if (metaData.addClassRetainedGenerated()) {
+            builder.addAnnotation(recordBuilderGeneratedAnnotation);
+        }
 
-        if (recordInterface.addRecordBuilder()) {
+        if (addRecordBuilder) {
             ClassType builderClassType = ElementUtils.getClassType(packageName, getBuilderName(iface, metaData, recordClassType, metaData.suffix()) + "." + metaData.withClassName(), iface.getTypeParameters());
             builder.addAnnotation(RecordBuilder.class);
             builder.addSuperinterface(builderClassType.typeName());
+            if (fromTemplate) {
+                builder.addAnnotation(AnnotationSpec.get(metaData));
+            } else {
+                var options = iface.getAnnotation(RecordBuilder.Options.class);
+                if (options != null) {
+                    builder.addAnnotation(AnnotationSpec.get(options));
+                }
+            }
         }
 
+        alternateMethods = buildAlternateMethods(recordComponents);
+
         recordType = builder.build();
     }
 
-    boolean isValid()
-    {
+    boolean isValid() {
         return !recordComponents.isEmpty();
     }
 
@@ -91,8 +108,7 @@ class InternalRecordInterfaceProcessor {
         return recordClassType;
     }
 
-    String toRecord(String classSource)
-    {
+    String toRecord(String classSource) {
         // javapoet does yet support records - so a class was created and we can reshape it
         // The class will look something like this:
         /*
@@ -118,22 +134,42 @@ class InternalRecordInterfaceProcessor {
         String declaration = matcher.group(1).trim().replace("class", "record");
         String implementsSection = matcher.group(2).trim();
         String argumentList = matcher.group(5).trim();
-        return declaration + argumentList + " " + implementsSection + " {}";
+
+        StringBuilder fixedRecord = new StringBuilder(declaration).append(argumentList).append(' ').append(implementsSection).append(" {");
+        alternateMethods.forEach(method -> fixedRecord.append('\n').append(method));
+        fixedRecord.append('}');
+        return fixedRecord.toString();
     }
 
-    private MethodSpec generateArgumentList()
-    {
+    private MethodSpec generateArgumentList() {
         MethodSpec.Builder builder = MethodSpec.methodBuilder(FAKE_METHOD_NAME);
-        recordComponents.forEach(element -> {
-            ParameterSpec parameterSpec = ParameterSpec.builder(ClassName.get(element.getReturnType()), element.getSimpleName().toString()).build();
-            builder.addTypeVariables(element.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()));
+        recordComponents.forEach(component -> {
+            String name = component.alternateName.orElseGet(() -> component.element.getSimpleName().toString());
+            ParameterSpec parameterSpec = ParameterSpec.builder(ClassName.get(component.element.getReturnType()), name).build();
+            builder.addTypeVariables(component.element.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList()));
             builder.addParameter(parameterSpec);
         });
         return builder.build();
     }
 
-    private List<ExecutableElement> getRecordComponents(TypeElement iface) {
-        List<ExecutableElement> components = new ArrayList<>();
+    private List<String> buildAlternateMethods(List<Component> recordComponents) {
+        return recordComponents.stream()
+                .filter(component -> component.alternateName.isPresent())
+                .map(component -> {
+                    var method = MethodSpec.methodBuilder(component.element.getSimpleName().toString())
+                            .addAnnotation(Override.class)
+                            .addAnnotation(generatedRecordInterfaceAnnotation)
+                            .returns(ClassName.get(component.element.getReturnType()))
+                            .addModifiers(Modifier.PUBLIC)
+                            .addCode("return $L();", component.alternateName.get())
+                            .build();
+                    return method.toString();
+                })
+                .collect(Collectors.toList());
+    }
+
+    private List<Component> getRecordComponents(TypeElement iface) {
+        List<Component> components = new ArrayList<>();
         try {
             getRecordComponents(iface, components, new HashSet<>(), new HashSet<>());
             if (components.isEmpty()) {
@@ -146,14 +182,14 @@ class InternalRecordInterfaceProcessor {
         return components;
     }
 
-    private static class IllegalInterface extends RuntimeException
-    {
+    private static class IllegalInterface extends RuntimeException {
         public IllegalInterface(String message) {
             super(message);
         }
+
     }
 
-    private void getRecordComponents(TypeElement iface, Collection<? super ExecutableElement> components, Set<String> visitedSet, Set<String> usedNames) {
+    private void getRecordComponents(TypeElement iface, Collection<Component> components, Set<String> visitedSet, Set<String> usedNames) {
         if (!visitedSet.add(iface.getQualifiedName().toString())) {
             return;
         }
@@ -176,10 +212,21 @@ class InternalRecordInterfaceProcessor {
                     }
                 })
                 .filter(element -> usedNames.add(element.getSimpleName().toString()))
+                .map(element -> new Component(element, stripBeanPrefix(element.getSimpleName().toString())))
                 .collect(Collectors.toCollection(() -> components));
         iface.getInterfaces().forEach(parentIface -> {
             TypeElement parentIfaceElement = (TypeElement) processingEnv.getTypeUtils().asElement(parentIface);
             getRecordComponents(parentIfaceElement, components, visitedSet, usedNames);
         });
     }
+
+    private Optional<String> stripBeanPrefix(String name) {
+        return javaBeanPrefixes.stream()
+                .filter(prefix -> name.startsWith(prefix) && (name.length() > prefix.length()))
+                .findFirst()
+                .map(prefix -> {
+                    var stripped = name.substring(prefix.length());
+                    return Character.toLowerCase(stripped.charAt(0)) + stripped.substring(1);
+                });
+    }
 }

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/OptionBasedRecordBuilderMetaData.java

@@ -1,163 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.processor;
-
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
-import java.util.Map;
-
-public class OptionBasedRecordBuilderMetaData implements RecordBuilderMetaData {
-    /**
-     * @see #suffix()
-     */
-    public static final String OPTION_SUFFIX = "suffix";
-
-    /**
-     * @see #interfaceSuffix()
-     */
-    public static final String OPTION_INTERFACE_SUFFIX = "interfaceSuffix";
-
-    /**
-     * @see #copyMethodName()
-     */
-    public static final String OPTION_COPY_METHOD_NAME = "copyMethodName";
-
-    /**
-     * @see #builderMethodName()
-     */
-    public static final String OPTION_BUILDER_METHOD_NAME = "builderMethodName";
-
-    /**
-     * @see #buildMethodName()
-     */
-    public static final String OPTION_BUILD_METHOD_NAME = "buildMethodName";
-
-    /**
-     * @see #componentsMethodName()
-     */
-    public static final String OPTION_COMPONENTS_METHOD_NAME = "componentsMethodName";
-
-    /**
-     * @see #fileComment()
-     */
-    public static final String OPTION_FILE_COMMENT = "fileComment";
-
-    /**
-     * @see #fileIndent()
-     */
-    public static final String OPTION_FILE_INDENT = "fileIndent";
-
-    /**
-     * @see #prefixEnclosingClassNames()
-     */
-    public static final String OPTION_PREFIX_ENCLOSING_CLASS_NAMES = "prefixEnclosingClassNames";
-
-    /**
-     * @see #withClassName()
-     */
-    public static final String OPTION_WITH_CLASS_NAME = "withClassName";
-
-    /**
-     * @see #withClassMethodPrefix()
-     */
-    public static final String OPTION_WITH_CLASS_METHOD_PREFIX = "withClassMethodPrefix";
-
-    private final String suffix;
-    private final String interfaceSuffix;
-    private final String copyMethodName;
-    private final String builderMethodName;
-    private final String buildMethodName;
-    private final String componentsMethodName;
-    private final String withClassName;
-    private final String withClassMethodPrefix;
-    private final String fileComment;
-    private final String fileIndent;
-    private final boolean prefixEnclosingClassNames;
-
-    public OptionBasedRecordBuilderMetaData(Map<String, String> options) {
-        suffix = options.getOrDefault(OPTION_SUFFIX, DEFAULT.suffix());
-        interfaceSuffix = options.getOrDefault(OPTION_INTERFACE_SUFFIX, DEFAULT.interfaceSuffix());
-        builderMethodName = options.getOrDefault(OPTION_BUILDER_METHOD_NAME, DEFAULT.builderMethodName());
-        copyMethodName = options.getOrDefault(OPTION_COPY_METHOD_NAME, DEFAULT.copyMethodName());
-        buildMethodName = options.getOrDefault(OPTION_BUILD_METHOD_NAME, DEFAULT.buildMethodName());
-        componentsMethodName = options.getOrDefault(OPTION_COMPONENTS_METHOD_NAME, DEFAULT.componentsMethodName());
-        withClassName = options.getOrDefault(OPTION_WITH_CLASS_NAME, DEFAULT.withClassName());
-        withClassMethodPrefix = options.getOrDefault(OPTION_WITH_CLASS_METHOD_PREFIX, DEFAULT.withClassMethodPrefix());
-        fileComment = options.getOrDefault(OPTION_FILE_COMMENT, DEFAULT.fileComment());
-        fileIndent = options.getOrDefault(OPTION_FILE_INDENT, DEFAULT.fileIndent());
-        String prefixenclosingclassnamesopt = options.getOrDefault(OPTION_PREFIX_ENCLOSING_CLASS_NAMES, String.valueOf(DEFAULT.prefixEnclosingClassNames()));
-        if (prefixenclosingclassnamesopt == null) {
-            prefixEnclosingClassNames = true;
-        } else {
-            prefixEnclosingClassNames = Boolean.parseBoolean(prefixenclosingclassnamesopt);
-        }
-    }
-
-    @Override
-    public String suffix() {
-        return suffix;
-    }
-
-    @Override
-    public String copyMethodName() {
-        return copyMethodName;
-    }
-
-    @Override
-    public String builderMethodName() {
-        return builderMethodName;
-    }
-
-    @Override
-    public String buildMethodName() {
-        return buildMethodName;
-    }
-
-    @Override
-    public String componentsMethodName() {
-        return componentsMethodName;
-    }
-
-    @Override
-    public String withClassName() {
-        return withClassName;
-    }
-
-    @Override
-    public String withClassMethodPrefix() {
-        return withClassMethodPrefix;
-    }
-
-    @Override
-    public String fileComment() {
-        return fileComment;
-    }
-
-    @Override
-    public String fileIndent() {
-        return fileIndent;
-    }
-
-    @Override
-    public boolean prefixEnclosingClassNames() {
-        return prefixEnclosingClassNames;
-    }
-
-    @Override
-    public String interfaceSuffix() {
-        return interfaceSuffix;
-    }
-}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/OptionalType.java

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+
+public record OptionalType(TypeName typeName, TypeName valueType) {
+
+    private static final TypeName optionalType = TypeName.get(Optional.class);
+    private static final TypeName optionalIntType = TypeName.get(OptionalInt.class);
+    private static final TypeName optionalLongType = TypeName.get(OptionalLong.class);
+    private static final TypeName optionalDoubleType = TypeName.get(OptionalDouble.class);
+
+    private static boolean isOptional(ClassType component) {
+        if (component.typeName().equals(optionalType)) {
+            return true;
+        }
+        return (component.typeName() instanceof ParameterizedTypeName parameterizedTypeName)
+                && parameterizedTypeName.rawType.equals(optionalType);
+    }
+
+    static Optional<OptionalType> fromClassType(final ClassType component) {
+        if (isOptional(component)) {
+            if (!(component.typeName() instanceof ParameterizedTypeName parameterizedType)) {
+                return Optional.of(new OptionalType(optionalType, TypeName.get(Object.class)));
+            }
+            final TypeName containingType = parameterizedType.typeArguments.isEmpty()
+                    ? TypeName.get(Object.class)
+                    : parameterizedType.typeArguments.get(0);
+            return Optional.of(new OptionalType(optionalType, containingType));
+        }
+        if (component.typeName().equals(optionalIntType)) {
+            return Optional.of(new OptionalType(optionalIntType, TypeName.get(int.class)));
+        }
+        if (component.typeName().equals(optionalLongType)) {
+            return Optional.of(new OptionalType(optionalLongType, TypeName.get(long.class)));
+        }
+        if (component.typeName().equals(optionalDoubleType)) {
+            return Optional.of(new OptionalType(optionalDoubleType, TypeName.get(double.class)));
+        }
+        return Optional.empty();
+    }
+
+    public boolean isOptional() {
+        return typeName.equals(optionalType);
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderMetaDataLoader.java

@@ -1,53 +0,0 @@
-/**
- * Copyright 2019 Jordan Zimmerman
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package io.soabase.recordbuilder.processor;
-
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.Map;
-import java.util.function.Consumer;
-
-import javax.annotation.processing.ProcessingEnvironment;
-
-class RecordBuilderMetaDataLoader {
-    private final RecordBuilderMetaData metaData;
-
-    RecordBuilderMetaDataLoader(ProcessingEnvironment processingEnv, Consumer<String> logger) {
-        Map<String, String> options = processingEnv.getOptions();
-        String metaDataClassName = options.get(RecordBuilderMetaData.JAVAC_OPTION_NAME);
-        if ((metaDataClassName != null) && !metaDataClassName.isEmpty()) {
-            RecordBuilderMetaData loadedMetaData = null;
-            try {
-                Class<?> clazz = Class.forName(metaDataClassName);
-                loadedMetaData = (RecordBuilderMetaData) clazz.getDeclaredConstructor().newInstance();
-                logger.accept("Found meta data: " + clazz);
-            } catch (InvocationTargetException e) {
-                // log the thrown exception instead of the invocation target exception
-                logger.accept("Could not load meta data: " + metaDataClassName + " - " + e.getCause());
-            } catch (Exception e) {
-                logger.accept("Could not load meta data: " + metaDataClassName + " - " + e);
-            }
-            metaData = (loadedMetaData != null) ? loadedMetaData : RecordBuilderMetaData.DEFAULT;
-        } else {
-            metaData = new OptionBasedRecordBuilderMetaData(options);
-        }
-    }
-
-    RecordBuilderMetaData getMetaData() {
-        return metaData;
-    }
-}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderOptions.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+import java.util.Map;
+
+class RecordBuilderOptions {
+    private static final Map<String, Object> defaultValues = buildDefaultValues();
+
+    static RecordBuilder.Options build(Map<String, String> options) {
+        return (RecordBuilder.Options)Proxy.newProxyInstance(RecordBuilderOptions.class.getClassLoader(), new Class[]{RecordBuilder.Options.class}, (proxy, method, args) -> {
+            var name = method.getName();
+            var defaultValue = defaultValues.get(name);
+            var option = options.get(name);
+            if (option != null) {
+                if (defaultValue instanceof String) {
+                    return option;
+                }
+                if (defaultValue instanceof Boolean) {
+                    return Boolean.parseBoolean(option);
+                }
+                if (defaultValue instanceof Integer) {
+                    return Integer.parseInt(option);
+                }
+                if (defaultValue instanceof Long) {
+                    return Long.parseLong(option);
+                }
+                if (defaultValue instanceof Double) {
+                    return Double.parseDouble(option);
+                }
+                throw new IllegalArgumentException("Unhandled option type: " + defaultValue.getClass());
+            }
+            return defaultValue;
+        });
+    }
+
+    private static Map<String, Object> buildDefaultValues() {
+        var workMap = new HashMap<String, Object>();
+        for ( Method method : RecordBuilder.Options.class.getDeclaredMethods()) {
+            workMap.put(method.getName(), method.getDefaultValue());
+        }
+        workMap.put("toString", "Generated RecordBuilder.Options");
+        return Map.copyOf(workMap);
+    }
+
+    private RecordBuilderOptions() {
+    }
+}

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderProcessor.java

@@ -18,39 +18,48 @@ package io.soabase.recordbuilder.processor;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.JavaFile;
 import com.squareup.javapoet.TypeSpec;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordBuilderGenerated;
 import io.soabase.recordbuilder.core.RecordInterface;
 
-import javax.annotation.processing.*;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Generated;
+import javax.annotation.processing.RoundEnvironment;
 import javax.lang.model.SourceVersion;
 import javax.lang.model.element.Element;
+import javax.lang.model.element.PackageElement;
 import javax.lang.model.element.TypeElement;
 import javax.tools.Diagnostic;
 import javax.tools.JavaFileObject;
 import java.io.IOException;
 import java.io.Writer;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 
-import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.RECORD_BUILDER;
-import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.RECORD_INTERFACE;
+public class RecordBuilderProcessor
+        extends AbstractProcessor {
+    private static final String RECORD_BUILDER = RecordBuilder.class.getName();
+    private static final String RECORD_BUILDER_INCLUDE = RecordBuilder.Include.class.getName().replace('$', '.');
+    private static final String RECORD_INTERFACE = RecordInterface.class.getName();
+    private static final String RECORD_INTERFACE_INCLUDE = RecordInterface.Include.class.getName().replace('$', '.');
 
-@SupportedAnnotationTypes({RECORD_BUILDER, RECORD_INTERFACE})
-public class RecordBuilderProcessor extends AbstractProcessor {
-    public static final String RECORD_BUILDER = "io.soabase.recordbuilder.core.RecordBuilder";
-    public static final String RECORD_INTERFACE = "io.soabase.recordbuilder.core.RecordInterface";
-
-    static final AnnotationSpec generatedRecordBuilderAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RECORD_BUILDER).build();
-    static final AnnotationSpec generatedRecordInterfaceAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RECORD_INTERFACE).build();
+    static final AnnotationSpec generatedRecordBuilderAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RecordBuilder.class.getName()).build();
+    static final AnnotationSpec generatedRecordInterfaceAnnotation = AnnotationSpec.builder(Generated.class).addMember("value", "$S", RecordInterface.class.getName()).build();
+    static final AnnotationSpec recordBuilderGeneratedAnnotation = AnnotationSpec.builder(RecordBuilderGenerated.class).build();
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation)
-                .forEach(element -> process(annotation, element))
-        );
-        return true;
+        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation).forEach(element -> process(annotation, element)));
+        return false;
     }
-    
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+        return Set.of("*");
+    }
+
     @Override
     public SourceVersion getSupportedSourceVersion() {
         // we don't directly return RELEASE_14 as that may 
@@ -61,30 +70,93 @@ public class RecordBuilderProcessor extends AbstractProcessor {
     }
 
     private void process(TypeElement annotation, Element element) {
-        var metaData = new RecordBuilderMetaDataLoader(processingEnv, s -> processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, s)).getMetaData();
-
-        if (annotation.getQualifiedName().toString().equals(RECORD_BUILDER)) {
-            processRecordBuilder((TypeElement) element, metaData);
-        } else if (annotation.getQualifiedName().toString().equals(RECORD_INTERFACE)) {
-            processRecordInterface((TypeElement) element, element.getAnnotation(RecordInterface.class), metaData);
+        String annotationClass = annotation.getQualifiedName().toString();
+        if (annotationClass.equals(RECORD_BUILDER)) {
+            var typeElement = (TypeElement) element;
+            processRecordBuilder(typeElement, getMetaData(typeElement), Optional.empty());
+        } else if (annotationClass.equals(RECORD_INTERFACE)) {
+            var typeElement = (TypeElement) element;
+            processRecordInterface(typeElement, element.getAnnotation(RecordInterface.class).addRecordBuilder(), getMetaData(typeElement), Optional.empty(), false);
+        } else if (annotationClass.equals(RECORD_BUILDER_INCLUDE) || annotationClass.equals(RECORD_INTERFACE_INCLUDE)) {
+            processIncludes(element, getMetaData(element), annotationClass);
         } else {
-            throw new RuntimeException("Unknown annotation: " + annotation);
+            var recordBuilderTemplate = annotation.getAnnotation(RecordBuilder.Template.class);
+            if (recordBuilderTemplate != null) {
+                if (recordBuilderTemplate.asRecordInterface()) {
+                    processRecordInterface((TypeElement) element, true, recordBuilderTemplate.options(), Optional.empty(), true);
+                } else {
+                    processRecordBuilder((TypeElement) element, recordBuilderTemplate.options(), Optional.empty());
+                }
+            }
         }
     }
 
-    private void processRecordInterface(TypeElement element, RecordInterface recordInterface, RecordBuilderMetaData metaData) {
+    private RecordBuilder.Options getMetaData(Element element) {
+        var recordSpecificMetaData = element.getAnnotation(RecordBuilder.Options.class);
+        return (recordSpecificMetaData != null) ? recordSpecificMetaData : RecordBuilderOptions.build(processingEnv.getOptions());
+    }
+
+    private void processIncludes(Element element, RecordBuilder.Options metaData, String annotationClass) {
+        var isRecordBuilderInclude = annotationClass.equals(RECORD_BUILDER_INCLUDE);
+        var annotationMirrorOpt = ElementUtils.findAnnotationMirror(processingEnv, element, annotationClass);
+        if (annotationMirrorOpt.isEmpty()) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get annotation mirror for: " + annotationClass, element);
+        } else {
+            var includeHelper = new IncludeHelper(processingEnv, element, annotationMirrorOpt.get(), isRecordBuilderInclude);
+            if (includeHelper.isValid()) {
+                var packagePattern = ElementUtils.getStringAttribute(ElementUtils.getAnnotationValue(includeHelper.getAnnotationValues(), "packagePattern").orElse(null), "*");
+                for (var typeElement : includeHelper.getClassTypeElements()) {
+                    var packageName = buildPackageName(packagePattern, element, typeElement);
+                    if (packageName != null) {
+                        if (isRecordBuilderInclude) {
+                            processRecordBuilder(typeElement, metaData, Optional.of(packageName));
+                        } else {
+                            var addRecordBuilderOpt = ElementUtils.getAnnotationValue(includeHelper.getAnnotationValues(), "addRecordBuilder");
+                            var addRecordBuilder = addRecordBuilderOpt.map(ElementUtils::getBooleanAttribute).orElse(true);
+                            processRecordInterface(typeElement, addRecordBuilder, metaData, Optional.of(packageName), false);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private String buildPackageName(String packagePattern, Element builderElement, TypeElement includedClass) {
+        PackageElement includedClassPackage = findPackageElement(includedClass, includedClass);
+        if (includedClassPackage == null) {
+            return null;
+        }
+        String replaced = packagePattern.replace("*", includedClassPackage.getQualifiedName().toString());
+        if (builderElement instanceof PackageElement) {
+            return replaced.replace("@", ((PackageElement) builderElement).getQualifiedName().toString());
+        }
+        return replaced.replace("@", ((PackageElement) builderElement.getEnclosingElement()).getQualifiedName().toString());
+    }
+
+    private PackageElement findPackageElement(Element actualElement, Element includedClass) {
+        if (includedClass == null) {
+            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Element has not package", actualElement);
+            return null;
+        }
+        if (includedClass.getEnclosingElement() instanceof PackageElement) {
+            return (PackageElement) includedClass.getEnclosingElement();
+        }
+        return findPackageElement(actualElement, includedClass.getEnclosingElement());
+    }
+
+    private void processRecordInterface(TypeElement element, boolean addRecordBuilder, RecordBuilder.Options metaData, Optional<String> packageName, boolean fromTemplate) {
         if (!element.getKind().isInterface()) {
             processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "RecordInterface only valid for interfaces.", element);
             return;
         }
-        var internalProcessor = new InternalRecordInterfaceProcessor(processingEnv, element, recordInterface, metaData);
+        var internalProcessor = new InternalRecordInterfaceProcessor(processingEnv, element, addRecordBuilder, metaData, packageName, fromTemplate);
         if (!internalProcessor.isValid()) {
             return;
         }
         writeRecordInterfaceJavaFile(element, internalProcessor.packageName(), internalProcessor.recordClassType(), internalProcessor.recordType(), metaData, internalProcessor::toRecord);
     }
 
-    private void processRecordBuilder(TypeElement record, RecordBuilderMetaData metaData) {
+    private void processRecordBuilder(TypeElement record, RecordBuilder.Options metaData, Optional<String> packageName) {
         // we use string based name comparison for the element kind,
         // as the ElementKind.RECORD enum doesn't exist on JRE releases
         // older than Java 14, and we don't want to throw unexpected
@@ -93,30 +165,26 @@ public class RecordBuilderProcessor extends AbstractProcessor {
             processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "RecordBuilder only valid for records.", record);
             return;
         }
-        var internalProcessor = new InternalRecordBuilderProcessor(record, metaData);
+        var internalProcessor = new InternalRecordBuilderProcessor(processingEnv, record, metaData, packageName);
         writeRecordBuilderJavaFile(record, internalProcessor.packageName(), internalProcessor.builderClassType(), internalProcessor.builderType(), metaData);
     }
 
-    private void writeRecordBuilderJavaFile(TypeElement record, String packageName, ClassType builderClassType, TypeSpec builderType, RecordBuilderMetaData metaData) {
+    private void writeRecordBuilderJavaFile(TypeElement record, String packageName, ClassType builderClassType, TypeSpec builderType, RecordBuilder.Options metaData) {
         // produces the Java file
         JavaFile javaFile = javaFileBuilder(packageName, builderType, metaData);
         Filer filer = processingEnv.getFiler();
-        try
-        {
+        try {
             String fullyQualifiedName = packageName.isEmpty() ? builderClassType.name() : (packageName + "." + builderClassType.name());
             JavaFileObject sourceFile = filer.createSourceFile(fullyQualifiedName);
-            try ( Writer writer = sourceFile.openWriter() )
-            {
+            try (Writer writer = sourceFile.openWriter()) {
                 javaFile.writeTo(writer);
             }
-        }
-        catch ( IOException e )
-        {
+        } catch (IOException e) {
             handleWriteError(record, e);
         }
     }
 
-    private void writeRecordInterfaceJavaFile(TypeElement element, String packageName, ClassType classType, TypeSpec type, RecordBuilderMetaData metaData, Function<String, String> toRecordProc) {
+    private void writeRecordInterfaceJavaFile(TypeElement element, String packageName, ClassType classType, TypeSpec type, RecordBuilder.Options metaData, Function<String, String> toRecordProc) {
         JavaFile javaFile = javaFileBuilder(packageName, type, metaData);
 
         String classSourceCode = javaFile.toString();
@@ -124,25 +192,19 @@ public class RecordBuilderProcessor extends AbstractProcessor {
         String recordSourceCode = toRecordProc.apply(classSourceCode);
 
         Filer filer = processingEnv.getFiler();
-        try
-        {
+        try {
             String fullyQualifiedName = packageName.isEmpty() ? classType.name() : (packageName + "." + classType.name());
             JavaFileObject sourceFile = filer.createSourceFile(fullyQualifiedName);
-            try ( Writer writer = sourceFile.openWriter() )
-            {
+            try (Writer writer = sourceFile.openWriter()) {
                 writer.write(recordSourceCode);
             }
-        }
-        catch ( IOException e )
-        {
+        } catch (IOException e) {
             handleWriteError(element, e);
         }
     }
 
-    private JavaFile javaFileBuilder(String packageName, TypeSpec type, RecordBuilderMetaData metaData) {
-        var javaFileBuilder = JavaFile.builder(packageName, type)
-                .skipJavaLangImports(true)
-                .indent(metaData.fileIndent());
+    private JavaFile javaFileBuilder(String packageName, TypeSpec type, RecordBuilder.Options metaData) {
+        var javaFileBuilder = JavaFile.builder(packageName, type).skipJavaLangImports(true).indent(metaData.fileIndent());
         var comment = metaData.fileComment();
         if ((comment != null) && !comment.isEmpty()) {
             javaFileBuilder.addFileComment(comment);

record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordClassType.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.processor;
+
+import com.squareup.javapoet.TypeName;
+
+import javax.lang.model.element.AnnotationMirror;
+import java.util.List;
+
+public class RecordClassType extends ClassType {
+    private final TypeName rawTypeName;
+    private final List<? extends AnnotationMirror> accessorAnnotations;
+    private final List<? extends AnnotationMirror> canonicalConstructorAnnotations;
+
+    public RecordClassType(TypeName typeName, TypeName rawTypeName, String name, List<? extends AnnotationMirror> accessorAnnotations, List<? extends AnnotationMirror> canonicalConstructorAnnotations) {
+        super(typeName, name);
+        this.rawTypeName = rawTypeName;
+        this.accessorAnnotations = accessorAnnotations;
+        this.canonicalConstructorAnnotations = canonicalConstructorAnnotations;
+    }
+
+    public TypeName rawTypeName() {
+        return rawTypeName;
+    }
+
+    public List<? extends AnnotationMirror> getAccessorAnnotations() {
+        return accessorAnnotations;
+    }
+
+    public List<? extends AnnotationMirror> getCanonicalConstructorAnnotations() {
+        return canonicalConstructorAnnotations;
+    }
+}

record-builder-test-custom-enhancer/pom.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>34-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>record-builder-test-custom-enhancer</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

record-builder-test-custom-enhancer/src/main/java/io/soabase/recordbuilder/enhancer/test/TestEnhancer.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.spi.Processor;
+import io.soabase.recordbuilder.enhancer.spi.RecordBuilderEnhancer;
+import recordbuilder.org.objectweb.asm.Opcodes;
+import recordbuilder.org.objectweb.asm.tree.FieldInsnNode;
+import recordbuilder.org.objectweb.asm.tree.InsnList;
+import recordbuilder.org.objectweb.asm.tree.InsnNode;
+import recordbuilder.org.objectweb.asm.tree.MethodInsnNode;
+
+import javax.lang.model.element.TypeElement;
+import java.util.List;
+
+public class TestEnhancer
+    implements RecordBuilderEnhancer
+{
+    @Override
+    public InsnList enhance(Processor processor, TypeElement element, List<String> arguments)
+    {
+        /*
+           4: getstatic     #7                  // Field io/soabase/recordbuilder/enhancer/test/Counter.COUNTER:Ljava/util/concurrent/atomic/AtomicInteger;
+           7: invokevirtual #13                 // Method java/util/concurrent/atomic/AtomicInteger.incrementAndGet:()I
+          10: pop
+         */
+        InsnList insnList = new InsnList();
+        insnList.add(new FieldInsnNode(Opcodes.GETSTATIC, "io/soabase/recordbuilder/enhancer/test/Counter", "COUNTER", "Ljava/util/concurrent/atomic/AtomicInteger;"));
+        insnList.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/concurrent/atomic/AtomicInteger", "incrementAndGet", "()I"));
+        insnList.add(new InsnNode(Opcodes.POP));
+        return insnList;
+    }
+
+    public String description() {
+        return "This is a test";
+    }
+}

record-builder-test/pom.xml

@@ -3,18 +3,71 @@
     <parent>
         <groupId>io.soabase.record-builder</groupId>
         <artifactId>record-builder</artifactId>
-        <version>1.11.ea-SNAPSHOT</version>
+        <version>34-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>record-builder-test</artifactId>
 
+    <properties>
+        <license-file-path>${project.parent.basedir}/src/etc/header.txt</license-file-path>
+    </properties>
+
     <dependencies>
+        <dependency>
+            <groupId>javax.validation</groupId>
+            <artifactId>validation-api</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>io.soabase.record-builder</groupId>
             <artifactId>record-builder-core</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-processor</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-enhancer</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-validator</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-test-custom-enhancer</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>javax.el</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
@@ -24,27 +77,6 @@
 
     <build>
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-            </plugin>
-
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <annotationProcessorPaths>
-                        <annotationProcessorPath>
-                            <groupId>io.soabase.record-builder</groupId>
-                            <artifactId>record-builder-processor</artifactId>
-                            <version>${project.version}</version>
-                        </annotationProcessorPath>
-                    </annotationProcessorPaths>
-                    <annotationProcessors>
-                        <annotationProcessor>io.soabase.recordbuilder.processor.RecordBuilderProcessor</annotationProcessor>
-                    </annotationProcessors>
-                </configuration>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-deploy-plugin</artifactId>
@@ -60,6 +92,48 @@
                     <skip>true</skip>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>default-prepare-agent</id>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-report</id>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>default-check</id>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                        <configuration>
+                            <includes>
+                                <include>io/soabase/recordbuilder/test/jacoco/*</include>
+                            </includes>
+                            <rules>
+                                <rule>
+                                    <element>BUNDLE</element>
+                                    <limits>
+                                        <limit>
+                                            <counter>COMPLEXITY</counter>
+                                            <value>COVEREDRATIO</value>
+                                            <minimum>0.60</minimum>
+                                        </limit>
+                                    </limits>
+                                </rule>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </project>

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CopyCollectionNullableEmptyTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollectionNullableEmpty;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = CopyCollectionNullableEmpty.class)
+public record CopyCollectionNullableEmptyTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/Counter.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Counter {
+    public static final AtomicInteger COUNTER = new AtomicInteger();
+
+    private Counter() {
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CustomEnhance.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollectionNullableEmpty;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullOptional;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullString;
+import io.soabase.recordbuilder.enhancer.enhancers.RequireNonNull;
+
+import java.lang.annotation.*;
+
+@RecordBuilderEnhance.Template(enhancers = {CopyCollectionNullableEmpty.class, EmptyNullString.class, EmptyNullOptional.class, RequireNonNull.class})
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE)
+@Inherited
+public @interface CustomEnhance {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/CustomEnhanced.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.List;
+import java.util.Optional;
+
+@CustomEnhance
+public record CustomEnhanced(String s, Optional<String> o, Instant i, List<BigDecimal> l) {
+    public CustomEnhanced {
+        Counter.COUNTER.decrementAndGet();
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/GuavaCopyCollectionNullableEmptyTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.GuavaCopyCollectionNullableEmpty;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = GuavaCopyCollectionNullableEmpty.class)
+public record GuavaCopyCollectionNullableEmptyTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/GuavaCopyCollectionTest.java

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.GuavaCopyCollection;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = GuavaCopyCollection.class)
+public record GuavaCopyCollectionTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/MadeUpNotNullable.java

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.RECORD_COMPONENT;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+@Target(RECORD_COMPONENT)
+@Retention(SOURCE)
+public @interface MadeUpNotNullable {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/NotNullAnnotation.java

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhanceArguments;
+import io.soabase.recordbuilder.enhancer.enhancers.NotNullAnnotations;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilderEnhance(enhancers = NotNullAnnotations.class,
+        arguments = @RecordBuilderEnhanceArguments(enhancer = NotNullAnnotations.class, arguments = ".*notnull.*"))
+public record NotNullAnnotation(String s, @NotNull Integer i, @MadeUpNotNullable Double d) {
+    public NotNullAnnotation() {
+        this(null, null, null);
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/NotNullableCopyCollectionTest.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.CopyCollection;
+import io.soabase.recordbuilder.enhancer.enhancers.RequireNonNull;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RecordBuilderEnhance(enhancers = {RequireNonNull.class, CopyCollection.class})
+public record NotNullableCopyCollectionTest(Collection<Instant> c, List<BigInteger> l, Set<Boolean> s, Map<Map<String, Short>, AtomicBoolean> m) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/OptionalTest.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullOptional;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+@RecordBuilderEnhance(enhancers = EmptyNullOptional.class)
+public record OptionalTest(OptionalInt i, OptionalLong l, OptionalDouble d, Optional<String> o) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/PluginTest.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+
+@RecordBuilderEnhance(enhancers = TestEnhancer.class)
+public record PluginTest(int i) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/enhancer/test/StringTest.java

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.enhancer.test;
+
+import io.soabase.recordbuilder.enhancer.RecordBuilderEnhance;
+import io.soabase.recordbuilder.enhancer.enhancers.EmptyNullString;
+
+@RecordBuilderEnhance(enhancers = EmptyNullString.class)
+public record StringTest(String s) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Annotated.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Null;
+
+@RecordBuilder
+public record Annotated(@NotNull @Null String hey, @Min(10) @Max(100) int i, double d) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/BeanStyle.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordInterface;
+import java.time.Instant;
+
+@RecordInterface
+public interface BeanStyle {
+    String getName();
+
+    Instant getDate();
+
+    boolean isSomething();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Builder.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordInterface;
+
+@RecordInterface.Include({
+    Thingy.class
+})
+@RecordBuilder.Include({
+    Nested.NestedRecord.class
+})
+public class Builder {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionInterface.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordInterface;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordInterface
+@RecordBuilder.Options(useImmutableCollections = true)
+public interface CollectionInterface<T, X extends Point> {
+    List<T> l();
+
+    Set<T> s();
+
+    Map<T, X> m();
+
+    Collection<X> c();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecord.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(useImmutableCollections = true, addFunctionalMethodsToWith = true)
+public record CollectionRecord<T, X extends Point>(List<T> l, Set<T> s, Map<T, X> m,
+                                                   Collection<X> c) implements CollectionRecordBuilder.With<T, X> {
+    public static void main(String[] args) {
+        var r = new CollectionRecord<>(List.of("hey"), Set.of("there"), Map.of("one", new Point(10, 20)), Set.of(new Point(30, 40)));
+        Instant now = r.map((l1, s1, m1, c1) -> Instant.now());
+        r.accept((l1, s1, m1, c1) -> {
+        });
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecordConflicts.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(useImmutableCollections = true)
+public record CollectionRecordConflicts(List<String> __list, Set<String> __set, Map<String, String> __map, Collection<String> __collection) implements CollectionRecordConflictsBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/CustomMethodNames.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.util.List;
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.test.CustomMethodNamesBuilder.Bean;
+
+@RecordBuilder
+@RecordBuilder.Options(
+    setterPrefix = "set", getterPrefix = "get", booleanPrefix = "is", beanClassName = "Bean")
+public record CustomMethodNames(
+    int theValue,
+    List<Integer> theList,
+    boolean theBoolean) implements Bean {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Customer.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.time.Instant;
+
+public interface Customer {
+    String name();
+
+    String address();
+
+    Instant activeDate();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Empty.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+public record Empty() implements EmptyBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/ExceptionDetails.java

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.lang.model.type.ErrorType;
+import java.util.List;
+
+@RecordBuilder
+public record ExceptionDetails(
+        String internalMessage, String endUserMessage, String httpStatus,
+        ErrorType errorType, List<String> jsonProblems, Throwable cause
+) {
+    @Override
+    public List<String> jsonProblems() {
+        if (jsonProblems == null) {
+            return List.of();
+        }
+        return jsonProblems;
+    }
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/FullRecord.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilderFull;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+import java.util.Map;
+
+@RecordBuilderFull
+public record FullRecord(@NotNull List<Number> numbers, @NotNull Map<Number, FullRecord> fullRecords, @NotNull String justAString) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/IgnoreAnnotated.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder()
+@RecordBuilder.Options(inheritComponentAnnotations = false)
+public record IgnoreAnnotated(@NotNull String s) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/IncludeWithOption.java

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(prefixEnclosingClassNames = false)
+@RecordBuilder.Include(IncludeWithOption.Hey.class)
+public class IncludeWithOption {
+    public static record Hey(String s){}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/InterfaceTemplateTest.java

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+@MyInterfaceTemplate
+public interface InterfaceTemplateTest {
+    String name();
+
+    int age();
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MutableCollectionRecord.java

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.List;
+
+@RecordBuilder
+public record MutableCollectionRecord(List<String> l) implements MutableCollectionRecordBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MyInterfaceTemplate.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "This is a test",
+        withClassName = "Com"),
+        asRecordInterface = true
+)
+public @interface MyInterfaceTemplate {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/MyTemplate.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Template(options = @RecordBuilder.Options(
+        fileComment = "This is a test",
+        withClassName = "Com"
+))
+public @interface MyTemplate
+{
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Nested.java

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public class Nested {
+    record NestedRecord(int x, int y){}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/NoStaticBuilder.java

@@ -0,0 +1,23 @@
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@RecordBuilder.Options(addStaticBuilder = false)
+@RecordBuilder
+public record NoStaticBuilder(String foo) {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Pair.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public record Pair<T, U>(T t, U u) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/Point.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+public record Point(int x, int y) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithAnR.java

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+public record RecordWithAnR(int r, String b) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional.java

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import javax.validation.constraints.NotNull;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+@RecordBuilder.Options(emptyDefaultForOptional = true, addConcreteSettersForOptional = true)
+@RecordBuilder
+public record RecordWithOptional(@NotNull Optional<String> value, Optional raw, OptionalInt i, OptionalLong l, OptionalDouble d) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional2.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder.Options(emptyDefaultForOptional = true)
+@RecordBuilder
+public record RecordWithOptional2(Optional<String> value, Optional raw, OptionalInt i, OptionalLong l, OptionalDouble d) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequestWithValid.java

@@ -0,0 +1,28 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder
+@RecordBuilder.Options(useValidationApi = true)
+public record RequestWithValid(@NotNull @Valid Part part) implements RequestWithValidBuilder.With {
+  public record Part(@NotBlank String name) {}
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@RecordBuilder.Options(interpretNotNulls = true)
+@RecordBuilder
+public record RequiredRecord(@NotNull String hey, @NotNull int i, @NotNull List<String> l) implements RequiredRecordBuilder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord2.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import javax.validation.constraints.NotNull;
+
+@RecordBuilder.Options(useValidationApi = true)
+@RecordBuilder
+public record RequiredRecord2(@NotNull String hey, @NotNull int i) implements RequiredRecord2Builder.With {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/SimpleRecord.java

@@ -18,5 +18,6 @@ package io.soabase.recordbuilder.test;
 import io.soabase.recordbuilder.core.RecordBuilder;
 
 @RecordBuilder
+@RecordBuilder.Options(prefixEnclosingClassNames = false)
 public record SimpleRecord(int i, String s) {
 }

record-builder-test/src/main/java/io/soabase/recordbuilder/test/SingleItems.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RecordBuilder
+@RecordBuilder.Options(
+        addSingleItemCollectionBuilders = true,
+        singleItemBuilderPrefix = "add1",
+        useImmutableCollections = true,
+        addFunctionalMethodsToWith = true
+)
+public record SingleItems<T>(List<String> strings, Set<List<T>> sets, Map<Instant, T> map, Collection<T> collection) implements SingleItemsBuilder.With<T> {
+}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/StrippedFeaturesRecord.java

@@ -0,0 +1,25 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+@RecordBuilder.Options(
+    enableGetters = false,
+    enableWither = false
+)
+public record StrippedFeaturesRecord(int aField) {}

record-builder-test/src/main/java/io/soabase/recordbuilder/test/TemplateTest.java

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 Jordan Zimmerman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.soabase.recordbuilder.test;
+
+import java.time.Instant;
+
+@MyTemplate
+public record TemplateTest(String text, Instant date) implements TemplateTestBuilder.Com
+{
+}