Merge pull request #953 from dewthefifth/features/builders-as-inner-classes

Features/builders as inner classes

Author: joelittlejohn

jsonschema2pojo-ant/src/main/java/org/jsonschema2pojo/ant/Jsonschema2PojoTask.java

@@ -69,6 +69,8 @@ public class Jsonschema2PojoTask extends Task implements GenerationConfig {
 
     private boolean generateBuilders;
 
+    private boolean useInnerClassBuilders = false;
+
     private boolean includeConstructors = false;
 
     private boolean usePrimitives;
@@ -1201,5 +1203,18 @@ public Language getTargetLanguage() {
     public Map<String, String> getFormatTypeMapping() {
         return formatTypeMapping;
     }
-    
+
+    @Override
+    public boolean isUseInnerClassBuilders() {
+        return useInnerClassBuilders;
+    }
+
+    /**
+     * Sets the 'useInnerClassBuilders' property of this class
+     *
+     * @param useInnerClassBuilders determines whether builders will be chainable setters or embedded classes when {@link #isGenerateBuilders()} used
+     */
+    public void setUseInnerClassBuilders(boolean useInnerClassBuilders) {
+        this.useInnerClassBuilders = useInnerClassBuilders;
+    }
 }

jsonschema2pojo-ant/src/site/Jsonschema2PojoTask.html

@@ -156,6 +156,11 @@ <h3>Parameters</h3>
         </td>
         <td align="center" valign="top">No (default <code>false</code>)</td>
     </tr>
+    <tr>
+        <td valign="top">useInnerClassBuilders</td>
+        <td valign="top">Determines whether builders will be chainable setters or embedded classes when generateBuilders is used</td>
+        <td align="center" valign="top">No (default <code>false</code>)</td>
+    </tr>
     <tr>
         <td valign="top">includeGetters</td>
         <td valign="top">Whether to include getters or to omit these accessor methods and create public fields instead.</td>

jsonschema2pojo-cli/src/main/java/org/jsonschema2pojo/cli/Arguments.java

@@ -63,6 +63,9 @@ public class Arguments implements GenerationConfig {
     @Parameter(names = { "-b", "--generate-builders" }, description = "Generate builder-style methods as well as setters")
     private boolean generateBuilderMethods = false;
 
+    @Parameter(names = { "--use-inner-class-builders" }, description = "Generate an inner class with builder-style methods")
+    private boolean useInnerClassBuilders = false;
+
     @Parameter(names = { "-c", "--generate-constructors" }, description = "Generate constructors")
     private boolean generateConstructors = false;
 
@@ -278,6 +281,11 @@ public boolean isGenerateBuilders() {
         return generateBuilderMethods;
     }
 
+    @Override
+    public boolean isUseInnerClassBuilders() {
+        return useInnerClassBuilders;
+    }
+
     @Override
     public boolean isUsePrimitives() {
         return usePrimitives;

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/DefaultGenerationConfig.java

@@ -444,5 +444,7 @@ public Language getTargetLanguage() {
     public Map<String, String> getFormatTypeMapping() {
         return Collections.emptyMap();
     }
-    
+
+    @Override
+    public boolean isUseInnerClassBuilders() { return false; }
 }

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/GenerationConfig.java

@@ -571,4 +571,13 @@ public interface GenerationConfig {
      *         fully qualified type name (e.g. 'java.net.URI').
      */
     Map<String, String> getFormatTypeMapping();
+
+    /**
+     * If set to true, then the gang of four builder pattern will be used to generate builders on generated classes. Note: This property works
+     * in collaboration with the {@link #isGenerateBuilders()} method. If the {@link #isGenerateBuilders()} is false,
+     * then this property will not do anything.
+     * @return whether to include the gang of four builder patter on the generated classes. The default value for this is false.
+     */
+    default boolean isUseInnerClassBuilders(){ return false;}
+
 }

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/ScalaSingleStreamCodeWriter.java

@@ -16,15 +16,14 @@
 
 package org.jsonschema2pojo;
 
-import java.io.ByteArrayOutputStream;
-import java.io.FilterOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-
 import com.mysema.scalagen.ConversionSettings;
 import com.mysema.scalagen.Converter;
 import com.sun.codemodel.JPackage;
 import com.sun.codemodel.writer.SingleStreamCodeWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
 
 public class ScalaSingleStreamCodeWriter extends SingleStreamCodeWriter {
 

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/rules/AdditionalPropertiesRule.java

@@ -19,6 +19,11 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import java.util.Optional;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.stream.StreamSupport;
+import org.apache.commons.collections15.CollectionUtils;
 import org.jsonschema2pojo.Schema;
 
 import com.fasterxml.jackson.databind.JsonNode;
@@ -160,7 +165,19 @@ private JMethod addGetter(JDefinedClass jclass, JFieldVar field) {
         return getter;
     }
 
-    private void addBuilder(JDefinedClass jclass, JType propertyType, JFieldVar field) {
+    private JMethod addBuilder(JDefinedClass jclass, JType propertyType, JFieldVar field) {
+
+        JMethod result = null;
+        if(ruleFactory.getGenerationConfig().isUseInnerClassBuilders()) {
+            result = addInnerBuilder(jclass, propertyType, field);
+        } else {
+            result = addLegacyBuilder(jclass, propertyType, field);
+        }
+
+        return result;
+    }
+
+    private JMethod addLegacyBuilder(JDefinedClass jclass, JType propertyType, JFieldVar field) {
         JMethod builder = jclass.method(JMod.PUBLIC, jclass, "withAdditionalProperty");
 
         JVar nameParam = builder.param(String.class, "name");
@@ -171,6 +188,32 @@ private void addBuilder(JDefinedClass jclass, JType propertyType, JFieldVar fiel
         mapInvocation.arg(nameParam);
         mapInvocation.arg(valueParam);
         body._return(JExpr._this());
+
+        return builder;
+    }
+
+    private JMethod addInnerBuilder(JDefinedClass jclass, JType propertyType, JFieldVar field) {
+        Optional<JDefinedClass> builderClass = StreamSupport
+            .stream(Spliterators.spliteratorUnknownSize(jclass.classes(), Spliterator.ORDERED), false)
+            .filter(definedClass -> definedClass.name().equals(getBuilderClassName(jclass)))
+            .findFirst();
+
+        JMethod builder = builderClass.get().method(JMod.PUBLIC, builderClass.get(), "withAdditionalProperty");
+
+        JVar nameParam = builder.param(String.class, "name");
+        JVar valueParam = builder.param(propertyType, "value");
+
+        JBlock body = builder.body();
+        JInvocation mapInvocation = body.invoke(JExpr.ref(JExpr.cast(jclass, JExpr._this().ref("instance")), field), "put");
+        mapInvocation.arg(nameParam);
+        mapInvocation.arg(valueParam);
+        body._return(JExpr._this());
+
+        return builder;
+    }
+
+    private String getBuilderClassName(JDefinedClass c) {
+        return ruleFactory.getNameHelper().getBuilderClassName(c);
     }
 
 }

jsonschema2pojo-core/src/main/java/org/jsonschema2pojo/rules/BuilderRule.java

@@ -0,0 +1,121 @@
+/**
+ * Copyright © 2010-2017 Nokia
+ *
+ * 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 org.jsonschema2pojo.rules;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.sun.codemodel.JAnnotationUse;
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JClass;
+import com.sun.codemodel.JClassAlreadyExistsException;
+import com.sun.codemodel.JConditional;
+import com.sun.codemodel.JDefinedClass;
+import com.sun.codemodel.JExpr;
+import com.sun.codemodel.JFieldVar;
+import com.sun.codemodel.JInvocation;
+import com.sun.codemodel.JMethod;
+import com.sun.codemodel.JMod;
+import com.sun.codemodel.JTypeVar;
+import com.sun.codemodel.JVar;
+import java.util.Objects;
+import org.jsonschema2pojo.Schema;
+import org.jsonschema2pojo.util.ReflectionHelper;
+
+public class BuilderRule implements Rule<JDefinedClass, JDefinedClass> {
+
+  private RuleFactory ruleFactory;
+  private ReflectionHelper reflectionHelper;
+
+  BuilderRule(RuleFactory ruleFactory, ReflectionHelper reflectionHelper) {
+    this.ruleFactory = ruleFactory;
+    this.reflectionHelper = reflectionHelper;
+  }
+
+  @Override
+  public JDefinedClass apply(String nodeName, JsonNode node, JsonNode parent, JDefinedClass instanceClass, Schema currentSchema) {
+
+    // Create the inner class for the builder
+    JDefinedClass builderClass;
+
+    try {
+      String builderName = ruleFactory.getNameHelper().getBuilderClassName(instanceClass);
+      builderClass = instanceClass._class(JMod.PUBLIC + JMod.STATIC, builderName);
+    } catch (JClassAlreadyExistsException e) {
+      return e.getExistingClass();
+    }
+
+    // Determine which builder (if any) this builder should inherit from
+    JClass parentBuilderClass = null;
+    JClass parentClass = instanceClass._extends();
+    if (!(parentClass.isPrimitive() || reflectionHelper.isFinal(parentClass) || Objects.equals(parentClass.fullName(), "java.lang.Object"))) {
+      parentBuilderClass = reflectionHelper.getBuilderClass(parentClass);
+    }
+
+    // Determine the generic type 'T' that the builder will create instances of
+    JTypeVar instanceType = builderClass.generify("T", instanceClass);
+
+    // For new builders we need to create an instance variable and 'build' method
+    // for inheriting builders we'll receive these from the superType
+    if (parentBuilderClass == null) {
+
+      // Create the instance variable
+      JFieldVar instanceField = builderClass.field(JMod.PROTECTED, instanceType, "instance");
+
+      // Create the actual "build" method
+      JMethod buildMethod = builderClass.method(JMod.PUBLIC, instanceType, "build");
+
+      JBlock body = buildMethod.body();
+      JVar result = body.decl(instanceType, "result");
+      body.assign(result, JExpr._this().ref(instanceField));
+      body.assign(JExpr._this().ref(instanceField), JExpr._null());
+      body._return(result);
+
+      // Create the noargs builder constructor
+      generateNoArgsBuilderConstructor(instanceClass, builderClass);
+    } else {
+      // Declare the inheritance
+      builderClass._extends(parentBuilderClass);
+
+      // Create the noargs builder constructor
+      generateNoArgsBuilderConstructor(instanceClass, builderClass);
+    }
+
+    return builderClass;
+  }
+
+  private void generateNoArgsBuilderConstructor(JDefinedClass instanceClass, JDefinedClass builderClass) {
+    JMethod noargsConstructor = builderClass.constructor(JMod.PUBLIC);
+    JAnnotationUse warningSuppression = noargsConstructor.annotate(SuppressWarnings.class);
+    warningSuppression.param("value", "unchecked");
+
+    JBlock constructorBlock = noargsConstructor.body();
+
+    JFieldVar instanceField = reflectionHelper.searchClassAndSuperClassesForField("instance", builderClass);
+
+    // Determine if we need to invoke the super() method for our parent builder
+    JClass parentClass = builderClass._extends();
+    if (!(parentClass.isPrimitive() || reflectionHelper.isFinal(parentClass) || Objects.equals(parentClass.fullName(), "java.lang.Object"))) {
+      constructorBlock.invoke("super");
+    }
+
+    // Only initialize the instance if the object being constructed is actually this class
+    // if it's a subtype then ignore the instance initialization since the subclass will initialize it
+    constructorBlock.directStatement("// Skip initialization when called from subclass");
+    JInvocation comparison = JExpr._this().invoke("getClass").invoke("equals").arg(JExpr.dotclass(builderClass));
+    JConditional ifNotSubclass = constructorBlock._if(comparison);
+    ifNotSubclass._then().assign(JExpr._this().ref(instanceField), JExpr.cast(instanceField.type(), JExpr._new(instanceClass)));
+  }
+
+}