#46 - ENH: Add support for request scoped @Inject for Javalin Context and Helidon ServerRequest and ServerResponse.

Author: rbygrave

dinject-generator/src/main/java/io/dinject/generator/Append.java

@@ -9,6 +9,8 @@
 class Append {
 
   private final Writer writer;
+  private int nameIndex;
+  private boolean comma;
 
   Append(Writer writer) {
     this.writer = writer;
@@ -48,4 +50,21 @@ Append append(String format, Object... args) {
     return append(String.format(format, args));
   }
 
+  void resetNextName() {
+    nameIndex = 0;
+    comma = false;
+  }
+
+  String nextName(String prefix) {
+    return prefix + nameIndex++;
+  }
+
+  void commaAppend(String name) {
+    if (!comma) {
+      comma = true;
+    } else {
+      append(", ");
+    }
+    append(name);
+  }
 }

dinject-generator/src/main/java/io/dinject/generator/BeanReader.java

@@ -51,6 +51,8 @@ class BeanReader {
 
   private final Set<String> importTypes = new TreeSet<>();
 
+  private final BeanRequestParams requestParams;
+
   private MethodReader constructor;
 
   private String registrationTypes;
@@ -69,11 +71,16 @@ class BeanReader {
     this.type = beanType.getQualifiedName().toString();
     this.shortName = beanType.getSimpleName().toString();
     this.context = context;
+    this.requestParams = new BeanRequestParams(type);
     init();
   }
 
-  private void init() {
+  @Override
+  public String toString() {
+    return beanType.toString();
+  }
 
+  private void init() {
     StringBuilder sb = new StringBuilder();
 
     for (TypeMirror anInterface : beanType.getInterfaces()) {
@@ -138,7 +145,6 @@ List<FieldReader> getInjectFields() {
   }
 
   void read(boolean factory) {
-
     for (Element element : beanType.getEnclosedElements()) {
       ElementKind kind = element.getKind();
       switch (kind) {
@@ -156,6 +162,10 @@ void read(boolean factory) {
     constructor = findConstructor();
     if (constructor != null) {
       constructor.addImports(importTypes);
+      constructor.checkRequest(requestParams);
+    }
+    for (FieldReader fields : injectFields) {
+      fields.checkRequest(requestParams);
     }
     for (MethodReader factoryMethod : factoryMethods) {
       factoryMethod.addImports(importTypes);
@@ -173,7 +183,6 @@ private MethodReader findConstructor() {
   }
 
   List<String> getDependsOn() {
-
     List<String> list = new ArrayList<>();
     if (constructor != null) {
       for (MethodReader.MethodParam param : constructor.getParams()) {
@@ -346,6 +355,7 @@ private Set<String> importTypes() {
     if (Util.notVoid(type)) {
       importTypes.add(type);
     }
+    requestParams.addImports(importTypes);
     return importTypes;
   }
 
@@ -370,4 +380,49 @@ void setWrittenToFile() {
     this.writtenToFile = true;
   }
 
+  /**
+   * Return true if the bean has a dependency which is a request scoped type.
+   * Like Javalin Context, Helidon request and response types.
+   * <p>
+   * If request scoped then generate a BeanFactory instead.
+   */
+  boolean isRequestScoped() {
+    return requestParams.isRequestScoped();
+  }
+
+  String suffix() {
+    return isRequestScoped() ? "$factory" : "$di";
+  }
+
+  /**
+   * Add interface for this as a BeanFactory (request scoped).
+   */
+  void factoryInterface(Append writer) {
+    requestParams.factoryInterface(writer);
+  }
+
+  /**
+   * Generate the BeanFactory dependencies and create method implementation.
+   */
+  void writeRequestCreate(Append writer) {
+    if (constructor != null) {
+      constructor.writeRequestDependency(writer);
+    }
+    for (FieldReader field : injectFields) {
+      field.writeRequestDependency(writer);
+    }
+    requestParams.writeRequestCreate(writer);
+    writer.resetNextName();
+    writer.append("    %s bean = new %s(", shortName, shortName);
+    if (constructor != null) {
+      constructor.writeRequestConstructor(writer);
+    }
+    writer.append(");").eol();
+    for (FieldReader field : injectFields) {
+      field.writeRequestInject(writer);
+    }
+    writer.append("    return bean;").eol();
+    writer.append("  }").eol();
+  }
+
 }

dinject-generator/src/main/java/io/dinject/generator/BeanRequestParams.java

@@ -0,0 +1,65 @@
+package io.dinject.generator;
+
+import java.util.Set;
+
+/**
+ * Holds detection and details of request scoped dependencies.
+ */
+class BeanRequestParams {
+
+  private final String parentType;
+
+  private RequestScope.Handler reqScopeHandler;
+
+  BeanRequestParams(String parentType) {
+    this.parentType = parentType;
+  }
+
+  /**
+   * Return true if this type is a request scoped type (e.g. Javalin Context).
+   */
+  boolean check(String paramType) {
+    if (paramType != null && RequestScope.check(paramType)) {
+      if (reqScopeHandler == null) {
+        reqScopeHandler = RequestScope.handler(paramType);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Return true if the bean has request scoped dependencies.
+   */
+  boolean isRequestScoped() {
+    return reqScopeHandler != null;
+  }
+
+  void factoryInterface(Append writer) {
+    reqScopeHandler.factoryInterface(writer, nm(parentType));
+  }
+
+  void addImports(Set<String> importTypes) {
+    if (reqScopeHandler != null) {
+      importTypes.add(Constants.SINGLETON);
+      importTypes.add(Constants.INJECT);
+      reqScopeHandler.addImports(importTypes);
+    }
+  }
+
+  void writeRequestCreate(Append writer) {
+    writer.append("  @Override").eol();
+    reqScopeHandler.writeCreateMethod(writer, nm(parentType));
+  }
+
+  /**
+   * Return the argument name based on the parameter type.
+   */
+  String argumentName(String paramType) {
+    return reqScopeHandler.argumentName(paramType);
+  }
+
+  private String nm(String raw) {
+    return Util.shortName(raw);
+  }
+}

dinject-generator/src/main/java/io/dinject/generator/Constants.java

@@ -12,11 +12,16 @@ class Constants {
   static final String PATH = "io.dinject.controller.Path";
   static final String CONTROLLER = "io.dinject.controller.Controller";
 
+  static final String AT_SINGLETON = "@Singleton";
   static final String AT_GENERATED = "@Generated(\"io.dinject.generator\")";
   static final String META_INF_FACTORY = "META-INF/services/io.dinject.core.BeanContextFactory";
 
+  static final String BEAN_FACTORY = "io.dinject.core.BeanFactory";
+  static final String BEAN_FACTORY2 = "io.dinject.core.BeanFactory2";
   static final String BEAN_LIFECYCLE = "io.dinject.core.BeanLifecycle";
   static final String BUILDER = "io.dinject.core.Builder";
+  static final String SINGLETON = "javax.inject.Singleton";
+  static final String INJECT = "javax.inject.Inject";
 
   static final String IMPORT_CONTEXTMODULE = "import io.dinject.ContextModule;";
   static final String IMPORT_DEPENDENCYMETA = "import io.dinject.core.DependencyMeta;";

dinject-generator/src/main/java/io/dinject/generator/FieldReader.java

@@ -1,34 +1,68 @@
 package io.dinject.generator;
 
 import javax.lang.model.element.Element;
-import javax.lang.model.type.TypeMirror;
 
 class FieldReader {
 
   private final Element element;
-
   private final String name;
+  private final UtilType type;
+  private boolean requestParam;
+  private String requestParamName;
 
   FieldReader(Element element) {
     this.element = element;
     this.name = Util.getNamed(element);
+    this.type = Util.determineType(element.asType());
   }
 
   String getFieldName() {
     return element.getSimpleName().toString();
   }
 
   String builderGetDependency() {
-
-    UtilType beanType = Util.determineType(element.asType());
-
     StringBuilder sb = new StringBuilder();
-    sb.append("b.").append(beanType.getMethod());
-    sb.append(beanType.rawType()).append(".class");
+    sb.append("b.").append(type.getMethod());
+    sb.append(type.rawType()).append(".class");
     if (name != null) {
       sb.append(",\"").append(name).append("\"");
     }
     sb.append(")");
     return sb.toString();
   }
+
+  /**
+   * Check for request scoped dependency.
+   */
+  void checkRequest(BeanRequestParams requestParams) {
+    requestParam = requestParams.check(type.rawType());
+    if (requestParam) {
+      requestParamName = requestParams.argumentName(type.rawType());
+    }
+  }
+
+  /**
+   * Generate code for dependency inject for BeanFactory.
+   */
+  void writeRequestDependency(Append writer) {
+    if (!requestParam) {
+      // just add as field dependency
+      requestParamName = writer.nextName(getFieldName().toLowerCase());//"dep");
+      final String shortType = nm(type.rawType());
+      writer.append("  @Inject").eol();
+      writer.append("  %s %s;", shortType, requestParamName).eol().eol();
+    }
+  }
+
+  /**
+   * Generate code to set bean field dependencies as part of BeanFactory create().
+   */
+  void writeRequestInject(Append writer) {
+    writer.append("    bean.%s = %s;", getFieldName(), requestParamName).eol();
+  }
+
+  private String nm(String raw) {
+    return Util.shortName(raw);
+  }
+
 }

dinject-generator/src/main/java/io/dinject/generator/MethodReader.java

@@ -23,7 +23,6 @@ class MethodReader {
   private final String shortName;
   private final boolean isVoid;
   private final List<MethodParam> params = new ArrayList<>();
-
   private final List<String> interfaceTypes = new ArrayList<>();
   private final String factoryShortName;
   private final boolean isFactory;
@@ -225,15 +224,42 @@ void buildLifecycleClass(Append writer) {
     writer.append("  }").eol().eol();
   }
 
+  /**
+   * Check for request scoped dependency.
+   */
+  void checkRequest(BeanRequestParams requestParams) {
+    for (MethodParam param : params) {
+      param.checkRequest(requestParams);
+    }
+  }
+
+  /**
+   * Generate code for dependency inject for BeanFactory.
+   */
+  void writeRequestDependency(Append writer) {
+    for (MethodParam param : params) {
+      param.writeRequestDependency(writer);
+    }
+  }
+
+  /**
+   * Generate code constructor arguments.
+   */
+  void writeRequestConstructor(Append writer) {
+    for (MethodParam param : params) {
+      param.writeRequestConstructor(writer);
+    }
+  }
 
   static class MethodParam {
 
     private final String named;
     private final UtilType utilType;
     private final String paramType;
     private final GenericType genericType;
-
     private int providerIndex;
+    private boolean requestParam;
+    private String requestParamName;
 
     MethodParam(VariableElement param) {
       this.named = Util.getNamed(param);
@@ -284,5 +310,30 @@ void addProviderParam(Append writer, int providerIndex) {
       genericType.writeShort(writer);
       writer.append("> prov%s", providerIndex);
     }
+
+    void checkRequest(BeanRequestParams requestParams) {
+      requestParam = requestParams.check(paramType);
+      if (requestParam) {
+        requestParamName = requestParams.argumentName(paramType);
+      }
+    }
+
+    void writeRequestDependency(Append writer) {
+      if (!requestParam) {
+        final String shortType = nm(paramType);
+        requestParamName = writer.nextName(shortType.toLowerCase());
+        writer.append("  @Inject").eol();
+        writer.append("  %s %s;", shortType, requestParamName).eol().eol();
+      }
+    }
+
+    void writeRequestConstructor(Append writer) {
+      writer.commaAppend(requestParamName);
+    }
+
+    private String nm(String raw) {
+      return Util.shortName(raw);
+    }
+
   }
 }