Merge pull request diffblue#566 from diffblue/bugfix/java-code-block

NathanJPhillips · web-flow · commit 30ef0db3c15e · 2018-08-28T14:28:09.000+01:00
Fix bug in Block
diff --git a/env-model-generator/src/env-model-generator.ts b/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, Block, Class, FnCall, Method, Null, Return, Statement } from "./javaCode";
+import { BlankLine, CatchBlock, Class, FnCall, IfThenElse, Method, Null, Return, Statement, StringConstant, TryCatch } from "./javaCode";
 import * as model from "./model";
 import parseSpringConfigFiles from "./parserDriver";
 import { createPath } from "./utils";
@@ -64,14 +64,13 @@ async function transformConfigFiles(fileName: string, options: any) {
           new Method(
             "public Object getBean(String name)",
             [
-              new Block(
-                "try",
+              new TryCatch(
                 (<Statement[]>[]).concat(
                   model.Repository.getNamed()
                     .sort((a, b) => a.name < b.name ? -1 : a.name === b.name ? 0 : 1)
                     .map((bean) =>
-                      new Block(
-                        `if (name.equals("${bean.name}"))`,
+                      new IfThenElse(
+                        new FnCall("name.equals", [ new StringConstant(bean.name) ]),
                         [
                           new Return(new FnCall(bean.getter, [])),
                         ])),
@@ -80,17 +79,14 @@ async function transformConfigFiles(fileName: string, options: any) {
                       const bean = model.Repository.tryGet(beanId);
                       if (bean === undefined)
                         throw new Error("Found alias to bean that doesn't exist");
-                      return new Block(
-                        `if (name.equals("${alias}"))`,
+                      return new IfThenElse(
+                        new FnCall("name.equals", [ new StringConstant(alias) ]),
                         [
                           new Return(new FnCall(bean.getter, [])),
                         ]);
                     }),
                 ),
-              ),
-              new Block(
-                "catch(Exception ex)",
-                []),
+                [ new CatchBlock("Exception") ]),
               new Return(new Null()),
             ],
             [],
diff --git a/env-model-generator/src/javaCode.ts b/env-model-generator/src/javaCode.ts
@@ -58,6 +58,55 @@ export class FnCall extends CodeElement implements Expression {
   }
 }
 
+export class BinaryOperator extends CodeElement implements Expression {
+  public isExpression: true = true;
+
+  private lhs: Expression;
+  private operatorName: string;
+  private rhs: Expression;
+
+  public constructor(lhs: Expression, operatorName: string, rhs: Expression) {
+    super();
+    this.lhs = lhs;
+    this.operatorName = operatorName;
+    this.rhs = rhs;
+  }
+
+  public flatten(): string[] {
+    const lhsInLines = this.lhs.flatten();
+    const rhsInLines = this.rhs.flatten();
+    if (lhsInLines.length === 1 && rhsInLines.length === 1) {
+      const oneLine = `${lhsInLines[0]} ${this.operatorName} ${rhsInLines[0]}`;
+      if (oneLine.length < maxLineLength) {
+        return [ oneLine ];
+      }
+    }
+    if (lhsInLines.length === 1) {
+      const firstLine = `${lhsInLines[0]} ${this.operatorName}`;
+      if (firstLine.length < maxLineLength) {
+        return [
+          firstLine,
+          ...rhsInLines.map(indent),
+        ];
+      }
+    }
+    if (rhsInLines.length === 1) {
+      const lastLine = indent(`${this.operatorName} ${rhsInLines[0]}`);
+      if (lastLine.length < maxLineLength) {
+        return [
+          ...lhsInLines,
+          lastLine,
+        ];
+      }
+    }
+    return [
+      ...lhsInLines,
+      this.operatorName,
+      ...rhsInLines.map(indent),
+    ];
+  }
+}
+
 export class BraceInitialiser extends CodeElement implements Expression {
   public isExpression: true = true;
 
@@ -254,7 +303,7 @@ class Braces extends CodeElement {
   public flatten(): string[] {
     return [
       this.intro ? this.intro + " {" : "{",
-      ..._.flatMap(this.body, (block) => block.flatten()).map(indent),
+      ..._.flatMap(this.body, (stmt) => stmt.flatten()).map(indent),
       "}",
     ];
   }
@@ -286,6 +335,168 @@ export class Method extends Braces implements Member {
   }
 }
 
+export class CatchBlock {
+  private exceptionType: string;
+  private body: Statement[];
+  private exceptionName: string;
+
+  public constructor(exceptionType: string, body: Statement[] = [], exceptionName: string = "ex") {
+    this.exceptionType = exceptionType;
+    this.body = body;
+    this.exceptionName = exceptionName;
+  }
+
+  public flatten(): string[] {
+    return [
+      `} catch (${this.exceptionType} ${this.exceptionName}) {`,
+      ..._.flatMap(this.body, (stmt) => stmt.flatten()),
+    ];
+  }
+}
+
+export class TryCatch extends CodeElement implements Statement {
+  public isStatement: true = true;
+
+  private tryBody: Statement[];
+  private catchBlocks: CatchBlock[];
+  private finallyBody?: Statement[];
+
+  public constructor(tryBody: Statement[] = [], catchBlocks: CatchBlock[] = [], finallyBody?: Statement[]) {
+    super();
+    this.tryBody = tryBody;
+    this.catchBlocks = catchBlocks;
+    this.finallyBody = finallyBody;
+  }
+
+  private getFinallyLines(): string[] {
+    if (this.finallyBody === undefined) {
+      return [];
+    }
+    return [
+      "} finally {",
+      ..._.flatMap(this.finallyBody, (stmt) => stmt.flatten()),
+    ];
+  }
+
+  public flatten(): string[] {
+    return [
+      "try {",
+      ..._.flatMap(this.tryBody, (stmt) => stmt.flatten()).map(indent),
+      ..._.flatMap(this.catchBlocks, (catchBlock) => catchBlock.flatten()),
+      ...this.getFinallyLines(),
+      "}",
+    ];
+  }
+}
+
+export class IfThenElse extends CodeElement implements Statement {
+  public isStatement: true = true;
+
+  private guard: Expression;
+  private thenBlock: Statement[];
+  private elseBlock?: Statement[];
+
+  public constructor(guard: Expression, thenBlock: Statement[], elseBlock?: Statement[]) {
+    super();
+    this.guard = guard;
+    this.thenBlock = thenBlock;
+    this.elseBlock = elseBlock;
+  }
+
+  private getGuardLines(): string[] {
+    const guardInLines = this.guard.flatten();
+    if (guardInLines.length === 1) {
+      const oneLine = `if (${guardInLines[0]}) {`;
+      if (oneLine.length < maxLineLength)
+        return [ oneLine ];
+    }
+    guardInLines[guardInLines.length - 1] += ")";
+    return [
+      "if (",
+      ...guardInLines.map(indent),
+      "{",
+    ];
+  }
+
+  public flatten(): string[] {
+    const thenLines = _.flatMap(this.thenBlock, (stmt) => stmt.flatten()).map(indent);
+    if (this.elseBlock === undefined) {
+      return [
+        ...this.getGuardLines(),
+        ...thenLines,
+        "}",
+      ];
+    } else {
+      return [
+        ...this.getGuardLines(),
+        ...thenLines,
+        "} else {",
+        ..._.flatMap(this.elseBlock, (stmt) => stmt.flatten()).map(indent),
+        "}",
+      ];
+    }
+  }
+}
+
+export class RangedFor extends CodeElement implements Statement {
+  public isStatement: true = true;
+
+  private modifiedType: string;
+  private rangeVariableName: string;
+  private collection: Expression;
+  private body: Statement[];
+
+  public constructor(modifiedType: string, rangeVariableName: string, collection: Expression, body: Statement[]) {
+    super();
+    this.modifiedType = modifiedType;
+    this.rangeVariableName = rangeVariableName;
+    this.collection = collection;
+    this.body = body;
+  }
+
+  private getForLines(): string[] {
+    const collectionInLines = this.collection.flatten();
+    if (collectionInLines.length === 1) {
+      const oneLine = `for (${this.modifiedType} ${this.rangeVariableName} : ${collectionInLines[0]}) {`;
+      if (oneLine.length < maxLineLength)
+        return [ oneLine ];
+    }
+    collectionInLines[collectionInLines.length - 1] += ")";
+    const forLine = `for (${this.modifiedType} ${this.rangeVariableName} :`;
+    if (forLine.length < maxLineLength) {
+      return [
+        forLine,
+        ...collectionInLines.map(indent),
+        "{",
+      ];
+    }
+    const rangeVariableLine = indent(`${this.modifiedType} ${this.rangeVariableName} :`);
+    if (rangeVariableLine.length < maxLineLength) {
+      return [
+        "for (",
+        rangeVariableLine,
+        ...collectionInLines.map(indent),
+        "{",
+      ];
+    }
+    return [
+      "for (",
+      indent(this.modifiedType),
+      indent(indent(`${this.rangeVariableName} :`)),
+      ...collectionInLines.map(indent),
+      "{",
+    ];
+  }
+
+  public flatten(): string[] {
+    return [
+      ...this.getForLines(),
+      ..._.flatMap(this.body, (stmt) => stmt.flatten()).map(indent),
+      "}",
+    ];
+  }
+}
+
 export class Class extends CodeElement {
   private modifiers: string;
   private name: string;
diff --git a/env-model-generator/src/model.ts b/env-model-generator/src/model.ts
@@ -2,16 +2,18 @@ import * as _ from "lodash";
 import { ConfigParseError } from "./configParseError";
 import {
   Assignment,
+  BinaryOperator,
   BlankLine,
-  Block,
   BraceInitialiser,
   Declaration,
   Expression,
   FnCall,
   FnStatement,
+  IfThenElse,
   Member,
   Method,
   Null,
+  RangedFor,
   Return,
   Statement,
   StringConstant,
@@ -190,8 +192,8 @@ export class Bean implements IBean {
       this._javaMembers.push(new Method(
         `public static ${typeName} ${this.getter}()`,
         [
-          new Block(
-            `if (${variableName} == null)`,
+          new IfThenElse(
+            new BinaryOperator(new Symbol(variableName), "==", new Null()),
             [
               new Assignment(variableName, new FnCall(creatorFn, constructorArgs)),
               ...initialisers,
@@ -432,8 +434,10 @@ export class PropertiesValue extends Value {
         "public static java.util.Properties listToProperties(java.util.List<java.util.AbstractMap.SimpleEntry<String, String>> properties)",
         [
           new Declaration("java.util.Properties", "result", new FnCall("new java.util.Properties", [])),
-          new Block(
-            "for (java.util.AbstractMap.SimpleEntry<String, String> prop : properties)",
+          new RangedFor(
+            "java.util.AbstractMap.SimpleEntry<String, String>",
+            "prop",
+            new Symbol("properties"),
             [
               new FnStatement(new FnCall("result.put", [ new FnCall("prop.getKey", []), new FnCall("prop.getValue", []) ])),
             ]),
@@ -481,8 +485,10 @@ export class MapValue extends Value {
         "public static java.util.Map<String, String> listToMap(java.util.List<java.util.AbstractMap.SimpleEntry<String, String>> entries)",
         [
           new Declaration("java.util.Map<String, String>", "result", new FnCall("new java.util.HashMap<String, String>", [])),
-          new Block(
-            "for (java.util.AbstractMap.SimpleEntry<String, String> entry : entries)",
+          new RangedFor(
+            "java.util.AbstractMap.SimpleEntry<String, String>",
+            "entry",
+            new Symbol("entries"),
             [
               new FnStatement(new FnCall("result.put", [ new FnCall("entry.getKey", []), new FnCall("entry.getValue", []) ])),
             ]),
