RelfectiveBeanConverter issue - not decoding HashValue with contructor injection fix #1531

Author: jknack

docs/asciidoc/usage/usage.adoc

@@ -28,7 +28,7 @@ Kotlin build also requires it via https://kotlinlang.org/docs/reference/kapt.htm
     <plugins>
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
-        <version>${maven-compiler-plugin.version}</version>
+        <version>{mavenCompilerPluginVersion}</version>
         <configuration>
           <annotationProcessorPaths>
             <path>
@@ -51,7 +51,7 @@ Kotlin build also requires it via https://kotlinlang.org/docs/reference/kapt.htm
       <plugin>
         <artifactId>kotlin-maven-plugin</artifactId>
         <groupId>org.jetbrains.kotlin</groupId>
-        <version>${kotlin.version}</version>
+        <version>{kotlinVersion}</version>
         <configuration>
           <args>
             <arg>-java-parameters</arg>
@@ -101,7 +101,7 @@ Kotlin build also requires it via https://kotlinlang.org/docs/reference/kapt.htm
                 <annotationProcessorPath>
                   <groupId>io.jooby</groupId>
                   <artifactId>jooby-apt</artifactId>
-                  <version>${jooby.version}</version>
+                  <version>{joobyVersion}</version>
                 </annotationProcessorPath>
               </annotationProcessorPaths>
             </configuration>
@@ -130,20 +130,20 @@ Java build needs an annotationProcessor statement using `jooby-apt`.
 Kotlin builds needs a https://kotlinlang.org/docs/reference/kapt.html#using-in-gradle[kapt] dependency and statement using `jooby-apt`.
 
 .Java
-[source, groovy, role="primary"]
+[source, groovy, role="primary", subs="verbatim,attributes"]
 ----
 dependencies {
   annotationProcessor "io.jooby:jooby-apt:{joobyVersion}"
 }
 ----
 
 .Kotlin
-[source, groovy, role="secondary"]
+[source, groovy, role="secondary", subs="verbatim,attributes"]
 ----
 buildscript {
   ...
   dependencies {
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:{kotlinVersion}"
   }
 }
 
@@ -184,3 +184,78 @@ Alternatively, you can delegate IntelliJ build/run actions to Maven or Gradle co
 *Eclipse 4.9+*
 
 You need https://www.eclipse.org/m2e/[M2Eclipse] for Maven or https://projects.eclipse.org/projects/tools.buildship[Gradle Buildship]
+
+== Bean Converter
+
+=== Parameter Name Missing
+
+*Exception*:
+
+----
+Unable to provision parameter at position: '...', require by: ... Parameter's name is missing
+----
+
+Thrown when the bean converter has no access to a parameter name at runtime. Compilation must be 
+done using `parameters` compiler option.
+
+*Maven Solution*
+
+.Java
+[source, xml, role = "primary", subs="verbatim,attributes"]
+----
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>{mavenCompilerPluginVersion}</version>
+        <configuration>
+        ...
+          <compilerArgs>
+            <arg>-parameters</arg>
+          </compilerArgs>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+----
+
+.Kotlin
+[source, xml, role = "secondary", subs="verbatim,attributes"]
+----
+  <build>
+    <plugins>
+      <plugin>
+          <artifactId>kotlin-maven-plugin</artifactId>
+          <groupId>org.jetbrains.kotlin</groupId>
+          <version>{kotlinVersion}</version>
+          <configuration>
+            ...
+            <args>
+              <arg>-java-parameters</arg>
+            </args>
+            <jvmTarget>1.8</jvmTarget>
+            ...
+          </configuration>
+        </plugin>
+    </plugins>
+  </build>
+----
+
+*Gradle Solution*
+
+.Java
+[source, groovy, role = "primary", subs="verbatim,attributes"]
+----
+tasks.withType(JavaCompile) {
+  options.compilerArgs << '-parameters'
+  options.debug = true
+}
+----
+
+.Kotlin
+[source, groovy, role = "secondary", subs="verbatim,attributes"]
+----
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+  kotlinOptions.javaParameters = true
+}
+----

jooby/src/main/java/io/jooby/Usage.java

@@ -5,22 +5,30 @@
  */
 package io.jooby;
 
+import io.jooby.exception.ProvisioningException;
+
 import javax.annotation.Nonnull;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Parameter;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Usage exceptions. They provide a descriptive message with a link for a detailed section.
  *
  * @since 2.1.0
  */
 public class Usage extends RuntimeException {
+
   /**
    * Creates a new Usage exception.
    *
    * @param message Message.
    * @param id Link to detailed section.
    */
   public Usage(@Nonnull String message, @Nonnull String id) {
-    super((message + "\nFor more details, please visit: https://jooby.io/usage#" + id));
+    super((message + "\nFor more details, please visit: " + System
+        .getProperty("jooby.host", "https://jooby.io") + "/usage#" + id));
   }
 
   /**
@@ -34,6 +42,22 @@ public Usage(@Nonnull String message, @Nonnull String id) {
         + "`. Make sure Jooby annotation processor is configured properly.", "router-not-found");
   }
 
+  /**
+   * Thrown when the reflective bean converter has no access to a parameter name. Compilation
+   * must be done using <code>parameters</code> compiler option.
+   *
+   * @param parameter Parameter.
+   * @return Usage exception.
+   */
+  public static @Nonnull Usage parameterNameNotPresent(@Nonnull Parameter parameter) {
+    Executable executable = parameter.getDeclaringExecutable();
+    int p = Stream.of(executable.getParameters()).collect(Collectors.toList()).indexOf(parameter);
+    String message = "Unable to provision parameter at position: '" + p + "', require by: "
+        + ProvisioningException.toString(parameter.getDeclaringExecutable())
+        + ". Parameter's name is missing";
+    return new Usage(message, "bean-converter-parameter-name-missing");
+  }
+
   private static Usage apt(String message, String id) {
     return new Usage(message, "annotation-processing-tool-" + id);
   }

jooby/src/main/java/io/jooby/exception/ProvisioningException.java

@@ -41,11 +41,23 @@ public ProvisioningException(@Nonnull String message, @Nonnull Throwable cause)
     super(message, cause);
   }
 
-  private static String toString(Parameter parameter) {
+  /**
+   * Creates a parameter description.
+   *
+   * @param parameter Parameter.
+   * @return Description.
+   */
+  public static String toString(@Nonnull Parameter parameter) {
     return parameter.getName() + ": " + parameter.getParameterizedType();
   }
 
-  private static String toString(Executable method) {
+  /**
+   * Creates a method description.
+   *
+   * @param method Parameter.
+   * @return Description.
+   */
+  public static String toString(@Nonnull Executable method) {
     StringBuilder buff = new StringBuilder();
     if (method instanceof Constructor) {
       buff.append("constructor ");

jooby/src/main/java/io/jooby/internal/converter/ReflectiveBeanConverter.java

@@ -5,6 +5,7 @@
  */
 package io.jooby.internal.converter;
 
+import io.jooby.Usage;
 import io.jooby.exception.BadRequestException;
 import io.jooby.BeanConverter;
 import io.jooby.FileUpload;
@@ -111,12 +112,14 @@ public static Object[] inject(ValueNode scope, Executable method, Consumer<Value
   }
 
   private static String paramName(Parameter parameter) {
-    String name = parameter.getName();
     Named named = parameter.getAnnotation(Named.class);
     if (named != null && named.value().length() > 0) {
-      name = named.value();
+      return named.value();
     }
-    return name;
+    if (parameter.isNamePresent()) {
+      return parameter.getName();
+    }
+    throw Usage.parameterNameNotPresent(parameter);
   }
 
   private static <T> T setters(T newInstance, ValueNode node, Set<ValueNode> skip) {

jooby/src/test/java/io/jooby/UsageTest.java

@@ -0,0 +1,27 @@
+package io.jooby;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class UsageTest {
+
+  static {
+    System.setProperty("jooby.host", "http://localhost:4000");
+  }
+
+  @Test
+  public void parameterNameMissing() throws NoSuchMethodException {
+    Method method = getClass().getDeclaredMethod("parameterMissing", String.class);
+    Usage usage = Usage.parameterNameNotPresent(method.getParameters()[0]);
+    assertEquals("Unable to provision parameter at position: '0', require by: method io.jooby.UsageTest.parameterMissing(java.lang.String). Parameter's name is missing\n"
+        + "For more details, please visit: http://localhost:4000/usage#bean-converter-parameter-name-missing", usage.getMessage());
+  }
+
+  public void parameterMissing(String some) {
+
+  }
+
+}