Merge pull request diffblue#510 from diffblue/feature/di-bean-annotations

DI bean annotations [SEC-545]

Author: NathanJPhillips

env-model-generator/package.json

@@ -16,6 +16,7 @@
     "build": "tsc",
     "lint": "tslint src/**/*.ts",
     "fix-lint": "tslint src/**/*.ts --fix",
+    "gen-docs": "typedoc --out doc",
     "start": "node built/env-model-generator.js ../benchmarks/GENUINE/sakai/edu-services/cm-service/cm-impl/hibernate-impl/impl/src/test/spring-test.xml --outputPath output"
   },
   "dependencies": {
@@ -27,11 +28,12 @@
   },
   "devDependencies": {
     "@types/fs-extra": "5.0.0",
-    "@types/lodash": "4.14.68",
+    "@types/lodash": "^4.14.115",
     "@types/node": "8.0.47",
     "@types/xml2js": "0.4.2",
     "tslint": "5.4.2",
     "tslint-language-service": "0.9.6",
+    "typedoc": "^0.11.1",
     "typescript": "2.4.1"
   }
 }

env-model-generator/src/parseJson.ts

@@ -2,15 +2,38 @@ import * as fs from "fs-extra";
 import * as jsonConfig from "./annotationConfig";
 import { ConfigParseError } from "./configParseError";
 import * as model from "./model";
+import { getBeanById } from "./parserDriver";
 import { lowerInitialChar } from "./utils";
 
 interface NamedComponent {
   qualifiedClassName: string;
   component: jsonConfig.Component;
 }
 
-const beansById = new Map<string, NamedComponent>();
+/**
+ * [[BeanDefinitionMethod]] does not include the name of the method or the name of the class it is defined in; these are provided by the context.
+ *
+ * This class therefore combines these bits of information to act as the value to be used in a map from calculated identifiers to bean definition
+ * methods.
+ */
+interface NamedBeanDefinitionMethod {
+  className: string;
+  name: string;
+  method: jsonConfig.BeanDefinitionMethod;
+}
+
+// A map from identifiers to components discovered in the JSON file.
+const componentsById = new Map<string, NamedComponent>();
+// A map from identifiers to bean definition methods discovered in the JSON file.
+const beansById = new Map<string, NamedBeanDefinitionMethod>();
 
+/**
+ * Collect beans from the JSON configuration file without parsing them.
+ *
+ * This allows us to set up objects that can be used to resolve circular references discovered later during parsing.
+ * @param filePath  The path to the configuration file to read the input from
+ * @returns         Paths to other config files to also include
+ */
 export async function collectBeansFromConfigFile(filePath: string): Promise<string[]> {
   let json: string;
   try {
@@ -22,59 +45,145 @@ export async function collectBeansFromConfigFile(filePath: string): Promise<stri
   for (const qualifiedClassName in annotationConfig.components) {
     if (!annotationConfig.components.hasOwnProperty(qualifiedClassName))
       continue;
-    // Create bean ID
-    // TODO: Handle name parameter to @Component constructor
+    // TODO: Handle name value on @Component annotation
     const id = lowerInitialChar(<string>qualifiedClassName.split(".").pop());
-    // Check for duplicate ids from other beans
-    if (beansById.has(id))
-      throw new ConfigParseError(`Found multiple components 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 component = { qualifiedClassName: qualifiedClassName, component: annotationConfig.components[qualifiedClassName] };
-    beansById.set(id, component);
-    model.Bean.registerIdForClass(component.qualifiedClassName, id);
+    checkBeanId(id, `@Component annotation on class '${qualifiedClassName}'`);
+    componentsById.set(id, { qualifiedClassName: qualifiedClassName, component: annotationConfig.components[qualifiedClassName] });
+    model.Bean.registerIdForClass(qualifiedClassName, id);
+  }
+  for (const configurationClassName in annotationConfig.configurations) {
+    if (!annotationConfig.configurations.hasOwnProperty(configurationClassName))
+      continue;
+    const beanDefinitionMethods = annotationConfig.configurations[configurationClassName].beanDefinitionMethods;
+    for (const beanDefinitionMethodName in beanDefinitionMethods) {
+      if (!beanDefinitionMethods.hasOwnProperty(beanDefinitionMethodName))
+        continue;
+      const beanDefinitionMethod = beanDefinitionMethods[beanDefinitionMethodName];
+      let id = beanDefinitionMethodName;
+      if (beanDefinitionMethod.specifiedNames !== undefined && beanDefinitionMethod.specifiedNames.length !== 0) {
+        id = beanDefinitionMethod.specifiedNames[0];
+        // Add aliases
+        for (let i = 1; i < beanDefinitionMethod.specifiedNames.length; ++i)
+          model.Bean.addAlias(beanDefinitionMethod.specifiedNames[i], id);
+      }
+      checkBeanId(id, `@Bean annotation on '${configurationClassName}.${beanDefinitionMethodName}'`);
+      beansById.set(id, { className: configurationClassName, name: configurationClassName, method: beanDefinitionMethod });
+      model.Bean.registerIdForClass(beanDefinitionMethod.type, id);
+    }
   }
   // TODO: Return paths to XML config files specified in code
   return [];
 }
 
+/**
+ * Check for duplicate ids from other beans or aliases
+ * @param id                The bean identifier to check
+ * @param location          The location to include in the text of any thrown exception
+ * @throws [[ConfigParseError]] If the bean identifier has already been used
+ */
+function checkBeanId(id: string, location: string): void {
+  if (componentsById.has(id))
+    throw new ConfigParseError(`${location}: There is an existing component with id '${id}'`);
+  if (beansById.has(id))
+    throw new ConfigParseError(`${location}: There is an existing bean with id '${id}'`);
+  const aliasedBeanId = model.Bean.getAlias(id);
+  if (aliasedBeanId !== undefined)
+    throw new ConfigParseError(`${location}: There is an existing alias with identifier '${aliasedBeanId}'`);
+}
+
+/**
+ * Check whether a bean identifier is already implemented by an element from the JSON configuration
+ * @param id  The bean identifier to check
+ * @returns   True if the bean identifier is already registered
+ */
 export function beanWithIdExists(id: string): boolean {
-  return beansById.has(id);
+  return componentsById.has(id) || beansById.has(id);
 }
 
+/**
+ * Create the model for each bean discovered during the execution of [[collectBeansFromConfigFile]]
+ */
 export function parseAllBeans(): void {
-  for (const [ beanId, bean ] of beansById) {
+  for (const [ beanId, component ] of componentsById) {
+    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
+    parseJsonComponent(beanId, component);
+  }
+  for (const [ beanId, namedMethod ] 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);
+    parseJsonBean(beanId, namedMethod);
   }
 }
 
+/**
+ * Create the model for a bean with the given identifier
+ * @param id The identifier of a bean implemented by a component or bean definition method
+ * @returns         The model for the bean
+ */
 export function parseBean(id: string): model.Bean {
+  const component = componentsById.get(id);
+  if (component !== undefined)
+    return parseJsonComponent(id, component);
   const bean = beansById.get(id);
-  if (bean === undefined)
-    throw new Error("Called parseBean on a bean that did not exist");
-  return parseJsonBean(id, bean);
+  if (bean !== undefined)
+    return parseJsonBean(id, bean);
+  throw new Error("Called parseBean on a bean that did not exist");
 }
 
-function parseJsonBean(id: string | undefined, namedBean: NamedComponent): model.Bean {
+/**
+ * Create the model for a bean with the given identifier defined by a component from the JSON configuration file
+ * @param id        The identifier of a bean implemented by a component
+ * @param namedBean The component definition from the JSON configuration file
+ * @returns         The model for the bean
+ */
+function parseJsonComponent(id: string, namedBean: NamedComponent): model.Bean {
   const component = namedBean.component;
   const properties: model.BeanProperty[] = [];
   for (const fieldName in component.fields) {
     if (!component.fields.hasOwnProperty(fieldName))
       continue;
-    const fieldClass = component.fields[fieldName].type;
-
-    const fieldBeanId = model.Bean.tryGetIdByClass(fieldClass);
-    if (fieldBeanId === undefined)
-      throw new ConfigParseError(
-        `Auto-wired 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) });
+    properties.push({
+      name: fieldName,
+      value: getBeanForClass(component.fields[fieldName].type, `Auto-wired field '${namedBean.qualifiedClassName}.${fieldName}'`),
+    });
   }
   // TODO: Handle constructor arguments
   return new model.Bean(undefined, id, namedBean.qualifiedClassName, false, [], properties);
 }
+
+/**
+ * Create the model for a bean with the given identifier defined by a component from the JSON configuration file
+ * @param id          The identifier of a bean implemented by a bean definition method
+ * @param namedMethod The bean definition method definition from the JSON configuration file
+ * @returns           The model for the bean
+ */
+function parseJsonBean(id: string, namedMethod: NamedBeanDefinitionMethod): model.Bean {
+  const fieldBeanId = model.Bean.tryGetIdByClass(namedMethod.className);
+  if (fieldBeanId === undefined)
+    throw new ConfigParseError(
+      `Factory method '${namedMethod.name}' is defined in a class '${namedMethod.className}' `
+        + `that has ${model.Bean.hasMultipleBeansForClass(namedMethod.className) ? "multiple" : "no"} implementations`);
+  const factoryBean = getBeanById(fieldBeanId);
+  if (factoryBean === undefined)
+    throw new ConfigParseError(
+      `Couldn't find bean '${namedMethod.className}' that is configuration containing factory method '${namedMethod.name}'`);
+  const method = namedMethod.method;
+  const argumentValues: model.Value[] = [];
+  for (const parameterType of method.parameterTypes) {
+    argumentValues.push(getBeanForClass(parameterType, `Parameter to factory method '${namedMethod.className}.${namedMethod.name}'`));
+  }
+  const isLazyInit = method.scope !== undefined && method.scope !== "singleton" || method.isLazyInit === true;
+  return new model.Bean(undefined, id, { bean: factoryBean, method: namedMethod.name }, isLazyInit, argumentValues, []);
+}
+
+function getBeanForClass(className: string, userString: string): model.BeanRefValue {
+  const fieldBeanId = model.Bean.tryGetIdByClass(className);
+  if (fieldBeanId === undefined)
+    throw new ConfigParseError(
+      `${userString} depends on a class '${className}' `
+        + `that has ${model.Bean.hasMultipleBeansForClass(className) ? "multiple" : "no"} implementations`);
+  return new model.BeanRefValue(fieldBeanId);
+}

env-model-generator/src/parseSpringXml.ts

@@ -106,7 +106,7 @@ function parseXmlBean(id: string | undefined, bean: spring.BeanType): model.Bean
       throw new ConfigParseError(
         `Couldn't find bean '${bean.factoryBean}' specified as factoryBean of ${id === undefined ? "anonymous bean" : `'${id}'`}`);
   }
-  const isLazyInit = bean.scope !== undefined && bean.scope !== "prototype" || bean.lazyInit === "true";
+  const isLazyInit = bean.scope !== undefined && bean.scope !== "singleton" || bean.lazyInit === "true";
   // For each constructor argument parse the index and create a map from index to the whole argument object
   const constructorArgMap =
     new Map((bean.constructorArg || []).map((arg) => [ parseInt(arg.index, 10), arg ] as [ number, spring.ConstructorArgType ]));