[maven-release-plugin] prepare release record-builder-26

[maven-release-plugin] prepare for next development iteration
[maven-release-plugin] prepare release record-builder-25-java15
2021-08-18 08:19:14 -05:00 · 2021-08-18 08:15:23 -05:00 · 2021-08-18 08:15:19 -05:00 · 2021-08-18 08:01:48 -05:00 · 2021-08-18 07:48:28 -05:00 · 2021-08-18 07:48:04 -05:00
58 changed files with 2492 additions and 629 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: Randgalt
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.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.0.0-ea
+    - name: Build with Maven
+      run: mvn -B package --file pom.xml
--- a/.github/workflows/maven_java15.yml
+++ b/.github/workflows/maven_java15.yml
@@ -0,0 +1,28 @@
+# 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 15
+
+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: 15
+    - name: Create Maven Directory
+      run: mkdir -p .mvn/
+    - name: Create Maven JVM file
+      run: echo "--enable-preview" > .mvn/jvm.config
+    - name: Build with Maven
+      run: mvn -P java15 -B package --file pom.xml
--- a/.mvn/jvm.config
+++ b/.mvn/jvm.config
@@ -1 +0,0 @@
--enable-preview
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +0,0 @@
-language: java
-jdk:
-  - openjdk15
--- a/README.md
+++ b/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)
+- [Java 15 Versions](#java-15-versions)

 ## 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,15 +62,24 @@ 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"));
+   }
+});
 ```

 _Hat tip to [Benji Weber](https://benjiweber.co.uk/blog/2020/09/19/fun-with-java-records/) for the Withers idea._
@@ -84,6 +102,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
     */
@@ -159,25 +184,33 @@ public class NameAndAgeBuilder {
                && 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 +219,14 @@ 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);
        }
    }
 }
@@ -215,7 +246,8 @@ This will generate a record ala:

 ```java
@RecordBuilder
-public record NameAndAgeRecord(String name, int age) implements NameAndAge {}
+public record NameAndAgeRecord(String name, int age) implements 
+    NameAndAge, NameAndAgeRecordBuilder.With {}
 ```

 Note that the generated record is annotated with `@RecordBuilder` so a record
@@ -229,25 +261,53 @@ 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 {
+}
+```
+
+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).  

 ## Usage

 ### Maven

-1\. Add the dependency that contains the `@RecordBuilder` annotation.
+1) Add the dependency that contains the `@RecordBuilder` annotation.

-```
+```xml
 <dependency>
    <groupId>io.soabase.record-builder</groupId>
    <artifactId>record-builder-core</artifactId>
    <version>set-version-here</version>
+    <scope>provided</scope>
 </dependency>

 ```

-2\. Enable the annotation processing for the Maven Compiler Plugin:
+2) Enable the annotation processing for the Maven Compiler Plugin:

-```
+```xml
 <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
@@ -265,6 +325,74 @@ Notes:
        </annotationProcessors>

        
+        ... any other options here ...
+    </configuration>
+</plugin>
+```
+
+### Gradle
+
+Add the following to your build.gradle file:
+
+```groovy
+dependencies {
+    annotationProcessor 'io.soabase.record-builder:record-builder-processor:$version-goes-here'
+    compileOnly 'io.soabase.record-builder:record-builder-core:$version-goes-here'
+}
+```
+
+### IDE
+
+Depending on your IDE you are likely to need to enable Annotation Processing in your IDE settings.
+
+## Customizing
+
+RecordBuilder can be customized to your needs and you can even create your
+own custom RecordBuilder annotations. See [Customizing RecordBuilder](customizing.md)
+for details.
+
+## Java 15 Versions
+
+Artifacts compiled wth Java 15 are available. These versions have `-java15` appended.
+
+Note: records are a preview feature only in Java 15. 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`.
+
+You will need to enable preview in your build tools:
+
+### Maven
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder-core</artifactId>
+        <version>record-builder-version-java15</version>
+    </dependency>
+</dependencies>
+
+<plugin>
+    <groupId>org.apache.maven.plugins</groupId>
+    <artifactId>maven-compiler-plugin</artifactId>
+    <version>maven-compiler-version</version>
+    <configuration>
+        <annotationProcessorPaths>
+            <annotationProcessorPath>
+                <groupId>io.soabase.record-builder</groupId>
+                <artifactId>record-builder-processor</artifactId>
+                <version>record-builder-version-java15</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>
@@ -276,18 +404,14 @@ Notes:
 </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'
+    annotationProcessor 'io.soabase.record-builder:record-builder-processor:$record-builder-version-java15'
+    compileOnly 'io.soabase.record-builder:record-builder-core:$record-builder-version-java15'
 }

 tasks.withType(JavaCompile) {
@@ -299,39 +423,3 @@ tasks.withType(Test) {
    jvmArgs += "--enable-preview"
 }
 ```
-
-### IDE
-
-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`
--- a/customizing.md
+++ b/customizing.md
@@ -0,0 +1,85 @@
+[◀︎ RecordBuilder](README.md) • Customizing RecordBuilder
+
+# 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. 
+
+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.
--- a/java15.sh
+++ b/java15.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+#
+# 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.
+#
+
+
+jenv local 15
+javahome
+mkdir -p .mvn/
+echo "--enable-preview" > .mvn/jvm.config
--- a/java16.sh
+++ b/java16.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+#
+# 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.
+#
+
+
+jenv local 16
+javahome
+rm -fr .mvn
--- a/pom.xml
+++ b/pom.xml
@@ -5,12 +5,13 @@
    <groupId>io.soabase.record-builder</groupId>
    <artifactId>record-builder</artifactId>
    <packaging>pom</packaging>
-    <version>1.10.ea</version>
+    <version>26</version>

    <modules>
        <module>record-builder-core</module>
        <module>record-builder-processor</module>
        <module>record-builder-test</module>
+        <module>record-builder-validator</module>
    </modules>

    <properties>
@@ -18,7 +19,9 @@
        <project.build.resourceEncoding>UTF-8</project.build.resourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

-        <jdk-version>15</jdk-version>
+        <enable-preview />
+
+        <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>
@@ -31,10 +34,16 @@
        <maven-shade-plugin-version>3.2.1</maven-shade-plugin-version>
        <maven-release-plugin-version>2.5.3</maven-release-plugin-version>
        <maven-surefire-plugin-version>3.0.0-M5</maven-surefire-plugin-version>
+        <maven-jar-plugin-version>3.2.0</maven-jar-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>
+        <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>
    </properties>

    <name>Record Builder</name>
@@ -71,7 +80,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>record-builder-1.10.ea</tag>
+        <tag>record-builder-26</tag>
    </scm>

    <issueManagement>
@@ -106,11 +115,35 @@
                <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>
        </dependencies>
    </dependencyManagement>

@@ -124,7 +157,7 @@
                    <configuration>
                        <release>${jdk-version}</release>
                        <compilerArgs>
-                            <arg>--enable-preview</arg>
+                            <arg>${enable-preview}</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
@@ -157,7 +190,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>
@@ -183,6 +216,8 @@
                            <exclude>**/jvm.config</exclude>
                            <exclude>**/.java-version</exclude>
                            <exclude>**/.travis.yml</exclude>
+                            <exclude>**/gradlew</exclude>
+                            <exclude>**/.github/**</exclude>
                        </excludes>
                        <strictCheck>true</strictCheck>
                    </configuration>
@@ -278,9 +313,21 @@
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>${maven-surefire-plugin-version}</version>
                    <configuration>
-                        <argLine>--enable-preview</argLine>
+                        <argLine>${enable-preview}</argLine>
                    </configuration>
                </plugin>
+
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <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>
            </plugins>
        </pluginManagement>

@@ -324,7 +371,6 @@
                <plugins>
                    <plugin>
                        <artifactId>maven-gpg-plugin</artifactId>
-                        <version>${maven-gpg-plugin-version}</version>
                        <configuration>
                            <passphrase>${gpg.passphrase}</passphrase>
                            <useAgent>true</useAgent>
@@ -342,5 +388,13 @@
                </plugins>
            </build>
        </profile>
+
+        <profile>
+            <id>java15</id>
+            <properties>
+                <jdk-version>15</jdk-version>
+                <enable-preview>--enable-preview</enable-preview>
+            </properties>
+        </profile>
    </profiles>
 </project>
--- a/record-builder-core/pom.xml
+++ b/record-builder-core/pom.xml
@@ -3,9 +3,29 @@
    <parent>
        <groupId>io.soabase.record-builder</groupId>
        <artifactId>record-builder</artifactId>
-        <version>1.10.ea</version>
+        <version>26</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>
--- a/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java
+++ b/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilder.java
@@ -15,12 +15,141 @@
 */
 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 {
+        Class<?>[] value();
+
+        /**
+         * 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 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 method that returns the record components as a stream
+         */
+        String componentsMethodName() default "stream";
+
+        /**
+         * 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 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;
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @Inherited
+    @interface Template {
+        RecordBuilder.Options options();
+    }
 }
--- a/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordBuilderMetaData.java
+++ b/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;
-    }
-}
--- a/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordInterface.java
+++ b/record-builder-core/src/main/java/io/soabase/recordbuilder/core/RecordInterface.java
@@ -16,12 +16,33 @@
 package io.soabase.recordbuilder.core;

 import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

@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 {
+        Class<?>[] value();
+
+        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 Include annotation. '*' is replaced with
+         * the package of the included class.
+         *
+         * @return package pattern
+         */
+        String packagePattern() default "@";
+    }
 }
--- a/record-builder-processor/pom.xml
+++ b/record-builder-processor/pom.xml
@@ -3,12 +3,16 @@
    <parent>
        <groupId>io.soabase.record-builder</groupId>
        <artifactId>record-builder</artifactId>
-        <version>1.10.ea</version>
+        <version>26</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>
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/CollectionBuilderUtils.java
+++ b/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/CollectionBuilderUtils.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.processor;
+
+import com.squareup.javapoet.*;
+
+import javax.lang.model.element.Modifier;
+import java.util.*;
+
+import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;
+
+class CollectionBuilderUtils {
+    private final boolean enabled;
+    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, boolean enabled) {
+        this.enabled = enabled;
+
+        listShimName = adjustShimName(recordComponents, "__list", 0);
+        mapShimName = adjustShimName(recordComponents, "__map", 0);
+        setShimName = adjustShimName(recordComponents, "__set", 0);
+        collectionShimName = adjustShimName(recordComponents, "__collection", 0);
+    }
+
+    void add(CodeBlock.Builder builder, RecordClassType component) {
+        if (enabled) {
+            if (component.rawTypeName().equals(listType)) {
+                needsListShim = true;
+                builder.add("$L($L)", listShimName, component.name());
+            } else if (component.rawTypeName().equals(mapType)) {
+                needsMapShim = true;
+                builder.add("$L($L)", mapShimName, component.name());
+            } else if (component.rawTypeName().equals(setType)) {
+                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 (!enabled) {
+            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 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 (o != null) ? $T.copyOf(o) : $T.of()", setType, 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();
+    }
+}
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/ElementUtils.java
+++ b/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/ElementUtils.java
@@ -19,15 +19,65 @@ 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> getClassesAttribute(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());
+    }
+
+    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 +87,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 +108,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 +122,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) {
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordBuilderProcessor.java
+++ b/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordBuilderProcessor.java
@@ -15,25 +15,14 @@
 */
 package io.soabase.recordbuilder.processor;

-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import com.squareup.javapoet.TypeVariableName;
-import io.soabase.recordbuilder.core.RecordBuilderMetaData;
+import com.squareup.javapoet.*;
+import io.soabase.recordbuilder.core.RecordBuilder;

-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-
-import java.util.AbstractMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.*;
+import java.util.*;
 import java.util.function.Consumer;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
@@ -42,33 +31,50 @@ import static io.soabase.recordbuilder.processor.ElementUtils.getBuilderName;
 import static io.soabase.recordbuilder.processor.ElementUtils.getWithMethodName;
 import static io.soabase.recordbuilder.processor.RecordBuilderProcessor.generatedRecordBuilderAnnotation;

-class InternalRecordBuilderProcessor
-{
-    private final RecordBuilderMetaData metaData;
+class InternalRecordBuilderProcessor {
+    private final RecordBuilder.Options metaData;
    private final ClassType recordClassType;
    private final String packageName;
    private final ClassType builderClassType;
    private final List<TypeVariableName> typeVariables;
-    private final List<ClassType> recordComponents;
+    private final List<RecordClassType> recordComponents;
    private final TypeSpec builderType;
    private final TypeSpec.Builder builder;
+    private final String uniqueVarName;
+    private final Pattern notNullPattern;
+    private final CollectionBuilderUtils collectionBuilderUtils;

-    InternalRecordBuilderProcessor(TypeElement record, RecordBuilderMetaData metaData)
-    {
-        this.metaData = metaData;
+    private static final TypeName overrideType = TypeName.get(Override.class);
+    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 final TypeName validatorTypeName = ClassName.get("io.soabase.recordbuilder.validator", "RecordBuilderValidator");
+    private final ProcessingEnvironment processingEnv;
+
+    InternalRecordBuilderProcessor(ProcessingEnvironment processingEnv, TypeElement record, RecordBuilder.Options metaData, Optional<String> packageNameOpt) {
+        this.processingEnv = processingEnv;
+        var recordActualPackage = ElementUtils.getPackageName(record);
+        this.metaData = getMetaData(record, metaData);
        recordClassType = ElementUtils.getClassType(record, record.getTypeParameters());
-        packageName = ElementUtils.getPackageName(record);
+        packageName = packageNameOpt.orElse(recordActualPackage);
        builderClassType = ElementUtils.getClassType(packageName, getBuilderName(record, metaData, recordClassType, metaData.suffix()), record.getTypeParameters());
        typeVariables = record.getTypeParameters().stream().map(TypeVariableName::get).collect(Collectors.toList());
-        recordComponents = record.getRecordComponents().stream().map(ElementUtils::getClassType).collect(Collectors.toList());
+        recordComponents = buildRecordComponents(record);
+        uniqueVarName = getUniqueVarName();
+        notNullPattern = Pattern.compile(metaData.interpretNotNullsPattern());
+        collectionBuilderUtils = new CollectionBuilderUtils(recordComponents, this.metaData.useImmutableCollections());

        builder = TypeSpec.classBuilder(builderClassType.name())
-                .addModifiers(Modifier.PUBLIC)
                .addAnnotation(generatedRecordBuilderAnnotation)
                .addTypeVariables(typeVariables);
+        addVisibility(recordActualPackage.equals(packageName), record.getModifiers());
        addWithNestedClass();
        addDefaultConstructor();
-        addAllArgsConstructor();
+        addStaticBuilder();
+        if (recordComponents.size() > 0) {
+            addAllArgsConstructor();
+        }
        addStaticDefaultBuilderMethod();
        addStaticCopyBuilderMethod();
        addStaticComponentsMethod();
@@ -81,26 +87,53 @@ class InternalRecordBuilderProcessor
            add1SetterMethod(component);
            add1GetterMethod(component);
        });
+        collectionBuilderUtils.addShims(builder);
        builderType = builder.build();
    }

-    String packageName()
-    {
+    String packageName() {
        return packageName;
    }

-    ClassType builderClassType()
-    {
+    ClassType builderClassType() {
        return builderClassType;
    }

-    TypeSpec builderType()
-    {
+    TypeSpec builderType() {
        return builderType;
    }

-    private void addWithNestedClass()
-    {
+    private void addVisibility(boolean builderIsInRecordPackage, Set<Modifier> modifiers) {
+        if (builderIsInRecordPackage) {
+            if (modifiers.contains(Modifier.PUBLIC) || modifiers.contains(Modifier.PRIVATE) || modifiers.contains(Modifier.PROTECTED)) {
+                builder.addModifiers(Modifier.PUBLIC);  // builders are top level classes - can only be public or package-private
+            }
+            // is package-private
+        }
+        else {
+            builder.addModifiers(Modifier.PUBLIC);
+        }
+    }
+
+    private List<RecordClassType> buildRecordComponents(TypeElement record) {
+        var accessorAnnotations = record.getRecordComponents().stream().map(e -> e.getAccessor().getAnnotationMirrors()).collect(Collectors.toList());
+        var canonicalConstructorAnnotations = ElementUtils.findCanonicalConstructor(record).map(constructor -> ((ExecutableElement) constructor).getParameters().stream().map(Element::getAnnotationMirrors).collect(Collectors.toList())).orElse(List.of());
+        var recordComponents = record.getRecordComponents();
+        return IntStream.range(0, recordComponents.size())
+                .mapToObj(index -> {
+                    var thisAccessorAnnotations = (accessorAnnotations.size() > index) ? accessorAnnotations.get(index) : List.<AnnotationMirror>of();
+                    var thisCanonicalConstructorAnnotations = (canonicalConstructorAnnotations.size() > index) ? canonicalConstructorAnnotations.get(index) : List.<AnnotationMirror>of();
+                    return ElementUtils.getRecordClassType(processingEnv, recordComponents.get(index), thisAccessorAnnotations, thisCanonicalConstructorAnnotations);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private RecordBuilder.Options getMetaData(TypeElement record, RecordBuilder.Options metaData) {
+        var recordSpecificMetaData = record.getAnnotation(RecordBuilder.Options.class);
+        return (recordSpecificMetaData != null) ? recordSpecificMetaData : metaData;
+    }
+
+    private void addWithNestedClass() {
        /*
            Adds a nested interface that adds withers similar to:

@@ -115,27 +148,25 @@ class InternalRecordBuilderProcessor
                .addJavadoc("Add withers to {@code $L}\n", recordClassType.name())
                .addModifiers(Modifier.PUBLIC)
                .addTypeVariables(typeVariables);
+        recordComponents.forEach(component -> addWithGetterMethod(classBuilder, component));
        addWithBuilderMethod(classBuilder);
        addWithSuppliedBuilderMethod(classBuilder);
        IntStream.range(0, recordComponents.size()).forEach(index -> add1WithMethod(classBuilder, recordComponents.get(index), index));
        builder.addType(classBuilder.build());
    }

-    private void addWithSuppliedBuilderMethod(TypeSpec.Builder classBuilder)
-    {
+    private void addWithSuppliedBuilderMethod(TypeSpec.Builder classBuilder) {
        /*
            Adds a method that returns a pre-filled copy builder similar to:

            default MyRecord with(Consumer<MyRecordBuilder> consumer) {
-                MyRecord r = (MyRecord)(Object)this;
-                MyRecordBuilder builder MyRecordBuilder.builder(r);
+                MyRecordBuilder builder = with();
                consumer.accept(builder);
                return builder.build();
            }
         */
        var codeBlockBuilder = CodeBlock.builder()
-                .add("var r = ($T)(Object)this;\n", recordClassType.typeName())
-                .add("$T builder = $L.$L(r);\n", builderClassType.typeName(), builderClassType.name(), metaData.copyMethodName())
+                .add("$T builder = with();\n", builderClassType.typeName())
                .add("consumer.accept(builder);\n")
                .add("return builder.build();\n");
        var consumerType = ParameterizedTypeName.get(ClassName.get(Consumer.class), builderClassType.typeName());
@@ -151,19 +182,18 @@ class InternalRecordBuilderProcessor
        classBuilder.addMethod(methodSpec);
    }

-    private void addWithBuilderMethod(TypeSpec.Builder classBuilder)
-    {
+    private void addWithBuilderMethod(TypeSpec.Builder classBuilder) {
        /*
            Adds a method that returns a pre-filled copy builder similar to:

            default MyRecordBuilder with() {
-                MyRecord r = (MyRecord)(Object)this;
                return MyRecordBuilder.builder(r);
            }
         */
        var codeBlockBuilder = CodeBlock.builder()
-                .add("var r = ($T)(Object)this;\n", recordClassType.typeName())
-                .add("return $L.$L(r);", builderClassType.name(), metaData.copyMethodName());
+                .add("return new $L(", builderClassType.name());
+        addComponentCallsAsArguments(-1, codeBlockBuilder);
+        codeBlockBuilder.add(");");
        var methodSpec = MethodSpec.methodBuilder(metaData.withClassMethodPrefix())
                .addAnnotation(generatedRecordBuilderAnnotation)
                .addJavadoc("Return a new record builder using the current values")
@@ -174,48 +204,69 @@ class InternalRecordBuilderProcessor
        classBuilder.addMethod(methodSpec);
    }

-    private void add1WithMethod(TypeSpec.Builder classBuilder, ClassType component, int index)
-    {
+    private String getUniqueVarName() {
+        return getUniqueVarName("");
+    }
+
+    private String getUniqueVarName(String prefix) {
+        var name = prefix + "r";
+        var alreadyExists = recordComponents.stream()
+                .map(ClassType::name)
+                .anyMatch(n -> n.equals(name));
+        return alreadyExists ? getUniqueVarName(prefix + "_") : name;
+    }
+
+    private void add1WithMethod(TypeSpec.Builder classBuilder, RecordClassType component, int index) {
        /*
            Adds a with method for the component similar to:

            default MyRecord withName(String name) {
-                MyRecord r = (MyRecord)(Object)this;
                return new MyRecord(name, r.age());
            }
         */
-        var codeBlockBuilder = CodeBlock.builder()
-                .add("var r = ($T)(Object)this;\n", recordClassType.typeName())
-                .add("return new $T(", recordClassType.typeName());
-        IntStream.range(0, recordComponents.size()).forEach(parameterIndex -> {
-            if (parameterIndex > 0) {
-                codeBlockBuilder.add(", ");
-            }
-            ClassType parameterComponent = recordComponents.get(parameterIndex);
-            if (parameterIndex == index) {
-                codeBlockBuilder.add(parameterComponent.name());
-            }
-            else {
-                codeBlockBuilder.add("r.$L()", parameterComponent.name());
-            }
-        });
-        codeBlockBuilder.add(");");
+        var codeBlockBuilder = CodeBlock.builder();
+        addNullCheckCodeBlock(codeBlockBuilder, index);
+        codeBlockBuilder.add("$[return ");
+        if (metaData.useValidationApi()) {
+            codeBlockBuilder.add("$T.validate(", validatorTypeName);
+        }
+        codeBlockBuilder.add("new $T(", recordClassType.typeName());
+        addComponentCallsAsArguments(index, codeBlockBuilder);
+        codeBlockBuilder.add(")");
+        if (metaData.useValidationApi()) {
+            codeBlockBuilder.add(")");
+        }
+        codeBlockBuilder.add(";$]");

        var methodName = getWithMethodName(component, metaData.withClassMethodPrefix());
-        var parameterSpec = ParameterSpec.builder(component.typeName(), component.name()).build();
+        var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+        addConstructorAnnotations(component, parameterSpecBuilder);
        var methodSpec = MethodSpec.methodBuilder(methodName)
                .addAnnotation(generatedRecordBuilderAnnotation)
                .addJavadoc("Return a new instance of {@code $L} with a new value for {@code $L}\n", recordClassType.name(), component.name())
                .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
-                .addParameter(parameterSpec)
+                .addParameter(parameterSpecBuilder.build())
                .addCode(codeBlockBuilder.build())
                .returns(recordClassType.typeName())
                .build();
        classBuilder.addMethod(methodSpec);
    }

-    private void addDefaultConstructor()
-    {
+    private void addComponentCallsAsArguments(int index, CodeBlock.Builder codeBlockBuilder) {
+        IntStream.range(0, recordComponents.size()).forEach(parameterIndex -> {
+            if (parameterIndex > 0) {
+                codeBlockBuilder.add(", ");
+            }
+            RecordClassType parameterComponent = recordComponents.get(parameterIndex);
+            if (parameterIndex == index) {
+                collectionBuilderUtils.add(codeBlockBuilder, parameterComponent);
+            } else {
+                codeBlockBuilder.add("$L()", parameterComponent.name());
+            }
+        });
+    }
+
+    private void addDefaultConstructor() {
        /*
            Adds a default constructor similar to:

@@ -229,8 +280,53 @@ class InternalRecordBuilderProcessor
        builder.addMethod(constructor);
    }

-    private void addAllArgsConstructor()
-    {
+    private void addStaticBuilder() {
+        /*
+            Adds an static builder similar to:
+
+            public static MyRecord(int p1, T p2, ...) {
+                return new MyRecord(p1, p2, ...);
+            }
+         */
+        CodeBlock codeBlock = buildCodeBlock();
+        var builder = MethodSpec.methodBuilder(recordClassType.name())
+                .addJavadoc("Static constructor/builder. Can be used instead of new $L(...)\n", recordClassType.name())
+                .addTypeVariables(typeVariables)
+                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(recordClassType.typeName())
+                .addCode(codeBlock);
+        recordComponents.forEach(component -> {
+            var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+            addConstructorAnnotations(component, parameterSpecBuilder);
+            builder.addParameter(parameterSpecBuilder.build());
+        });
+        this.builder.addMethod(builder.build());
+    }
+
+    private void addNullCheckCodeBlock(CodeBlock.Builder builder) {
+        if (metaData.interpretNotNulls()) {
+            for (int i = 0; i < recordComponents.size(); ++i) {
+                addNullCheckCodeBlock(builder, i);
+            }
+        }
+    }
+
+    private void addNullCheckCodeBlock(CodeBlock.Builder builder, int index) {
+        if (metaData.interpretNotNulls()) {
+            var component = recordComponents.get(index);
+            if (!component.typeName().isPrimitive() && isNullAnnotated(component)) {
+                builder.addStatement("$T.requireNonNull($L, $S)", Objects.class, component.name(), component.name() + " is required");
+            }
+        }
+    }
+
+    private boolean isNullAnnotated(RecordClassType component) {
+        return component.getCanonicalConstructorAnnotations().stream()
+                .anyMatch(annotation -> notNullPattern.matcher(annotation.getAnnotationType().asElement().getSimpleName().toString()).matches());
+    }
+
+    private void addAllArgsConstructor() {
        /*
            Adds an all-args constructor similar to:

@@ -251,8 +347,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(constructorBuilder.build());
    }

-    private void addToStringMethod()
-    {
+    private void addToStringMethod() {
        /*
            add a toString() method similar to:

@@ -281,8 +376,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void addHashCodeMethod()
-    {
+    private void addHashCodeMethod() {
        /*
            add a hashCode() method similar to:

@@ -310,8 +404,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void addEqualsMethod()
-    {
+    private void addEqualsMethod() {
        /*
            add an equals() method similar to:

@@ -324,14 +417,13 @@ class InternalRecordBuilderProcessor
         */
        var codeBuilder = CodeBlock.builder();
        codeBuilder.add("return (this == o) || (");
-        codeBuilder.add("(o instanceof $L b)", builderClassType.name());
+        codeBuilder.add("(o instanceof $L $L)", builderClassType.name(), uniqueVarName);
        recordComponents.forEach(recordComponent -> {
            String name = recordComponent.name();
            if (recordComponent.typeName().isPrimitive()) {
-                codeBuilder.add("\n&& ($L == b.$L)", name, name);
-            }
-            else {
-                codeBuilder.add("\n&& $T.equals($L, b.$L)", Objects.class, name, name);
+                codeBuilder.add("\n&& ($L == $L.$L)", name, uniqueVarName, name);
+            } else {
+                codeBuilder.add("\n&& $T.equals($L, $L.$L)", Objects.class, name, uniqueVarName, name);
            }
        });
        codeBuilder.add(")");
@@ -347,8 +439,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void addBuildMethod()
-    {
+    private void addBuildMethod() {
        /*
            Adds the build method that generates the record similar to:

@@ -356,27 +447,44 @@ class InternalRecordBuilderProcessor
                return new MyRecord(p1, p2, ...);
            }
         */
-        var codeBuilder = CodeBlock.builder().add("return new $T(", recordClassType.typeName());
-        IntStream.range(0, recordComponents.size()).forEach(index -> {
-            if (index > 0) {
-                codeBuilder.add(", ");
-            }
-            codeBuilder.add("$L", recordComponents.get(index).name());
-        });
-        codeBuilder.add(")");
-
+        CodeBlock codeBlock = buildCodeBlock();
        var methodSpec = MethodSpec.methodBuilder(metaData.buildMethodName())
                .addJavadoc("Return a new record instance with all fields set to the current values in this builder\n")
                .addModifiers(Modifier.PUBLIC)
                .addAnnotation(generatedRecordBuilderAnnotation)
                .returns(recordClassType.typeName())
-                .addStatement(codeBuilder.build())
+                .addCode(codeBlock)
                .build();
        builder.addMethod(methodSpec);
    }

-    private void addStaticCopyBuilderMethod()
-    {
+    private CodeBlock buildCodeBlock() {
+        /*
+            Builds the code block for allocating the record from its parts
+        */
+
+        var codeBuilder = CodeBlock.builder();
+        addNullCheckCodeBlock(codeBuilder);
+        codeBuilder.add("$[return ");
+        if (metaData.useValidationApi()) {
+            codeBuilder.add("$T.validate(", validatorTypeName);
+        }
+        codeBuilder.add("new $T(", recordClassType.typeName());
+        IntStream.range(0, recordComponents.size()).forEach(index -> {
+            if (index > 0) {
+                codeBuilder.add(", ");
+            }
+            collectionBuilderUtils.add(codeBuilder, recordComponents.get(index));
+        });
+        codeBuilder.add(")");
+        if (metaData.useValidationApi()) {
+            codeBuilder.add(")");
+        }
+        codeBuilder.add(";$]");
+        return codeBuilder.build();
+    }
+
+    private void addStaticCopyBuilderMethod() {
        /*
            Adds a copy builder method that pre-fills the builder with existing values similar to:

@@ -405,8 +513,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void addStaticDefaultBuilderMethod()
-    {
+    private void addStaticDefaultBuilderMethod() {
        /*
            Adds a the default builder method similar to:

@@ -425,8 +532,7 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void addStaticComponentsMethod()
-    {
+    private void addStaticComponentsMethod() {
        /*
            Adds a static method that converts a record instance into a stream of its component parts

@@ -460,19 +566,79 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }

-    private void add1Field(ClassType component)
-    {
+    private void add1Field(ClassType component) {
        /*
            For a single record component, add a field similar to:

            private T p;
         */
-        var fieldSpec = FieldSpec.builder(component.typeName(), component.name(), Modifier.PRIVATE).build();
-        builder.addField(fieldSpec);
+        var fieldSpecBuilder = FieldSpec.builder(component.typeName(), component.name(), Modifier.PRIVATE);
+        if (metaData.emptyDefaultForOptional()) {
+            TypeName thisOptionalType = null;
+            if (isOptional(component)) {
+                thisOptionalType = optionalType;
+            } else if (component.typeName().equals(optionalIntType)) {
+                thisOptionalType = optionalIntType;
+            } else if (component.typeName().equals(optionalLongType)) {
+                thisOptionalType = optionalLongType;
+            } else if (component.typeName().equals(optionalDoubleType)) {
+                thisOptionalType = optionalDoubleType;
+            }
+            if (thisOptionalType != null) {
+                var codeBlock = CodeBlock.builder().add("$T.empty()", thisOptionalType).build();
+                fieldSpecBuilder.initializer(codeBlock);
+            }
+        }
+        builder.addField(fieldSpecBuilder.build());
    }

-    private void add1GetterMethod(ClassType component)
-    {
+    private boolean isOptional(ClassType component) {
+        if (component.typeName().equals(optionalType)) {
+            return true;
+        }
+        return (component.typeName() instanceof ParameterizedTypeName parameterizedTypeName) && parameterizedTypeName.rawType.equals(optionalType);
+    }
+
+    private void addWithGetterMethod(TypeSpec.Builder classBuilder, RecordClassType component) {
+        /*
+            For a single record component, add a getter similar to:
+
+            T p();
+         */
+        var methodSpecBuilder = MethodSpec.methodBuilder(component.name())
+                .addJavadoc("Return the current value for the {@code $L} record component in the builder\n", component.name())
+                .addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC)
+                .addAnnotation(generatedRecordBuilderAnnotation)
+                .returns(component.typeName());
+        addAccessorAnnotations(component, methodSpecBuilder);
+        classBuilder.addMethod(methodSpecBuilder.build());
+    }
+
+    private boolean filterOutOverride(AnnotationSpec annotationSpec) {
+        return !annotationSpec.type.equals(overrideType);
+    }
+
+    private void addConstructorAnnotations(RecordClassType component, ParameterSpec.Builder parameterSpecBuilder) {
+        if (metaData.inheritComponentAnnotations()) {
+            component.getCanonicalConstructorAnnotations()
+                    .stream()
+                    .map(AnnotationSpec::get)
+                    .filter(this::filterOutOverride)
+                    .forEach(parameterSpecBuilder::addAnnotation);
+        }
+    }
+
+    private void addAccessorAnnotations(RecordClassType component, MethodSpec.Builder methodSpecBuilder) {
+        if (metaData.inheritComponentAnnotations()) {
+            component.getAccessorAnnotations()
+                    .stream()
+                    .map(AnnotationSpec::get)
+                    .filter(this::filterOutOverride)
+                    .forEach(methodSpecBuilder::addAnnotation);
+        }
+    }
+
+    private void add1GetterMethod(RecordClassType component) {
        /*
            For a single record component, add a getter similar to:

@@ -480,18 +646,17 @@ class InternalRecordBuilderProcessor
                return p;
            }
         */
-        var methodSpec = MethodSpec.methodBuilder(component.name())
+        var methodSpecBuilder = MethodSpec.methodBuilder(component.name())
                .addJavadoc("Return the current value for the {@code $L} record component in the builder\n", component.name())
                .addModifiers(Modifier.PUBLIC)
                .addAnnotation(generatedRecordBuilderAnnotation)
                .returns(component.typeName())
-                .addStatement("return $L", component.name())
-                .build();
-        builder.addMethod(methodSpec);
+                .addStatement("return $L", component.name());
+        addAccessorAnnotations(component, methodSpecBuilder);
+        builder.addMethod(methodSpecBuilder.build());
    }

-    private void add1SetterMethod(ClassType component)
-    {
+    private void add1SetterMethod(RecordClassType component) {
        /*
            For a single record component, add a setter similar to:

@@ -500,12 +665,14 @@ class InternalRecordBuilderProcessor
                return this;
            }
         */
-        var parameterSpec = ParameterSpec.builder(component.typeName(), component.name()).build();
+        var parameterSpecBuilder = ParameterSpec.builder(component.typeName(), component.name());
+        addConstructorAnnotations(component, parameterSpecBuilder);
+
        var methodSpec = MethodSpec.methodBuilder(component.name())
                .addJavadoc("Set a new value for the {@code $L} record component in the builder\n", component.name())
                .addModifiers(Modifier.PUBLIC)
                .addAnnotation(generatedRecordBuilderAnnotation)
-                .addParameter(parameterSpec)
+                .addParameter(parameterSpecBuilder.build())
                .returns(builderClassType.typeName())
                .addStatement("this.$L = $L", component.name(), component.name())
                .addStatement("return this")
@@ -513,3 +680,4 @@ class InternalRecordBuilderProcessor
        builder.addMethod(methodSpec);
    }
 }
+
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordInterfaceProcessor.java
+++ b/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/InternalRecordInterfaceProcessor.java
@@ -15,12 +15,13 @@
 */
 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 com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
 import io.soabase.recordbuilder.core.IgnoreDefaultMethod;
-
+import io.soabase.recordbuilder.core.RecordBuilder;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.ExecutableElement;
@@ -28,7 +29,13 @@ import javax.lang.model.element.Modifier;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.TypeKind;
 import javax.tools.Diagnostic;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -40,15 +47,20 @@ 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) {
        this.processingEnv = processingEnv;
-        packageName = ElementUtils.getPackageName(iface);
+        packageName = packageNameOpt.orElseGet(() -> ElementUtils.getPackageName(iface));
        recordComponents = getRecordComponents(iface);
        this.iface = iface;

@@ -65,12 +77,14 @@ class InternalRecordInterfaceProcessor {
                .addAnnotation(generatedRecordInterfaceAnnotation)
                .addTypeVariables(typeVariables);

-        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());
        }

+        alternateMethods = buildAlternateMethods(recordComponents);
+
        recordType = builder.build();
    }

@@ -118,22 +132,43 @@ 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()
    {
        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()) {
@@ -145,15 +180,15 @@ class InternalRecordInterfaceProcessor {
        }
        return components;
    }
-
    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 +211,22 @@ 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);
+            });
+    }
 }
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/OptionBasedRecordBuilderMetaData.java
+++ b/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;
-    }
-}
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderMetaDataLoader.java
+++ b/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;
-    }
-}
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderOptions.java
+++ b/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() {
+    }
+}
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderProcessor.java
+++ b/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordBuilderProcessor.java
@@ -18,41 +18,54 @@ 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.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.lang.model.type.TypeMirror;
 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();

    @Override
-    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
-        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation)
-                .forEach(element -> process(annotation, element))
-        );
-        return true;
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv)
+    {
+        annotations.forEach(annotation -> roundEnv.getElementsAnnotatedWith(annotation).forEach(element -> process(annotation, element)));
+        return false;
    }
-    
+
    @Override
-    public SourceVersion getSupportedSourceVersion() {
+    public Set<String> getSupportedAnnotationTypes()
+    {
+        return Set.of("*");
+    }
+
+    @Override
+    public SourceVersion getSupportedSourceVersion()
+    {
        // we don't directly return RELEASE_14 as that may 
        // not exist in prior releases
        // if we're running on an older release, returning latest()
@@ -60,31 +73,106 @@ public class RecordBuilderProcessor extends AbstractProcessor {
        return SourceVersion.latest();
    }

-    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);
+    private void process(TypeElement annotation, Element element)
+    {
+        String annotationClass = annotation.getQualifiedName().toString();
+        if (annotationClass.equals(RECORD_BUILDER)) {
+            var metaData = RecordBuilderOptions.build(processingEnv.getOptions());
+            processRecordBuilder((TypeElement) element, metaData, Optional.empty());
+        }
+        else if (annotationClass.equals(RECORD_INTERFACE)) {
+            var metaData = RecordBuilderOptions.build(processingEnv.getOptions());
+            processRecordInterface((TypeElement) element, element.getAnnotation(RecordInterface.class).addRecordBuilder(), metaData, Optional.empty());
+        }
+        else if (annotationClass.equals(RECORD_BUILDER_INCLUDE) || annotationClass.equals(RECORD_INTERFACE_INCLUDE)) {
+            var metaData = RecordBuilderOptions.build(processingEnv.getOptions());
+            processIncludes(element, metaData, annotationClass);
        } else {
-            throw new RuntimeException("Unknown annotation: " + annotation);
+            var recordBuilderTemplate = annotation.getAnnotation(RecordBuilder.Template.class);
+            if (recordBuilderTemplate != null) {
+                processRecordBuilder((TypeElement) element, recordBuilderTemplate.options(), Optional.empty());
+            }
        }
    }

-    private void processRecordInterface(TypeElement element, RecordInterface recordInterface, RecordBuilderMetaData metaData) {
+    private void processIncludes(Element element, RecordBuilder.Options metaData, String annotationClass)
+    {
+        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 values = processingEnv.getElementUtils().getElementValuesWithDefaults(annotationMirrorOpt.get());
+            var classes = ElementUtils.getAnnotationValue(values, "value");
+            if (classes.isEmpty()) {
+                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get annotation value for: " + annotationClass, element);
+            }
+            else {
+                var packagePattern = ElementUtils.getStringAttribute(ElementUtils.getAnnotationValue(values, "packagePattern").orElse(null), "*");
+                var classesMirrors = ElementUtils.getClassesAttribute(classes.get());
+                for (TypeMirror mirror : classesMirrors) {
+                    TypeElement typeElement = (TypeElement) processingEnv.getTypeUtils().asElement(mirror);
+                    if (typeElement == null) {
+                        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Could not get element for: " + mirror, element);
+                    }
+                    else {
+                        var packageName = buildPackageName(packagePattern, element, typeElement);
+                        if (packageName != null) {
+                            if (annotationClass.equals(RECORD_INTERFACE_INCLUDE)) {
+                                var addRecordBuilderOpt = ElementUtils.getAnnotationValue(values, "addRecordBuilder");
+                                var addRecordBuilder = addRecordBuilderOpt.map(ElementUtils::getBooleanAttribute).orElse(true);
+                                processRecordInterface(typeElement, addRecordBuilder, metaData, Optional.of(packageName));
+                            }
+                            else {
+                                processRecordBuilder(typeElement, metaData, Optional.of(packageName));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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)
+    {
        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);
        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 +181,29 @@ 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 +211,21 @@ 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);
@@ -150,7 +233,8 @@ public class RecordBuilderProcessor extends AbstractProcessor {
        return javaFileBuilder.build();
    }

-    private void handleWriteError(TypeElement element, IOException e) {
+    private void handleWriteError(TypeElement element, IOException e)
+    {
        String message = "Could not create source file";
        if (e.getMessage() != null) {
            message = message + ": " + e.getMessage();
--- a/record-builder-processor/src/main/java/io/soabase/recordbuilder/processor/RecordClassType.java
+++ b/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;
+    }
+}
--- a/record-builder-test/pom.xml
+++ b/record-builder-test/pom.xml
@@ -3,16 +3,43 @@
    <parent>
        <groupId>io.soabase.record-builder</groupId>
        <artifactId>record-builder</artifactId>
-        <version>1.10.ea</version>
+        <version>26</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>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.soabase.record-builder</groupId>
+            <artifactId>record-builder-validator</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>
@@ -42,6 +69,10 @@
                    <annotationProcessors>
                        <annotationProcessor>io.soabase.recordbuilder.processor.RecordBuilderProcessor</annotationProcessor>
                    </annotationProcessors>
+                    <release>${jdk-version}</release>
+                    <compilerArgs>
+                        <arg>${enable-preview}</arg>
+                    </compilerArgs>
                </configuration>
            </plugin>

--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Annotated.java
+++ b/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) {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/BeanStyle.java
+++ b/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();
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Builder.java
+++ b/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 {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecord.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecord.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 CollectionRecord<T, X extends Point>(List<T> l, Set<T> s, Map<T, X> m, Collection<X> c) implements CollectionRecordBuilder.With<T, X> {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/CollectionRecordConflicts.java
+++ b/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 {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Customer.java
+++ b/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();
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Empty.java
+++ b/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 {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/ExceptionDetails.java
+++ b/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;
+    }
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/IgnoreAnnotated.java
+++ b/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) {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/MutableCollectionRecord.java
+++ b/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 {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/MyTemplate.java
+++ b/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
+{
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Nested.java
+++ b/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){}
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Pair.java
+++ b/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) {}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Point.java
+++ b/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) {}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithAnR.java
+++ b/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) {}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RecordWithOptional.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.test;
+
+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)
+@RecordBuilder
+public record RecordWithOptional(Optional<String> value, Optional raw, OptionalInt i, OptionalLong l, OptionalDouble d) {}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord.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(interpretNotNulls = true)
+@RecordBuilder
+public record RequiredRecord(@NotNull String hey, @NotNull int i) implements RequiredRecordBuilder.With {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/RequiredRecord2.java
+++ b/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 {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/SimpleRecord.java
+++ b/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) {
 }
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/TemplateTest.java
+++ b/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
+{
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Thingy.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/Thingy.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 interface Thingy<T> {
+    T getIt();
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/package-info.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/package-info.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.
+ */
+
+@RecordBuilder.Include(value = {Point.class, Pair.class}, packagePattern = "*.foo")
+@RecordInterface.Include(value = Customer.class, addRecordBuilder = false, packagePattern = "*.bar")
+package io.soabase.recordbuilder.test;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+import io.soabase.recordbuilder.core.RecordInterface;
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/visibility/PackagePrivateRecord.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/visibility/PackagePrivateRecord.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.visibility;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+@RecordBuilder
+record PackagePrivateRecord(int i) {
+}
--- a/record-builder-test/src/main/java/io/soabase/recordbuilder/test/visibility/Wrapper.java
+++ b/record-builder-test/src/main/java/io/soabase/recordbuilder/test/visibility/Wrapper.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.visibility;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+class Wrapper {
+    @RecordBuilder
+    protected record ProtectedRecord(int i) {
+    }
+
+    @RecordBuilder
+    record PackagePrivateRecord(int i) {
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestAnnotated.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestAnnotated.java
@@ -0,0 +1,107 @@
+/**
+ * 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 org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Null;
+import java.lang.reflect.AnnotatedElement;
+
+class TestAnnotated {
+    @Test
+    void testInheritComponentAnnotationsFalse() throws NoSuchMethodException {
+        var method = IgnoreAnnotatedBuilder.class.getMethod("s");
+        Assertions.assertNull(method.getAnnotation(NotNull.class));
+    }
+
+    @Test
+    void testStaticConstructor() throws NoSuchMethodException {
+        var method = AnnotatedBuilder.class.getMethod("Annotated", String.class, Integer.TYPE, Double.TYPE);
+        var parameters = method.getParameters();
+        Assertions.assertEquals(3, parameters.length);
+        assertHey(parameters[0]);
+        assertI(parameters[1]);
+        assertD(parameters[2]);
+    }
+
+    @Test
+    void testSetters() throws NoSuchMethodException {
+        var method = AnnotatedBuilder.class.getMethod("hey", String.class);
+        var parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertHey(parameters[0]);
+
+        method = AnnotatedBuilder.class.getMethod("i", Integer.TYPE);
+        parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertI(parameters[0]);
+
+        method = AnnotatedBuilder.class.getMethod("d", Double.TYPE);
+        parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertD(parameters[0]);
+    }
+
+    @Test
+    void testGetters() throws NoSuchMethodException {
+        var method = AnnotatedBuilder.class.getMethod("hey");
+        assertHey(method);
+
+        method = AnnotatedBuilder.class.getMethod("i");
+        assertI(method);
+
+        method = AnnotatedBuilder.class.getMethod("d");
+        assertD(method);
+    }
+
+    @Test
+    void testWitherSetters() throws NoSuchMethodException {
+        var method = AnnotatedBuilder.With.class.getMethod("withHey", String.class);
+        var parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertHey(parameters[0]);
+
+        method = AnnotatedBuilder.With.class.getMethod("withI", Integer.TYPE);
+        parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertI(parameters[0]);
+
+        method = AnnotatedBuilder.With.class.getMethod("withD", Double.TYPE);
+        parameters = method.getParameters();
+        Assertions.assertEquals(1, parameters.length);
+        assertD(parameters[0]);
+    }
+
+    private void assertD(AnnotatedElement d) {
+        Assertions.assertEquals(0, d.getAnnotations().length);
+    }
+
+    private void assertI(AnnotatedElement i) {
+        Assertions.assertNotNull(i.getAnnotation(Min.class));
+        Assertions.assertEquals(i.getAnnotation(Min.class).value(), 10);
+        Assertions.assertNotNull(i.getAnnotation(Max.class));
+        Assertions.assertEquals(i.getAnnotation(Max.class).value(), 100);
+    }
+
+    private void assertHey(AnnotatedElement hey) {
+        Assertions.assertNotNull(hey.getAnnotation(NotNull.class));
+        Assertions.assertNotNull(hey.getAnnotation(Null.class));
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestCollections.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestCollections.java
@@ -0,0 +1,125 @@
+/**
+ * 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 org.junit.jupiter.api.Test;
+
+import java.util.*;
+
+import static io.soabase.recordbuilder.test.foo.PointBuilder.Point;
+import static org.junit.jupiter.api.Assertions.*;
+
+class TestCollections {
+    @Test
+    void testCollectionRecordDefaultValues() {
+        var defaultValues = CollectionRecordBuilder.builder().build();
+        assertNotNull(defaultValues.l());
+        assertNotNull(defaultValues.s());
+        assertNotNull(defaultValues.m());
+        assertNotNull(defaultValues.c());
+    }
+
+    @Test
+    void testCollectionRecordImmutable() {
+        var list = new ArrayList<String>();
+        list.add("one");
+        var set = new HashSet<String>();
+        set.add("one");
+        var map = new HashMap<String, Point>();
+        map.put("one", Point(10, 20));
+        var collectionAsSet = new HashSet<Point>();
+        collectionAsSet.add(Point(30, 40));
+        var r = CollectionRecordBuilder.<String, Point>builder()
+                .l(list)
+                .s(set)
+                .m(map)
+                .c(collectionAsSet)
+                .build();
+
+        assertValues(r, list, set, map, collectionAsSet);
+        assertValueChanges(r, list, set, map, collectionAsSet);
+        assertImmutable(r);
+
+        var collectionAsList = new ArrayList<Point>();
+        var x = CollectionRecordBuilder.<String, Point>builder()
+                .l(list)
+                .s(set)
+                .m(map)
+                .c(collectionAsList)
+                .build();
+        assertTrue(x.c() instanceof List);
+    }
+
+    @Test
+    void testCollectionRecordImmutableWithers() {
+        var r = CollectionRecordBuilder.<String, Point>builder().build();
+
+        var list = new ArrayList<String>();
+        list.add("one");
+        var set = new HashSet<String>();
+        set.add("one");
+        var map = new HashMap<String, Point>();
+        map.put("one", Point(10, 20));
+        var collectionAsSet = new HashSet<Point>();
+        collectionAsSet.add(Point(30, 40));
+        var x = r.withL(list).withS(set).withM(map).withC(collectionAsSet);
+
+        assertValues(x, list, set, map, collectionAsSet);
+        assertValueChanges(x, list, set, map, collectionAsSet);
+        assertImmutable(x);
+    }
+
+    @Test
+    public void testMutableCollectionRecord() {
+        var r = MutableCollectionRecordBuilder.builder().build();
+        assertNull(r.l());
+
+        var list = new ArrayList<String>();
+        list.add("one");
+        r = MutableCollectionRecordBuilder.builder().l(list).build();
+
+        assertEquals(r.l(), list);
+        list.add("two");
+        assertEquals(r.l(), list);
+    }
+
+    private void assertImmutable(CollectionRecord<String, Point> r) {
+        assertThrows(UnsupportedOperationException.class, () -> r.l().add("hey"));
+        assertThrows(UnsupportedOperationException.class, () -> r.s().add("hey"));
+        assertThrows(UnsupportedOperationException.class, () -> r.m().put("hey", Point(1, 2)));
+        assertThrows(UnsupportedOperationException.class, () -> r.c().add(Point(1, 2)));
+    }
+
+    private void assertValueChanges(CollectionRecord<String, Point> r, ArrayList<String> list, HashSet<String> set, HashMap<String, Point> map, HashSet<Point> collectionAsSet) {
+        list.add("two");
+        set.add("two");
+        map.put("two", Point(50, 60));
+        collectionAsSet.add(Point(70, 80));
+
+        assertNotEquals(r.l(), list);
+        assertNotEquals(r.s(), set);
+        assertNotEquals(r.m(), map);
+        assertNotEquals(r.c(), collectionAsSet);
+    }
+
+    private void assertValues(CollectionRecord<String, Point> r, ArrayList<String> list, HashSet<String> set, HashMap<String, Point> map, HashSet<Point> collectionAsSet) {
+        assertEquals(r.l(), list);
+        assertEquals(r.s(), set);
+        assertEquals(r.m(), map);
+        assertEquals(r.c(), collectionAsSet);
+        assertTrue(r.c() instanceof Set);
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestOptional.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestOptional.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 org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+class TestOptional {
+    @Test
+    void testDefaultEmpty() {
+        var record = RecordWithOptionalBuilder.builder();
+        Assertions.assertEquals(Optional.empty(), record.value());
+        Assertions.assertEquals(Optional.empty(), record.raw());
+        Assertions.assertEquals(OptionalInt.empty(), record.i());
+        Assertions.assertEquals(OptionalLong.empty(), record.l());
+        Assertions.assertEquals(OptionalDouble.empty(), record.d());
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestRecordInterface.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestRecordInterface.java
@@ -20,6 +20,9 @@ import org.junit.jupiter.api.Test;

 import java.time.Instant;

+import static io.soabase.recordbuilder.test.SimpleGenericRecordBuilder.SimpleGenericRecord;
+import static io.soabase.recordbuilder.test.SimpleRecordBuilder.SimpleRecord;
+
 public class TestRecordInterface
 {
    @Test
@@ -32,4 +35,17 @@ public class TestRecordInterface
        Assertions.assertEquals(Instant.MIN, r2.time());
        Assertions.assertEquals(Instant.MIN, r2.tomorrow());
    }
+
+    @Test
+    public void testStaticConstructor()
+    {
+        var simple = SimpleRecord(10,"hey");
+        Assertions.assertEquals(simple.i(), 10);
+        Assertions.assertEquals(simple.s(), "hey");
+
+        var now = Instant.now();
+        var generic = SimpleGenericRecord(101, now);
+        Assertions.assertEquals(generic.i(), 101);
+        Assertions.assertEquals(generic.s(), now);
+    }
 }
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestTemplate.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestTemplate.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.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.time.Instant;
+
+class TestTemplate {
+    @Test
+    void testTemplate() {
+        var t = TemplateTestBuilder.TemplateTest("one", Instant.MIN);
+        var w = t.withText("other");
+        Assertions.assertEquals("one", t.text());
+        Assertions.assertEquals("other", w.text());
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestValidation.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/TestValidation.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.test;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import javax.validation.ValidationException;
+
+class TestValidation {
+    @Test
+    void testNotNulls() {
+        Assertions.assertThrows(NullPointerException.class, () -> RequiredRecordBuilder.builder().build());
+    }
+
+    @Test
+    void testValidation() {
+        Assertions.assertThrows(ValidationException.class, () -> RequiredRecord2Builder.builder().build());
+    }
+
+    @Test
+    void testNotNullsWithNewProperty() {
+        var valid = RequiredRecordBuilder.builder().hey("hey").i(1).build();
+        Assertions.assertThrows(NullPointerException.class, () -> valid.withHey(null));
+    }
+
+    @Test
+    void testValidationWithNewProperty() {
+        var valid = RequiredRecord2Builder.builder().hey("hey").i(1).build();
+        Assertions.assertThrows(ValidationException.class, () -> valid.withHey(null));
+    }
+}
--- a/record-builder-test/src/test/java/io/soabase/recordbuilder/test/visibility/TestVisibility.java
+++ b/record-builder-test/src/test/java/io/soabase/recordbuilder/test/visibility/TestVisibility.java
@@ -0,0 +1,32 @@
+/**
+ * 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.visibility;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Modifier;
+
+class TestVisibility {
+    @Test
+    void testMatches() {
+        Assertions.assertFalse(Modifier.isPublic(PackagePrivateRecordBuilder.class.getModifiers()));
+        Assertions.assertFalse(Modifier.isPrivate(PackagePrivateRecordBuilder.class.getModifiers()));
+        Assertions.assertFalse(Modifier.isProtected(PackagePrivateRecordBuilder.class.getModifiers()));
+
+        Assertions.assertTrue(Modifier.isPublic(WrapperProtectedRecordBuilder.class.getModifiers()));
+    }
+}
--- a/record-builder-validator/pom.xml
+++ b/record-builder-validator/pom.xml
@@ -0,0 +1,31 @@
+<?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">
+    <parent>
+        <groupId>io.soabase.record-builder</groupId>
+        <artifactId>record-builder</artifactId>
+        <version>26</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>record-builder-validator</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.validator</Automatic-Module-Name>
+                        </manifestEntries>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
--- a/record-builder-validator/src/main/java/io/soabase/recordbuilder/validator/RecordBuilderValidator.java
+++ b/record-builder-validator/src/main/java/io/soabase/recordbuilder/validator/RecordBuilderValidator.java
@@ -0,0 +1,80 @@
+/**
+ * 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.validator;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Set;
+
+// complete Java Validation via reflection to avoid dependencies
+public class RecordBuilderValidator {
+    private static final Object validator;
+    private static final Method validationMethod;
+    private static final Constructor<?> constraintViolationExceptionCtor;
+    private static final Class<?>[] emptyGroups = new Class<?>[0];
+
+    private static final boolean PRINT_ERROR_STACKTRACE = Boolean.getBoolean("record_builder_validator_errors");
+
+    static {
+        Object localValidator = null;
+        Method localValidationMethod = null;
+        Constructor<?> localConstraintViolationExceptionCtor = null;
+        try {
+            var validationClass = Class.forName("javax.validation.Validation");
+            var factoryClass = validationClass.getDeclaredMethod("buildDefaultValidatorFactory");
+            var factory = factoryClass.invoke(null);
+            var getValidatorMethod = factory.getClass().getMethod("getValidator");
+            var constraintViolationExceptionClass = Class.forName("javax.validation.ConstraintViolationException");
+            localValidator = getValidatorMethod.invoke(factory);
+            localValidationMethod = localValidator.getClass().getMethod("validate", Object.class, Class[].class);
+            localConstraintViolationExceptionCtor = constraintViolationExceptionClass.getConstructor(Set.class);
+        } catch (Exception e) {
+            if (PRINT_ERROR_STACKTRACE) {
+                e.printStackTrace();
+            }
+        }
+        validator = localValidator;
+        validationMethod = localValidationMethod;
+        constraintViolationExceptionCtor = localConstraintViolationExceptionCtor;
+    }
+
+    public static <T> T validate(T o) {
+        if ((validator != null) && (validationMethod != null)) {
+            try {
+                var violations = validationMethod.invoke(validator, o, emptyGroups);
+                if (!((Collection<?>) violations).isEmpty()) {
+                    throw (RuntimeException) constraintViolationExceptionCtor.newInstance(violations);
+                }
+            } catch (IllegalAccessException | InstantiationException e) {
+                throw new RuntimeException(e);
+            } catch (InvocationTargetException e) {
+                if (e.getCause() != null) {
+                    if (e.getCause() instanceof RuntimeException) {
+                        throw (RuntimeException) e.getCause();
+                    }
+                    throw new RuntimeException(e.getCause());
+                }
+                throw new RuntimeException(e);
+            }
+        }
+        return o;
+    }
+
+    private RecordBuilderValidator() {
+    }
+}
Author	SHA1	Message	Date
Jordan Zimmerman	445c33fc1d	[maven-release-plugin] prepare release record-builder-26	2021-08-18 08:19:14 -05:00
Jordan Zimmerman	2b266bd65d	[maven-release-plugin] prepare for next development iteration	2021-08-18 08:15:23 -05:00
Jordan Zimmerman	821718ac3f	[maven-release-plugin] prepare release record-builder-25-java15	2021-08-18 08:15:19 -05:00
Jordan Zimmerman	8ac34529e7	Match record visibility If the builder is in the same package as the record and the record is package-private, make the builder package-private too. Closes #52	2021-08-18 08:01:48 -05:00
Jordan Zimmerman	c701a09039	`@Override` should not be inherited. Also, the `inheritComponentAnnotations` option was being ignored. Closes #57	2021-08-18 07:48:28 -05:00
Jordan Zimmerman	328bb7d660	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. Closes #56 Closes #58	2021-08-18 07:48:04 -05:00
Jordan Zimmerman	41eddd46a3	[maven-release-plugin] prepare for next development iteration	2021-08-04 08:38:31 -05:00
Jordan Zimmerman	b0f4bfbe88	[maven-release-plugin] prepare release record-builder-24	2021-08-04 08:38:27 -05:00
Jordan Zimmerman	09168b6104	[maven-release-plugin] prepare for next development iteration	2021-08-04 08:34:03 -05:00
Jordan Zimmerman	d4e24993c9	[maven-release-plugin] prepare release record-builder-23-java15	2021-08-04 08:33:59 -05:00
Jordan Zimmerman	8304cb1f83	Remove downcast in favor of methods Great suggestion from @Twisol. There's no need for the downcasting if record component methods are added to the Wither interface. Closes #27	2021-08-04 08:16:12 -05:00
Jordan Zimmerman	7215ad3241	Validation and null checks are missing for withers. This PR adds them. Closes #47	2021-07-01 08:37:52 +01:00
Jordan Zimmerman	f7d65c7619	[maven-release-plugin] prepare for next development iteration	2021-06-26 05:55:30 +01:00
Jordan Zimmerman	29ebe52914	[maven-release-plugin] prepare release record-builder-22	2021-06-26 05:55:23 +01:00
Jordan Zimmerman	d9c143aa8b	[maven-release-plugin] prepare for next development iteration	2021-06-25 19:21:43 +01:00
Jordan Zimmerman	0647b66bcd	[maven-release-plugin] prepare release record-builder-21	2021-06-25 19:21:36 +01:00
Jordan Zimmerman	08a4471d15	[maven-release-plugin] prepare for next development iteration	2021-06-25 19:15:49 +01:00
Jordan Zimmerman	a1acfb2863	[maven-release-plugin] prepare release record-builder-21-java15	2021-06-25 19:15:42 +01:00
Jordan Zimmerman	82bc1c1625	Added more unit tests Closes #36	2021-06-24 05:37:43 +01:00
Jordan Zimmerman	2d029a2786	Fix up some minor version/path issues in the POMs	2021-06-24 05:07:35 +01:00
dependabot[bot]	2625b3d849	Bump hibernate-validator from 6.0.16.Final to 6.0.20.Final Bumps [hibernate-validator](https://github.com/hibernate/hibernate-validator) from 6.0.16.Final to 6.0.20.Final. - [Release notes](https://github.com/hibernate/hibernate-validator/releases) - [Changelog](https://github.com/hibernate/hibernate-validator/blob/6.0.20.Final/changelog.txt) - [Commits](https://github.com/hibernate/hibernate-validator/compare/6.0.16.Final...6.0.20.Final) --- updated-dependencies: - dependency-name: org.hibernate.validator:hibernate-validator dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2021-06-24 04:51:54 +01:00
Jordan Zimmerman	cc5e189f94	Support Java Validation API Option to pass created records through the Java Validation API if it's available in the classpath. IMPORTANT: when enabled, the record-builder-validator module must also be included. record-builder-validator is written totally via reflection so if no validation framework is included it's a NOP.	2021-06-24 04:50:26 +01:00
Jordan Zimmerman	9125ba0660	Add support for NotNull-style annotations When enabled, annotations matching the configured regex for NotNull annotations cause `Object.requireNonNull()` to be added for annotated components.	2021-06-24 04:39:06 +01:00
Jordan Zimmerman	664809fc69	Use manifest based automatic module instead of hand-coded version (#43 ) This is much saner. It seems silly to maintain an extra file in the project when this can all be done via Maven config.	2021-06-22 13:37:56 +01:00
Jordan Zimmerman	9d011b82aa	Set optional fields to empty by default (#38 ) Sets `Optional` fields to `empty()` by default. Adds an option to control this. Closes #34	2021-06-22 13:04:43 +01:00
Jordan Zimmerman	35125f550d	Support copying component annotations to builder (#33 ) - Enabled via new option `inheritComponentAnnotations` (true by default) - Canonical constructor parameter annotations are copied to RecordBuilder setters and the static builder - Record component accessor annotations are copied to RecordBuilder getters	2021-06-22 12:09:11 +01:00
Jordan Zimmerman	cb2bd68697	Rework how options are specified (#37 ) - Remove `RecordBuilderMetaData` - Unify how the javac options are handled - Create `RecordBuilder.Options` to specify options - Allow creation of custom annotations that bundle options	2021-06-22 05:06:44 +01:00
Thiago Henrique Hüpner	f40cfd48ee	Enable syntax-highlighting in the README (#29 )	2021-04-03 09:40:46 -05:00
Jordan Zimmerman	d9f2adc2f9	Update README.md	2021-03-23 15:43:40 -05:00
Jordan Zimmerman	99832d50ae	Update README.md	2021-03-23 15:43:14 -05:00
Jordan Zimmerman	1203109108	Update README.md	2021-03-23 15:42:43 -05:00
Michał Górniewski	7e4675f7c0	Add support for Java Platform Module System (#28 )	2021-03-20 09:29:23 -05:00
Jordan Zimmerman	8ab9d8bdca	[maven-release-plugin] prepare for next development iteration	2021-03-16 09:50:46 -05:00
Jordan Zimmerman	24edc5e70c	[maven-release-plugin] prepare release record-builder-1.19	2021-03-16 09:50:39 -05:00
Jordan Zimmerman	3832cb3881	Merge branch 'master' of github.com:Randgalt/record-builder	2021-03-16 09:50:12 -05:00
Jordan Zimmerman	2beafc4803	[maven-release-plugin] rollback the release of record-builder-1.19	2021-03-16 09:49:45 -05:00
Jordan Zimmerman	82b3925618	[maven-release-plugin] prepare release record-builder-1.19	2021-03-16 09:49:32 -05:00
Jordan Zimmerman	802dd1f880	Update README.md	2021-02-04 10:12:17 -05:00
Jordan Zimmerman	ba90e6cdca	[maven-release-plugin] prepare for next development iteration	2021-02-04 06:35:37 -05:00
Jordan Zimmerman	07e52035ee	[maven-release-plugin] prepare release record-builder-1.18	2021-02-04 06:35:29 -05:00
Jordan Zimmerman	07fc606147	Update README.md	2021-02-04 06:33:50 -05:00
Jordan Zimmerman	677813e875	[maven-release-plugin] prepare for next development iteration	2021-02-04 06:31:51 -05:00
Jordan Zimmerman	7d877963fb	[maven-release-plugin] prepare release record-builder-1.18-java15	2021-02-04 06:31:51 -05:00
Jordan Zimmerman	96bb6ef9f3	Abandon previous attempt to have Java15 specific modules. I can just manually do it from now on	2021-02-04 06:31:51 -05:00
Jordan Zimmerman	6f3046f507	Update README.md	2021-02-01 13:22:08 -05:00
Jordan Zimmerman	7564643556	[maven-release-plugin] prepare for next development iteration	2021-02-01 13:08:04 -05:00
Jordan Zimmerman	dfd76fc58b	[maven-release-plugin] prepare release record-builder-1.17	2021-02-01 13:08:02 -05:00
Jordan Zimmerman	04e9135591	[maven-release-plugin] prepare for next development iteration	2021-02-01 13:06:44 -05:00
Jordan Zimmerman	b512a6e968	[maven-release-plugin] prepare release record-builder-1.17	2021-02-01 13:06:44 -05:00
Jordan Zimmerman	5a1cd35320	[maven-release-plugin] rollback the release of record-builder-1.17	2021-02-01 13:06:44 -05:00
Jordan Zimmerman	a615e3abb6	[maven-release-plugin] prepare release record-builder-1.17	2021-02-01 13:06:44 -05:00
Jordan Zimmerman	3f8bb47cbf	Support alternate artifacts built with Java 15	2021-02-01 13:00:42 -05:00
Jordan Zimmerman	5a8e72f0e9	[maven-release-plugin] prepare for next development iteration	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	44ad4531b6	[maven-release-plugin] prepare release record-builder-1.16	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	7e78d32780	Added support for putting @RecordInterface on Java beans	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	0dc4aa7657	Prep for Java 16	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	b6d9a6202f	Create FUNDING.yml	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	b21368f32f	Have the consumer version of with() use the other with() to get the builder. This will ensure better testing and is more logical	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	501da86afd	you're right - we only need provided/compileOnly. I've made the updates to Maven as well.	2021-02-01 12:26:07 -05:00
Marc Philipp	13d867e6e6	Use compileOnly instead of implementation Since most users only need the annotations.	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	a1206fa57f	[maven-release-plugin] prepare for next development iteration	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	b89722ebfe	[maven-release-plugin] prepare release record-builder-1.14.ea	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	75163f53ed	Update README.md	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	9855e7b504	Switch to Github Actions	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	aa3bdedf28	Update maven.yml	2021-02-01 12:26:07 -05:00
Jordan Zimmerman	6d5e15baa1	Create maven.yml	2021-02-01 12:26:07 -05:00
Mikaël Barbero	9c8e3626ba	Stop relying on toString() to detect package name. Fix for #15	2020-12-11 18:18:32 +00:00
Jordan Zimmerman	24b85e7ad5	[maven-release-plugin] prepare for next development iteration	2020-11-29 08:27:34 -05:00
Jordan Zimmerman	861e2e745a	[maven-release-plugin] prepare release record-builder-1.13.ea	2020-11-29 08:27:25 -05:00
Jordan Zimmerman	1fc7c9a4b3	Make sure the downcast variable name doesn't collide with a record component name	2020-11-28 22:39:00 -05:00
Jordan Zimmerman	570514e077	buildPackageName() can't assume that the immediate enclosing element is the package. It may be a nested class, etc.	2020-11-28 22:38:48 -05:00
Jordan Zimmerman	9d8b9e65bc	[maven-release-plugin] prepare for next development iteration	2020-11-28 08:44:33 -05:00
Jordan Zimmerman	93d6204b76	[maven-release-plugin] prepare release record-builder-1.12.ea	2020-11-28 08:44:25 -05:00
Jordan Zimmerman	15e5bfccc6	[maven-release-plugin] rollback the release of record-builder-1.12.ea	2020-11-28 08:42:15 -05:00
Jordan Zimmerman	67c54244c5	[maven-release-plugin] prepare release record-builder-1.12.ea	2020-11-28 08:41:59 -05:00
Jordan Zimmerman	870ac4a9d9	[maven-release-plugin] rollback the release of record-builder-1.12.ea	2020-11-28 08:29:46 -05:00
Jordan Zimmerman	9ee8b5912a	[maven-release-plugin] prepare for next development iteration	2020-11-28 08:28:09 -05:00
Jordan Zimmerman	6d9bcf27da	[maven-release-plugin] prepare release record-builder-1.12.ea	2020-11-28 08:27:49 -05:00
Jordan Zimmerman	44db5fdf17	Change to 1.12.ea-SNAPSHOT - last release must have missed this	2020-11-28 08:25:10 -05:00
Jordan Zimmerman	90a65235a9	Add support for static constructor Add a static constructor/builder so it can statically imported. Instead of calling "new Record(...)" you can call just "Record(...)".	2020-11-28 07:35:34 -05:00
Ted Cassirer	7e8ddbd700	Remove unused variable in RecordBuilder	2020-11-25 09:33:08 -05:00
Ted Cassirer	3a534fbea9	Don't add the allArgsConstructor to the RecordBuilder if record has no fields	2020-11-25 08:53:06 -05:00
Jordan Zimmerman	6d7ebe2545	Update README.md	2020-11-09 14:42:30 -05:00
Jordan Zimmerman	f1e47391c8	Update README.md	2020-11-04 11:34:41 -05:00
Jordan Zimmerman	c999d0ba06	Update README.md	2020-11-04 10:47:33 -05:00
Jordan Zimmerman	e0243c8b1c	Fixed some typos in previous PR	2020-11-04 10:44:43 -05:00
Jordan Zimmerman	65bbbaea05	Update README.md	2020-11-04 10:38:53 -05:00
Jordan Zimmerman	5ae03a2c66	Update README.md	2020-11-04 10:37:38 -05:00
Jordan Zimmerman	437e314799	Better exception when Wither is set as implementor on non-builder class	2020-11-04 10:36:35 -05:00
Jordan Zimmerman	a870beee21	Update README.md	2020-11-02 23:41:19 -05:00
Jordan Zimmerman	5b879743ef	Added simple module-info. I've never done this before, I hope it's right	2020-11-02 23:37:57 -05:00
Jordan Zimmerman	c7bdafb0b9	Add method to do downcasting	2020-11-02 23:37:57 -05:00
Jordan Zimmerman	d67c62ed3b	Update README.md	2020-10-05 15:00:28 -05:00
Jordan Zimmerman	39cf2b0353	Update README.md	2020-10-05 15:00:16 -05:00
Jordan Zimmerman	6813b88f8d	Update README.md	2020-10-05 14:59:28 -05:00
Jordan Zimmerman	54662d69c7	Support Include versions of the annotation	2020-10-05 14:45:34 -05:00
Jordan Zimmerman	7811ff8823	Update README.md	2020-10-05 11:30:04 -05:00
Jordan Zimmerman	4c5076690d	Update README.md	2020-10-05 11:29:32 -05:00
Jordan Zimmerman	39a800f10e	Update README.md	2020-10-05 11:29:00 -05:00
Jordan Zimmerman	610081b27e	[maven-release-plugin] prepare for next development iteration	2020-10-05 11:22:40 -05:00