add concrete setter for optionals in staged required only builder (#204) (#205)

Co-authored-by: gerg <[email protected]>

Author: gvdenbro

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

@@ -266,6 +266,10 @@ private void addStagedBuilderClasses() {
                             .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT).addParameter(parameterSpecBuilder.build())
                             .addCode(codeBlock).returns(builderClassType.typeName()).build();
                     classBuilder.addMethod(methodSpec);
+
+                    if (metaData.addConcreteSettersForOptional()) {
+                        add1ConcreteOptionalSetterMethodToFinalStage(optionalComponent, classBuilder);
+                    }
                 });
 
         var builderMethod = MethodSpec.methodBuilder(metaData.builderMethodName())
@@ -308,6 +312,23 @@ private void add1StagedBuilderClass(RecordClassType component, Optional<RecordCl
         builder.addType(classBuilder.build());
     }
 
+    private void add1ConcreteOptionalSetterMethodToFinalStage(RecordClassType optionalComponent,
+            TypeSpec.Builder classBuilder) {
+        var optionalType = OptionalType.fromClassType(optionalComponent);
+        if (optionalType.isPresent()) {
+            var type = optionalType.get();
+            var concreteCodeBlock = CodeBlock.builder().add("return $L().$L($L);", metaData.builderMethodName(),
+                    optionalComponent.name(), optionalComponent.name()).build();
+            var concreteParameterSpecBuilder = ParameterSpec.builder(type.valueType(), optionalComponent.name());
+            var concreteMethodSpec = MethodSpec.methodBuilder(optionalComponent.name())
+                    .addAnnotation(generatedRecordBuilderAnnotation)
+                    .addJavadoc("Call builder for optional component {@code $L}", optionalComponent.name())
+                    .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT).addParameter(concreteParameterSpecBuilder.build())
+                    .addCode(concreteCodeBlock).returns(builderClassType.typeName()).build();
+            classBuilder.addMethod(concreteMethodSpec);
+        }
+    }
+
     private void addWithNestedClass() {
         /*
          * Adds a nested interface that adds withers similar to:

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2019 The original author or authors
+ *
+ * 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.staged;
+
+import io.soabase.recordbuilder.core.RecordBuilder;
+
+import java.util.Optional;
+
+@RecordBuilder
+@RecordBuilder.Options(builderMode = RecordBuilder.BuilderMode.STAGED_REQUIRED_ONLY, addConcreteSettersForOptional = true)
+public record OptionalStagedRequiredOnly(int a, Optional<String> b, String c) {
+}

record-builder-test/src/test/java/io/soabase/recordbuilder/test/staged/TestStagedBuilder.java

@@ -91,4 +91,16 @@ void testInitialized() {
         InitializedStaged obj = InitializedStagedBuilder.builder().name("foo").age(42).build();
         assertEquals(new InitializedStaged(42, "foo"), obj);
     }
+
+    @Test
+    void testOptionalStagedRequiredOnlyConcreteSetter() {
+        OptionalStagedRequiredOnly obj = OptionalStagedRequiredOnlyBuilder.builder().a(1).c("cccc").build();
+        assertEquals(new OptionalStagedRequiredOnly(1, Optional.empty(), "cccc"), obj);
+
+        obj = OptionalStagedRequiredOnlyBuilder.builder().a(1).c("cccc").b(Optional.of("bbbb")).build();
+        assertEquals(new OptionalStagedRequiredOnly(1, Optional.of("bbbb"), "cccc"), obj);
+
+        obj = OptionalStagedRequiredOnlyBuilder.builder().a(1).c("cccc").b("bbbb").build();
+        assertEquals(new OptionalStagedRequiredOnly(1, Optional.of("bbbb"), "cccc"), obj);
+    }
 }