Major update to tool

Add overlay annotations
Handle factory beans
Handle recursive bean definitions
Handle forward references
Handle aliases
Handle beans with multiple names
Handle Set and Map values

Known limitation:
May not declare all exception types in the presence of mutually recursive beans
Ignores import paths on the Java classpath

Author: NathanJPhillips

env-model-generator/src/JavaCode.ts

@@ -239,10 +239,7 @@ export class BlankLine extends CodeElement implements Statement, Member {
   }
 }
 
-export class Braces extends CodeElement implements Statement, Member {
-  public isStatement: true = true;
-  public isMember: true = true;
-
+class Braces extends CodeElement {
   private intro: string;
   private body: Statement[];
 
@@ -261,20 +258,46 @@ export class Braces extends CodeElement implements Statement, Member {
   }
 }
 
+export class Block extends Braces implements Statement {
+  public isStatement: true = true;
+}
+
+export class Method extends Braces implements Member {
+  public isMember: true = true;
+
+  private annotations: string[];
+
+  public constructor(intro: string, body: Statement[], exceptions?: string[], annotations?: string[]) {
+    super(intro + (exceptions === undefined || exceptions.length === 0 ? "" : ` throws ${exceptions.join(", ")}`), body);
+    this.annotations = annotations === undefined ? [] : annotations;
+  }
+
+  public flatten(): string[] {
+    return [
+      ...this.annotations.map((annotation) => "@" + annotation),
+      ...super.flatten(),
+    ];
+  }
+}
+
 export class Class extends CodeElement {
   private modifiers: string;
   private name: string;
   private baseClass: string | undefined;
   private interfaces: string[];
   private members: Member[];
+  private annotations: string[];
 
-  public constructor(modifiers: string, name: string, baseClass: string | undefined, interfaces: string[], members: Member[]) {
+  public constructor(
+    modifiers: string, name: string, baseClass: string | undefined, interfaces: string[], members: Member[], annotations?: string[])
+  {
     super();
     this.modifiers = modifiers;
     this.name = name;
     this.baseClass = baseClass;
     this.interfaces = interfaces;
     this.members = members;
+    this.annotations = annotations === undefined ? [] : annotations;
   }
 
   public flatten(): string[] {
@@ -284,6 +307,7 @@ export class Class extends CodeElement {
     const baseClassString = this.baseClass === undefined ? "" : ` extends ${this.baseClass}`;
     const interfacesString = this.interfaces.length === 0 ? "" : ` implements ${this.interfaces.join(", ")}`;
     return [
+      ...this.annotations.map((annotation) => "@" + annotation),
       `${this.modifiers} class ${this.name}${baseClassString}${interfacesString} {`,
       ..._.flatMap(members, (member) => member.flatten()).map((line) => indent + line),
       "}",

env-model-generator/src/env-model-generator.ts

@@ -6,7 +6,7 @@ import * as program from "commander";
 import * as fs from "fs-extra";
 import * as _ from "lodash";
 import * as pathUtils from "path";
-import { BlankLine, Braces, Class, FnCall, Null, Return } from "./JavaCode";
+import { BlankLine, Block, Class, FnCall, Method, Null, Return, Statement } from "./JavaCode";
 import * as model from "./model";
 import parseSpringXmlConfigFile from "./parse-spring-xml";
 import { createPath } from "./utils";
@@ -32,6 +32,13 @@ if (program.args.length === 0) {
   program.help();
 }
 
+enum ReturnValue {
+    Success,
+    ParseError,
+    CreateJavaError,
+    OutputFolderNotFound,
+    OutputError,
+}
 
 async function transformConfigFile(fileName: string, options: any) {
   let fileNames = [ fileName ];
@@ -41,51 +48,73 @@ async function transformConfigFile(fileName: string, options: any) {
     await parseSpringXmlConfigFile(fileNames);
   } catch (err) {
     console.error(`Error parsing config file: ${err.message}`);
-    process.exit(2);
+    process.exit(ReturnValue.ParseError);
     return;
   }
   const packageName = "org.springframework.context.support";
   let output = `package ${packageName};\n\n`;
-  const applicationContext =
-    new Class(
-      "public", "ClassPathXmlApplicationContext", undefined, [ "org.springframework.context.ApplicationContext" ],
-      [
-        new Braces(
-          "public ClassPathXmlApplicationContext(String[] args)",
-          []
-        ),
-        new Braces(
-          "public Object getBean(String name)",
-          [
-            new Braces(
-              "try",
-              model.Bean.getNamed().map((bean) =>
-                new Braces(
-                  `if (name.equals("${bean.name}"))`,
-                  [
-                    new Return(new FnCall(bean.getter, [])),
-                  ])),
-            ),
-            new Braces(
-              "catch(Exception ex)",
-              []),
-            new Return(new Null()),
-          ]
-        ),
-        new BlankLine(),
-        new BlankLine(),
-        ..._.flatMap([...model.Bean.getAll()], (bean) => bean.toJava()[0]),
-        new BlankLine(),
-        ...model.PropertiesValue.utilityMethods(),
-        ...model.BeanValue.utilityMethods(),
-      ]);
-  output += applicationContext.toString() + "\n";
+  try {
+    const applicationContext =
+      new Class(
+        "public", "ClassPathXmlApplicationContext", undefined, [ "org.springframework.context.ApplicationContext" ],
+        [
+          new Method(
+            "public ClassPathXmlApplicationContext(String[] args)",
+            []),
+          new Method(
+            "public Object getBean(String name)",
+            [
+              new Block(
+                "try",
+                (<Statement[]>[]).concat(
+                  model.Bean.getNamed().map((bean) =>
+                    new Block(
+                      `if (name.equals("${bean.name}"))`,
+                      [
+                        new Return(new FnCall(bean.getter, [])),
+                      ])),
+                  [...model.Bean.getAliases()].map(
+                    function ([ alias, beanId ]) {
+                      const bean = model.Bean.tryGet(beanId);
+                      if (bean === undefined)
+                        throw new Error("Found alias to bean that doesn't exist");
+                      return new Block(
+                        `if (name.equals("${alias}"))`,
+                        [
+                          new Return(new FnCall(bean.getter, [])),
+                        ]);
+                    }),
+                ),
+              ),
+              new Block(
+                "catch(Exception ex)",
+                []),
+              new Return(new Null()),
+            ],
+            [],
+            [ "OverlayMethodImplementation" ]
+          ),
+          new BlankLine(),
+          new BlankLine(),
+          ..._.flatMap([...model.Bean.getAll()], (bean) => bean.javaMembers),
+          new BlankLine(),
+          ...model.PropertiesValue.utilityMethods(),
+          ...model.MapValue.utilityMethods(),
+          ...model.BeanValue.utilityMethods(),
+        ],
+        [ "OverlayClassImplementation" ]);
+    output += applicationContext.toString() + "\n";
+  } catch (err) {
+    console.error(`Error converting to Java: ${err.message}`);
+    process.exit(ReturnValue.CreateJavaError);
+    return;
+  }
   // Write out the generated Java
   let outputPath = options.outputPath;
   if (outputPath) {
     if (!fs.existsSync(outputPath)) {
       console.error(`Given output folder '${outputPath}' does not exist`);
-      process.exit(5);
+      process.exit(ReturnValue.OutputFolderNotFound);
       return;
     }
     // Create folder to store it in based on the package name
@@ -94,7 +123,7 @@ async function transformConfigFile(fileName: string, options: any) {
       outputPath = createPath(appContextFolder, outputPath);
     } catch (err) {
       console.error(`Can't create output folder '${appContextFolder}': ${err.message}`);
-      process.exit(3);
+      process.exit(ReturnValue.OutputError);
       return;
     }
     // Write file
@@ -104,7 +133,7 @@ async function transformConfigFile(fileName: string, options: any) {
       console.log("Output written to %s", outputFileName);
     } catch (err) {
       console.error(`Can't write output file '${outputFileName}': ${err.message}`);
-      process.exit(4);
+      process.exit(ReturnValue.OutputError);
       return;
     }
   } else