Merge pull request diffblue#507 from diffblue/feature/bean-annotation-config

Add bean annotation config

Author: NathanJPhillips

env-model-generator/src/annotationConfig.ts

@@ -1,19 +1,43 @@
 export interface AnnotationConfig {
-    beans: Beans;
+    components: Components;
+    configurations: Configurations;
 }
 
-export interface Beans {
-    [name: string]: Bean;
+export interface Components {
+    [name: string]: Component;
 }
 
-export interface Bean {
-    fields: AnnotatedFields;
+export interface Component {
+    isLazyInit: boolean;
+    fields: AutoWiredFields;
 }
 
-export interface AnnotatedFields {
-    [name: string]: AnnotatedField;
+export interface AutoWiredFields {
+    [name: string]: AutoWiredField;
 }
 
-export interface AnnotatedField {
+export interface AutoWiredField {
     type: string;
 }
+
+export interface Configurations {
+    [name: string]: Configuration;
+}
+
+export interface Configuration {
+    beanDefinitionMethods: BeanDefinitionMethods;
+}
+
+export interface BeanDefinitionMethods {
+    [name: string]: BeanDefinitionMethod;
+}
+
+export interface BeanDefinitionMethod {
+    type: string;
+    parameterTypes: string[];
+    scope?: string;
+    isLazyInit?: boolean;
+    specifiedName?: string;
+    initMethod?: string;
+    destroyMethod?: string;
+}

env-model-generator/src/model.ts

@@ -25,12 +25,6 @@ export interface BeanProperty {
   value: Value;
 }
 
-export enum BeanCreationPolicy {
-  Singleton,
-  Lazy,
-  Keen,
-}
-
 interface Factory {
   bean: Bean;
   method: string;
@@ -40,7 +34,7 @@ export class Bean {
   private readonly isAnonymous: boolean;
   public readonly name: string;
   private readonly impl: string | Factory;
-  private readonly beanCreationPolicy: BeanCreationPolicy;
+  private readonly isLazyInit: boolean;
   private readonly constructorArgs: Value[];
   private readonly properties: NameMap<BeanProperty>;
   private readonly initMethod?: string;
@@ -50,7 +44,7 @@ export class Bean {
    * @param parent The bean given as a parent for this one
    * @param name The name of this bean
    * @param impl The name of the class to be instantiated or the details on the factory to use
-   * @param beanCreationPolicy Whether the bean is created eagerly, statically, etc
+   * @param isLazyInit Whether the bean is created lazily rather than eagerly
    * @param constructorArgs Arguments to pass to the constructor
    * @param properties Properties to set after construction
    * @param initMethod Method to call after properties are set
@@ -59,7 +53,7 @@ export class Bean {
     parent: Bean | undefined,
     name: string | undefined,
     impl: string | Factory | undefined,
-    beanCreationPolicy: BeanCreationPolicy | undefined,
+    isLazyInit: boolean,
     constructorArgs: Value[],
     properties: BeanProperty[],
     initMethod?: string)
@@ -68,15 +62,11 @@ export class Bean {
     if (parent) {
       if (impl === undefined)
         impl = parent.impl;
-      if (beanCreationPolicy === undefined)
-        beanCreationPolicy = parent.beanCreationPolicy;
       propertiesMap = parent.properties;
       if (initMethod === undefined)
         initMethod = parent.initMethod;
     }
     propertiesMap.setRange(properties);
-    if (beanCreationPolicy === undefined)
-      throw Error("beanCreationPolicy not specified when parent isn't either");
 
     if (impl === undefined)
       throw Error(`Tried to create a Bean ('${name}') without a class name or a factory bean/method`);
@@ -85,7 +75,7 @@ export class Bean {
       name = Bean.getNextAnonName(typeof impl === "string" ? impl : impl.bean.identifier + "_" + impl.method);
     this.name = name;
     this.impl = impl;
-    this.beanCreationPolicy = beanCreationPolicy;
+    this.isLazyInit = isLazyInit;
     this.constructorArgs = constructorArgs;
     this.properties = propertiesMap;
     this.initMethod = initMethod;
@@ -117,7 +107,7 @@ export class Bean {
     // In the presence of circular dependencies between mutually recursive beans this should really contain the fixed-point set of all possible
     // exceptions from all beans on the component
     this._exceptions = [];
-    const variableName = this.beanCreationPolicy === BeanCreationPolicy.Singleton ? `_${this.identifier}` : "value";
+    const variableName = !this.isLazyInit ? `_${this.identifier}` : "value";
     const [ constructorArgs, constructorArgsExceptions ] = collectionToJava(this.constructorArgs);
     const [ initialisers, initialisersExceptions ]: [ FnStatement[], string[][] ] =
       this.properties.size === 0
@@ -142,7 +132,7 @@ export class Bean {
       typeName = "Object";
       creatorFn = `${this.impl.bean.getter}().${this.impl.method}`;
     }
-    if (this.beanCreationPolicy !== BeanCreationPolicy.Singleton) {
+    if (this.isLazyInit) {
       this._javaMembers.push(new Method(
         `public static ${typeName} ${this.getter}()`,
         [

env-model-generator/src/parseJson.ts

@@ -4,12 +4,12 @@ import { ConfigParseError } from "./configParseError";
 import * as model from "./model";
 import { lowerInitialChar } from "./utils";
 
-interface BeanWithName {
+interface NamedComponent {
   qualifiedClassName: string;
-  bean: jsonConfig.Bean;
+  component: jsonConfig.Component;
 }
 
-const beansById = new Map<string, BeanWithName>();
+const beansById = new Map<string, NamedComponent>();
 
 export async function collectBeansFromConfigFile(filePath: string): Promise<string[]> {
   let json: string;
@@ -19,22 +19,22 @@ export async function collectBeansFromConfigFile(filePath: string): Promise<stri
     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))
+  for (const qualifiedClassName in annotationConfig.components) {
+    if (!annotationConfig.components.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}'`);
+      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 bean = { qualifiedClassName: qualifiedClassName, bean: annotationConfig.beans[qualifiedClassName] };
-    beansById.set(id, bean);
-    model.Bean.registerIdForClass(bean.qualifiedClassName, id);
+    const component = { qualifiedClassName: qualifiedClassName, component: annotationConfig.components[qualifiedClassName] };
+    beansById.set(id, component);
+    model.Bean.registerIdForClass(component.qualifiedClassName, id);
   }
   // TODO: Return paths to XML config files specified in code
   return [];
@@ -60,21 +60,21 @@ export function parseBean(id: string): model.Bean {
   return parseJsonBean(id, bean);
 }
 
-function parseJsonBean(id: string | undefined, namedBean: BeanWithName): model.Bean {
-  const bean = namedBean.bean;
+function parseJsonBean(id: string | undefined, namedBean: NamedComponent): model.Bean {
+  const component = namedBean.component;
   const properties: model.BeanProperty[] = [];
-  for (const fieldName in bean.fields) {
-    if (!bean.fields.hasOwnProperty(fieldName))
+  for (const fieldName in component.fields) {
+    if (!component.fields.hasOwnProperty(fieldName))
       continue;
-    const fieldClass = bean.fields[fieldName].type;
+    const fieldClass = component.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}' `
+        `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) });
   }
   // TODO: Handle constructor arguments
-  return new model.Bean(undefined, id, namedBean.qualifiedClassName, model.BeanCreationPolicy.Singleton, [], properties);
+  return new model.Bean(undefined, id, namedBean.qualifiedClassName, false, [], properties);
 }

env-model-generator/src/parseSpringXml.ts

@@ -106,10 +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 creationPolicy =
-    bean.scope === "prototype"
-      ? bean.lazyInit === "true" ? model.BeanCreationPolicy.Lazy : model.BeanCreationPolicy.Keen
-      : model.BeanCreationPolicy.Singleton;
+  const isLazyInit = bean.scope !== undefined && bean.scope !== "prototype" || 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 ]));
@@ -127,7 +124,7 @@ function parseXmlBean(id: string | undefined, bean: spring.BeanType): model.Bean
     impl = { bean: factoryBean, method: bean.factoryMethod };
   else
     impl = bean.class;
-  return new model.Bean(parent, id, impl, creationPolicy, constructorArgs, properties, bean.initMethod);
+  return new model.Bean(parent, id, impl, isLazyInit, constructorArgs, properties, bean.initMethod);
 }
 
 function parseProperty(property: any): model.Value {