add support to generate subschemas as nested classes

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

@@ -71,6 +71,8 @@ public class Jsonschema2PojoTask extends Task implements GenerationConfig {
 
     private boolean includeTypeInfo = false;
 
+    private boolean useNestedClasses = false;
+
     private boolean useInnerClassBuilders = false;
 
     private boolean includeConstructorPropertiesAnnotation = false;
@@ -372,6 +374,23 @@ public void setIncludeTypeInfo(boolean includeTypeInfo) {
         this.includeTypeInfo = includeTypeInfo;
     }
 
+    /**
+     * Sets the 'useNestedClasses' property of this class.
+     *
+     * @param useNestedClasses
+     *            Whether to use static nested classes instead of top-level ones when generating types of complex inline
+     *            subschemas.
+     *            <p>
+     *            By default, complex types defined inline within a JSON schema are generated as top-level classes. This
+     *            property allows to override the default behaviour so that complex types defined inline are generated
+     *            as static nested classes of the main schema class.
+     *            <p>
+     *            Default: <code>false</code>.
+     */
+    public void setUseNestedClasses(boolean useNestedClasses) {
+        this.useNestedClasses = useNestedClasses;
+    }
+
     /**
      * Sets the 'usePrimitives' property of this class.
      *
@@ -994,6 +1013,11 @@ public boolean isIncludeTypeInfo()
         return includeTypeInfo;
     }
 
+    @Override
+    public boolean isUseNestedClasses() {
+        return useNestedClasses;
+    }
+
     @Override
     public boolean isUsePrimitives() {
         return usePrimitives;

jsonschema2pojo-ant/src/site/Jsonschema2PojoTask.html

@@ -176,6 +176,17 @@ <h3>Parameters</h3>
     </td>
     <td align="center" valign="top">No (default <code>false</code>)</td>
   </tr>
+  <tr>
+    <td valign="top">useNestedClasses</td>
+    <td valign="top">
+      <p>Whether to use static nested classes instead of top-level ones when generating types for complex inline
+        subschemas.</p>
+      <p>By default, complex types defined inline within a JSON schema are generated as top-level classes. This property
+        allows to override the default behaviour so that complex types defined inline are generated as static nested
+        classes of the main schema class.</p>
+    </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

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

@@ -66,6 +66,9 @@ public class Arguments implements GenerationConfig {
     @Parameter(names = { "--include-type-info" }, description = "Include json type info; required to support polymorphic type handling. https://github.com/FasterXML/jackson-docs/wiki/JacksonPolymorphicDeserialization")
     private boolean includeTypeInfo = false;
 
+    @Parameter(names = { "-nc", "--use-nested-classes" }, description = "Generate all inline complex subschemas as nested classes of the main schema class. The default is one top-level class corresponding to one complex subschema.")
+    private boolean useNestedClasses = false;
+
     @Parameter(names = { "--use-inner-class-builders" }, description = "Generate an inner class with builder-style methods")
     private boolean useInnerClassBuilders = false;
 
@@ -310,6 +313,11 @@ public boolean isIncludeTypeInfo()
         return includeTypeInfo;
     }
 
+    @Override
+    public boolean isUseNestedClasses() {
+        return useNestedClasses;
+    }
+
     public String getLogLevel() {
         return logLevel;
     }

jsonschema2pojo-cli/src/test/java/org/jsonschema2pojo/cli/ArgumentsTest.java

@@ -54,7 +54,8 @@ public void parseRecognisesValidArguments() {
         ArgsForTest args = (ArgsForTest) new ArgsForTest().parse(new String[] {
                 "--source", "/home/source", "--target", "/home/target", "--disable-getters", "--package", "mypackage",
                 "--generate-builders", "--use-primitives", "--omit-hashcode-and-equals", "--omit-tostring", "--include-dynamic-accessors",
-                "--include-dynamic-getters", "--include-dynamic-setters", "--include-dynamic-builders", "--inclusion-level", "ALWAYS"
+                "--include-dynamic-getters", "--include-dynamic-setters", "--include-dynamic-builders", "--inclusion-level", "ALWAYS",
+                "--use-nested-classes"
         });
 
         assertThat(args.didExit(), is(false));
@@ -71,13 +72,15 @@ public void parseRecognisesValidArguments() {
         assertThat(args.isIncludeDynamicGetters(), is(true));
         assertThat(args.isIncludeDynamicSetters(), is(true));
         assertThat(args.isIncludeDynamicBuilders(), is(true));
+        assertThat(args.isUseNestedClasses(), is(true));
         assertThat(args.getInclusionLevel(), is(InclusionLevel.ALWAYS));
     }
 
     @Test
     public void parseRecognisesShorthandArguments() {
         ArgsForTest args = (ArgsForTest) new ArgsForTest().parse(new String[] {
-                "-s", "/home/source", "-t", "/home/target", "-p", "mypackage", "-b", "-P", "-E", "-S", "-ida", "-idg", "-ids", "-idb", "-il", "ALWAYS"
+                "-s", "/home/source", "-t", "/home/target", "-p", "mypackage", "-b", "-P", "-E", "-S", "-ida", "-idg",
+                "-ids", "-idb", "-il", "ALWAYS", "-nc"
         });
 
         assertThat(args.didExit(), is(false));
@@ -92,6 +95,7 @@ public void parseRecognisesShorthandArguments() {
         assertThat(args.isIncludeDynamicGetters(), is(true));
         assertThat(args.isIncludeDynamicSetters(), is(true));
         assertThat(args.isIncludeDynamicBuilders(), is(true));
+        assertThat(args.isUseNestedClasses(), is(true));
         assertThat(args.getInclusionLevel(), is(InclusionLevel.ALWAYS));
     }
 
@@ -124,6 +128,7 @@ public void allOptionalArgsCanBeOmittedAndDefaultsPrevail() {
         assertThat(args.isIncludeDynamicGetters(), is(false));
         assertThat(args.isIncludeDynamicSetters(), is(false));
         assertThat(args.isIncludeDynamicBuilders(), is(false));
+        assertThat(args.isUseNestedClasses(), is(false));
     }
 
     @Test

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

@@ -48,6 +48,14 @@ public boolean isIncludeTypeInfo()
         return false;
     }
 
+    /**
+     * @return <code>false</code>
+     */
+    @Override
+    public boolean isUseNestedClasses() {
+        return false;
+    }
+
     /**
      * @return <code>false</code>
      */

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

@@ -52,6 +52,14 @@ public interface GenerationConfig {
    */
   boolean isIncludeTypeInfo();
 
+  /**
+   * Gets the 'useNestedClasses' configuration option.
+   *
+   * @return whether to use static nested classes instead of top-level ones when generating types for complex inline
+   *         subschemas
+   */
+  boolean isUseNestedClasses();
+
     /**
      * Gets the 'includeConstructorPropertiesAnnotation' configuration option.
      *

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

@@ -27,6 +27,7 @@
 import java.util.Map;
 import java.util.Set;
 
+import com.sun.codemodel.JClassContainer;
 import org.jsonschema2pojo.AnnotationStyle;
 import org.jsonschema2pojo.Annotator;
 import org.jsonschema2pojo.Schema;
@@ -39,7 +40,6 @@
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.sun.codemodel.ClassType;
-import com.sun.codemodel.JAnnotationUse;
 import com.sun.codemodel.JBlock;
 import com.sun.codemodel.JClass;
 import com.sun.codemodel.JClassAlreadyExistsException;
@@ -52,7 +52,6 @@
 import com.sun.codemodel.JMethod;
 import com.sun.codemodel.JMod;
 import com.sun.codemodel.JOp;
-import com.sun.codemodel.JPackage;
 import com.sun.codemodel.JType;
 import com.sun.codemodel.JVar;
 
@@ -63,7 +62,7 @@
  *      "http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1">http:/
  *      /tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1</a>
  */
-public class ObjectRule implements Rule<JPackage, JType> {
+public class ObjectRule implements Rule<JClassContainer, JType> {
 
     private final RuleFactory ruleFactory;
     private final ReflectionHelper reflectionHelper;
@@ -83,16 +82,15 @@ protected ObjectRule(RuleFactory ruleFactory, ParcelableHelper parcelableHelper,
      * characteristics. See other implementers of {@link Rule} for details.
      */
     @Override
-    public JType apply(String nodeName, JsonNode node, JsonNode parent, JPackage _package, Schema schema) {
-
-        JType superType = reflectionHelper.getSuperType(nodeName, node, _package, schema);
+    public JType apply(String nodeName, JsonNode node, JsonNode parent, JClassContainer container, Schema schema) {
+        JType superType = reflectionHelper.getSuperType(nodeName, node, container.getPackage(), schema);
         if (superType.isPrimitive() || reflectionHelper.isFinal(superType)) {
             return superType;
         }
 
         JDefinedClass jclass;
         try {
-            jclass = createClass(nodeName, node, _package);
+            jclass = createClass(nodeName, node, container);
         } catch (ClassAlreadyExistsException e) {
             return e.getExistingClass();
         }
@@ -187,16 +185,16 @@ private void addParcelSupport(JDefinedClass jclass) {
      *            new class. This node may include a 'javaType' property which
      *            if present will override the fully qualified name of the newly
      *            generated class.
-     * @param _package
-     *            the package which may contain a new class after this method
-     *            call
+     * @param container
+     *            the class container (package or class) which may contain a new
+     *            class after this method call
      * @return a reference to a newly created class
      * @throws ClassAlreadyExistsException
      *             if the given arguments cause an attempt to create a class
      *             that already exists, either on the classpath or in the
      *             current map of classes to be generated.
      */
-    private JDefinedClass createClass(String nodeName, JsonNode node, JPackage _package) throws ClassAlreadyExistsException {
+    private JDefinedClass createClass(String nodeName, JsonNode node, JClassContainer container) throws ClassAlreadyExistsException {
 
         JDefinedClass newType;
 
@@ -206,11 +204,11 @@ private JDefinedClass createClass(String nodeName, JsonNode node, JPackage _pack
             if (node.has("existingJavaType")) {
                 String fqn = substringBefore(node.get("existingJavaType").asText(), "<");
 
-                if (isPrimitive(fqn, _package.owner())) {
-                    throw new ClassAlreadyExistsException(primitiveType(fqn, _package.owner()));
+                if (isPrimitive(fqn, container.owner())) {
+                    throw new ClassAlreadyExistsException(primitiveType(fqn, container.owner()));
                 }
 
-                JClass existingClass = resolveType(_package, fqn + (node.get("existingJavaType").asText().contains("<") ? "<" + substringAfter(node.get("existingJavaType").asText(), "<") : ""));
+                JClass existingClass = resolveType(container, fqn + (node.get("existingJavaType").asText().contains("<") ? "<" + substringAfter(node.get("existingJavaType").asText(), "<") : ""));
                 throw new ClassAlreadyExistsException(existingClass);
             }
 
@@ -219,7 +217,7 @@ private JDefinedClass createClass(String nodeName, JsonNode node, JPackage _pack
             if (node.has("javaType")) {
                 String fqn = node.path("javaType").asText();
 
-                if (isPrimitive(fqn, _package.owner())) {
+                if (isPrimitive(fqn, container.owner())) {
                     throw new GenerationException("javaType cannot refer to a primitive type (" + fqn + "), did you mean to use existingJavaType?");
                 }
 
@@ -229,7 +227,7 @@ private JDefinedClass createClass(String nodeName, JsonNode node, JPackage _pack
 
                 int index = fqn.lastIndexOf(".") + 1;
                 if (index == 0) { //Actually not a fully qualified name
-                    fqn = _package.name() + "." + fqn;
+                    fqn = container.getPackage().name() + "." + fqn;
                     index = fqn.lastIndexOf(".") + 1;
                 }
 
@@ -238,15 +236,22 @@ private JDefinedClass createClass(String nodeName, JsonNode node, JPackage _pack
                 }
 
                 if (usePolymorphicDeserialization) {
-                    newType = _package.owner()._class(JMod.PUBLIC, fqn, ClassType.CLASS);
+                    newType = container.owner()._class(JMod.PUBLIC, fqn, ClassType.CLASS);
                 } else {
-                    newType = _package.owner()._class(fqn);
+                    newType = container.owner()._class(fqn);
                 }
             } else {
                 if (usePolymorphicDeserialization) {
-                    newType = _package._class(JMod.PUBLIC, ruleFactory.getNameHelper().getUniqueClassName(nodeName, node, _package), ClassType.CLASS);
+                    newType = container._class(JMod.PUBLIC, ruleFactory.getNameHelper()
+                            .getUniqueClassName(nodeName, node, container.getPackage()), ClassType.CLASS);
                 } else {
-                    newType = _package._class(ruleFactory.getNameHelper().getUniqueClassName(nodeName, node, _package));
+                    if (container instanceof JDefinedClass) {
+                        newType = container._class(JMod.PUBLIC | JMod.STATIC,
+                                ruleFactory.getNameHelper().getUniqueClassName(nodeName, node, container.getPackage()));
+                    } else {
+                        newType = container._class(ruleFactory.getNameHelper()
+                                .getUniqueClassName(nodeName, node, container.getPackage()));
+                    }
                 }
             }
         } catch (JClassAlreadyExistsException e) {

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

@@ -133,7 +133,7 @@ public Rule<JType, JType> getFormatRule() {
      *
      * @return a schema rule that can handle the "object" declaration.
      */
-    public Rule<JPackage, JType> getObjectRule() {
+    public Rule<JClassContainer, JType> getObjectRule() {
         return new ObjectRule(this, new ParcelableHelper(), reflectionHelper);
     }
 

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

@@ -80,7 +80,7 @@ public JType apply(String nodeName, JsonNode schemaNode, JsonNode parent, JClass
         if (schemaNode.has("enum")) {
             javaType = ruleFactory.getEnumRule().apply(nodeName, schemaNode, parent, generatableType, schema);
         } else {
-            javaType = ruleFactory.getTypeRule().apply(nodeName, schemaNode, parent, generatableType.getPackage(), schema);
+            javaType = ruleFactory.getTypeRule().apply(nodeName, schemaNode, parent, generatableType, schema);
         }
         schema.setJavaTypeIfEmpty(javaType);
 

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

@@ -28,6 +28,7 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.sun.codemodel.JClassContainer;
 import com.sun.codemodel.JCodeModel;
+import com.sun.codemodel.JDefinedClass;
 import com.sun.codemodel.JType;
 
 /**
@@ -79,8 +80,15 @@ public JType apply(String nodeName, JsonNode node, JsonNode parent, JClassContai
     JType type;
 
     if (propertyTypeName.equals("object") || node.has("properties") && node.path("properties").size() > 0) {
-
-      type = ruleFactory.getObjectRule().apply(nodeName, node, parent, jClassContainer.getPackage(), schema);
+      if (!ruleFactory.getGenerationConfig().isUseNestedClasses() || schema == schema.getParent()) {
+        type = ruleFactory.getObjectRule().apply(nodeName, node, parent, jClassContainer.getPackage(), schema);
+      } else if (jClassContainer instanceof JDefinedClass) {
+        return ruleFactory.getObjectRule().apply(nodeName, node, parent, jClassContainer, schema);
+      } else {
+        Schema parentSchema = ruleFactory.getSchemaStore().create(schema.getParent().getId(), null);
+        return ruleFactory.getObjectRule().apply(nodeName, node, parent, (JClassContainer) parentSchema.getJavaType(),
+                schema);
+      }
     } else if (node.has("existingJavaType")) {
       String typeName = node.path("existingJavaType").asText();