Merge pull request diffblue#500 from diffblue/feature/annotation-driven-ai

Annotation driven DI [SEC-556]

Author: NathanJPhillips

env-model-generator/src/AnnotationConfig.ts renamed to env-model-generator/src/annotationConfig.ts

@@ -16,4 +16,4 @@ export interface AnnotatedFields {
 
 export interface AnnotatedField {
     type: string;
-}
+}

env-model-generator/src/ConfigParseError.ts renamed to env-model-generator/src/configParseError.ts

@@ -6,9 +6,9 @@ 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, Block, Class, FnCall, Method, Null, Return, Statement } from "./javaCode";
 import * as model from "./model";
-import parseSpringXmlConfigFile from "./parse-spring-xml";
+import parseSpringConfigFiles from "./parserDriver";
 import { createPath } from "./utils";
 
 function collectOption(value: string, collection?: string[]) {
@@ -24,7 +24,7 @@ program
   .option("-i --input-file <path>", "Additional DI configuration file to read", collectOption)
   .option("-o --output-path <output-path>", "Path to write output under")
   .description("Create code from DI configuration")
-  .action(transformConfigFile);
+  .action(transformConfigFiles);
 program.parse(process.argv);
 
 // If program was called with no arguments then show help.
@@ -40,12 +40,12 @@ enum ReturnValue {
     OutputError,
 }
 
-async function transformConfigFile(fileName: string, options: any) {
+async function transformConfigFiles(fileName: string, options: any) {
   let fileNames = [ fileName ];
   if (options.inputFile)
   fileNames = fileNames.concat(options.inputFile);
   try {
-    await parseSpringXmlConfigFile(fileNames);
+    await parseSpringConfigFiles(fileNames);
   } catch (err) {
     console.error(`Error parsing config file: ${err.message}`);
     process.exit(ReturnValue.ParseError);

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

@@ -0,0 +1,22 @@
+export default class MapTrackingDuplicates<K, V>
+{
+  private _map = new Map<K, V | null>();
+
+  public has(key: K): boolean {
+    const value = this._map.get(key);
+    return value !== undefined && value !== null;
+  }
+
+  public hasDuplicates(key: K): boolean {
+    return this._map.get(key) === null;
+  }
+
+  public get(key: K): V | undefined {
+    const value = this._map.get(key);
+    return value === null ? undefined : value;
+  }
+
+  public set(key: K, value: V): void {
+    this._map.set(key, this._map.has(key) ? null : value);
+  }
+}

env-model-generator/src/JavaCode.ts renamed to env-model-generator/src/javaCode.ts

@@ -1,5 +1,5 @@
 import * as _ from "lodash";
-import { ConfigParseError } from "./ConfigParseError";
+import { ConfigParseError } from "./configParseError";
 import {
   Assignment,
   BlankLine,
@@ -15,11 +15,12 @@ import {
   Return,
   StringConstant,
   Symbol,
-} from "./JavaCode";
-import NameMap from "./NameMap";
+} from "./javaCode";
+import MapTrackingDuplicates from "./mapTrackingDuplicates";
+import NameMap from "./nameMap";
 import { makeIdentifier, upperInitialChar } from "./utils";
 
-interface BeanProperty {
+export interface BeanProperty {
   name: string;
   value: Value;
 }
@@ -214,7 +215,7 @@ export class Bean {
     Bean.aliases.set(alias, beanId);
   }
 
-  public static checkAliases(beans: Map<string, any>): void {
+  public static checkAliases(beanWithIdExists: (beanId: string) => boolean): void {
     // If A -> B is added before B -> C then A -> B needs updating to A -> C now
     const aliases = new Map<string, string>();
     for (const [ alias, target ] of Bean.aliases) {
@@ -227,7 +228,7 @@ export class Bean {
         if (beanId === alias)
           throw new ConfigParseError(`Found circular alias from '${alias}'`);
       }
-      if (beans.has(beanId) === undefined)
+      if (!beanWithIdExists(beanId))
         throw new ConfigParseError(`Couldn't find bean '${beanId}' aliased from '${alias}'`);
       aliases.set(alias, beanId);
     }
@@ -237,6 +238,20 @@ export class Bean {
   public static getAliases(): Iterable<[ string, string ]> {
     return Bean.aliases;
   }
+
+  private static beanIdByClass = new MapTrackingDuplicates<string, string>();
+
+  public static registerIdForClass(qualifiedClassName: string, beanId: string) {
+    Bean.beanIdByClass.set(qualifiedClassName, beanId);
+  }
+
+  public static tryGetIdByClass(qualifiedClassName: string): string | undefined {
+    return Bean.beanIdByClass.get(qualifiedClassName);
+  }
+
+  public static hasMultipleBeansForClass(qualifiedClassName: string): boolean {
+    return Bean.beanIdByClass.hasDuplicates(qualifiedClassName);
+  }
 }
 
 export abstract class Value {

env-model-generator/src/mapTrackingDuplicates.ts

@@ -0,0 +1,80 @@
+import * as fs from "fs-extra";
+import * as jsonConfig from "./annotationConfig";
+import { ConfigParseError } from "./configParseError";
+import * as model from "./model";
+import { lowerInitialChar } from "./utils";
+
+interface BeanWithName {
+  qualifiedClassName: string;
+  bean: jsonConfig.Bean;
+}
+
+const beansById = new Map<string, BeanWithName>();
+
+export async function collectBeansFromConfigFile(filePath: string): Promise<string[]> {
+  let json: string;
+  try {
+    json = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    throw new ConfigParseError(`Can't open input file '${filePath}': ${err.message}`);
+  }
+  const annotationConfig: jsonConfig.AnnotationConfig = JSON.parse(json);
+  for (const qualifiedClassName in annotationConfig.beans) {
+    if (!annotationConfig.beans.hasOwnProperty(qualifiedClassName))
+      continue;
+    // Create bean ID
+    // TODO: Handle name parameter to @Component constructor
+    const id = lowerInitialChar(<string>qualifiedClassName.split(".").pop());
+    // Check for duplicate ids from other beans
+    if (beansById.has(id))
+      throw new ConfigParseError(`Found multiple beans with id '${id}'`);
+    const aliasedBeanId = model.Bean.getAlias(id);
+    if (aliasedBeanId !== undefined)
+      throw new ConfigParseError(`Found a bean with id same as an alias for '${aliasedBeanId}'`);
+    // Create a bean model for the bean
+    const bean = { qualifiedClassName: qualifiedClassName, bean: annotationConfig.beans[qualifiedClassName] };
+    beansById.set(id, bean);
+    model.Bean.registerIdForClass(bean.qualifiedClassName, id);
+  }
+  // TODO: Return paths to XML config files specified in code
+  return [];
+}
+
+export function beanWithIdExists(id: string): boolean {
+  return beansById.has(id);
+}
+
+export function parseAllBeans(): void {
+  for (const [ beanId, bean ] of beansById) {
+    if (model.Bean.tryGet(beanId) !== undefined)
+      continue;
+    // We don't store the results of this parsing, it is stored in internal data structures which do enough for us
+    parseJsonBean(beanId, bean);
+  }
+}
+
+export function parseBean(id: string): model.Bean {
+  const bean = beansById.get(id);
+  if (bean === undefined)
+    throw new Error("Called parseBean on a bean that did not exist");
+  return parseJsonBean(id, bean);
+}
+
+function parseJsonBean(id: string | undefined, namedBean: BeanWithName): model.Bean {
+  const bean = namedBean.bean;
+  const properties: model.BeanProperty[] = [];
+  for (const fieldName in bean.fields) {
+    if (!bean.fields.hasOwnProperty(fieldName))
+      continue;
+    const fieldClass = bean.fields[fieldName].type;
+
+    const fieldBeanId = model.Bean.tryGetIdByClass(fieldClass);
+    if (fieldBeanId === undefined)
+      throw new ConfigParseError(
+        `Autowired field '${namedBean.qualifiedClassName}.${fieldName}' depends on a class '${fieldClass}' `
+          + `that has ${model.Bean.hasMultipleBeansForClass(fieldClass) ? "multiple" : "no"} implementations`);
+    properties.push({ name: fieldName, value: new model.BeanRefValue(fieldBeanId) });
+  }
+  // TODO: Handle constructor arguments
+  return new model.Bean(undefined, id, namedBean.qualifiedClassName, model.BeanCreationPolicy.Singleton, [], properties);
+}