[Java] Add annotation for DefaultParameterTransformer hook

Author: mpkorstanje

java/README.md

@@ -0,0 +1,63 @@
+Cucumber Java
+=============
+
+Provides annotation based step definitions. To use add the `cucumber-java` dependency to your pom.xml:
+
+```xml
+<dependencies>
+  [...]
+    <dependency>
+        <groupId>io.cucumber</groupId>
+        <artifactId>cucumber-java</artifactId>
+        <version>${cucumber.version}</version>
+        <scope>test</scope>
+    </dependency>
+  [...]
+</dependencies>
+```
+
+## Step Definitions
+
+Use annotations to mark methods as steps. For localized annotations import from `io.cucumber.java.<ISO2 Language Code>`
+
+
+```java
+import io.cucumber.java.en.Given;
+import io.cucumber.java.en.Then;
+import io.cucumber.java.en.When;
+
+import static org.junit.Assert.assertEquals;
+
+public class CalculatorSteps{
+    private RpnCalculator calc;
+
+    @Given("a calculator I just turned on")
+    public void a_calculator_I_just_turned_on() {
+        calc = new RpnCalculator();
+    }
+
+    @When("I add {int} and {int}")
+    public void adding(int arg1, int arg2) {
+        calc.push(arg1);
+        calc.push(arg2);
+        calc.push("+");
+    }
+
+    @Then("the result is {int}")
+    public void the_result_is(double expected) {
+        assertEquals(expected, calc.value());
+    }
+}
+```
+
+## TODO: Hooks
+ * `@Before` 
+ * `@After`
+ * `@BeforeStep`
+ * `@AfterStep`
+ 
+## TODO: Transformers 
+ * `@DefaultParameterTransformer`
+ * `@DefaultDataTableEntryTransformer`
+ * `@DefaultDataTableCellTransformer`
+ 

java/src/main/java/io/cucumber/java/DefaultParameterTransformer.java

@@ -0,0 +1,21 @@
+package io.cucumber.java;
+
+import org.apiguardian.api.API;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Allows a default transformer for all parameters to be registered.
+ * <p>
+ * Supports ParameterByTypeTransformer: String,Type -> T
+ * Supports ParameterByTypeTransformer: Object,Type -> T
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@API(status = API.Status.STABLE)
+public @interface DefaultParameterTransformer {
+
+}

java/src/main/java/io/cucumber/java/JavaBackend.java

@@ -96,6 +96,8 @@ void addHook(Annotation annotation, Method method) {
                 glue.addParameterType(new JavaParameterTypeDefinition(name, pattern, method, useForSnippets, preferForRegexMatch, lookup));
             } else if (annotation.annotationType().equals(DataTableType.class)) {
                 glue.addDataTableType(new JavaDataTableTypeDefinition(method, lookup));
+            }else if (annotation.annotationType().equals(DefaultParameterTransformer.class)) {
+                glue.addDefaultParameterTransformer(new JavaDefaultParameterTransformerDefinition(method, lookup));
             }
         }
     }

java/src/main/java/io/cucumber/java/JavaDataTableTypeDefinition.java

@@ -3,6 +3,7 @@
 import io.cucumber.core.backend.DataTableTypeDefinition;
 import io.cucumber.core.backend.Lookup;
 import io.cucumber.core.exception.CucumberException;
+import io.cucumber.core.reflection.MethodFormat;
 import io.cucumber.core.runtime.Invoker;
 import io.cucumber.datatable.DataTable;
 import io.cucumber.datatable.DataTableType;
@@ -22,11 +23,15 @@ class JavaDataTableTypeDefinition implements DataTableTypeDefinition {
     private final Method method;
     private final Lookup lookup;
     private final DataTableType dataTableType;
+    private final String shortFormat;
+    private final String fullFormat;
 
     JavaDataTableTypeDefinition(Method method, Lookup lookup) {
         this.method = method;
         this.lookup = lookup;
         this.dataTableType = createDataTableType(method);
+        this.shortFormat = MethodFormat.SHORT.format(method);
+        this.fullFormat = MethodFormat.FULL.format(method);
     }
 
     @SuppressWarnings("unchecked")
@@ -114,6 +119,10 @@ public DataTableType dataTableType() {
         return dataTableType;
     }
 
+    @Override
+    public String getLocation(boolean detail) {
+        return detail ? fullFormat : shortFormat;
+    }
 
     private Object execute(Object arg) throws Throwable {
         return Invoker.invoke(lookup.getInstance(method.getDeclaringClass()), method, 0, arg);

java/src/main/java/io/cucumber/java/JavaDefaultParameterTransformerDefinition.java

@@ -0,0 +1,74 @@
+package io.cucumber.java;
+
+import io.cucumber.core.backend.DefaultParameterTransformerDefinition;
+import io.cucumber.core.backend.Lookup;
+import io.cucumber.core.exception.CucumberException;
+import io.cucumber.core.reflection.MethodFormat;
+import io.cucumber.core.runtime.Invoker;
+import io.cucumber.cucumberexpressions.ParameterByTypeTransformer;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+class JavaDefaultParameterTransformerDefinition implements DefaultParameterTransformerDefinition {
+
+    private final Method method;
+
+    private final Lookup lookup;
+    private final ParameterByTypeTransformer transformer;
+    private final String shortFormat;
+    private final String fullFormat;
+
+    JavaDefaultParameterTransformerDefinition(Method method, Lookup lookup) {
+        this.method = requireValidMethod(method);
+        this.lookup = lookup;
+        this.shortFormat = MethodFormat.SHORT.format(method);
+        this.fullFormat = MethodFormat.FULL.format(method);
+        this.transformer = this::execute;
+    }
+
+    private Method requireValidMethod(Method method) {
+        Class<?> returnType = method.getReturnType();
+        if (Void.class.equals(returnType)) {
+            throw createInvalidSignatureException();
+        }
+
+        Class<?>[] parameterTypes = method.getParameterTypes();
+        if (parameterTypes.length != 2) {
+            throw createInvalidSignatureException();
+        }
+
+        if (!(String.class.equals(parameterTypes[0]) || Object.class.equals(parameterTypes[0]))) {
+            throw createInvalidSignatureException();
+        }
+
+        if (!Type.class.equals(parameterTypes[1])) {
+            throw createInvalidSignatureException();
+        }
+
+        return method;
+    }
+
+    private CucumberException createInvalidSignatureException() {
+        return new CucumberException("" +
+            "A @DefaultParameterTransformer annotated method must have one of these signature:\n" +
+            " * public Object defaultParameter(String fromValue, Type toValueType)\n" +
+            " * public Object defaultParameter(Object fromValue, Type toValueType)\n"
+        );
+    }
+
+    @Override
+    public ParameterByTypeTransformer parameterByTypeTransformer() {
+        return transformer;
+    }
+
+    @Override
+    public String getLocation(boolean detail) {
+        return detail ? fullFormat : shortFormat;
+    }
+
+    private Object execute(String fromValue, Type toValueType) throws Throwable {
+        return Invoker.invoke(lookup.getInstance(method.getDeclaringClass()), method, 0, fromValue, toValueType);
+    }
+
+}

java/src/main/java/io/cucumber/java/JavaParameterTypeDefinition.java

@@ -3,25 +3,32 @@
 import io.cucumber.core.backend.Lookup;
 import io.cucumber.core.backend.ParameterTypeDefinition;
 import io.cucumber.core.exception.CucumberException;
+import io.cucumber.core.reflection.MethodFormat;
 import io.cucumber.core.runtime.Invoker;
 import io.cucumber.cucumberexpressions.ParameterType;
 
 import java.lang.reflect.Method;
 import java.util.Collections;
 
+import static java.util.Collections.singletonList;
+
 class JavaParameterTypeDefinition implements ParameterTypeDefinition {
 
     private final Method method;
 
     private final Lookup lookup;
     private final ParameterType<Object> parameterType;
+    private final String shortFormat;
+    private final String fullFormat;
 
     JavaParameterTypeDefinition(String name, String pattern, Method method, boolean useForSnippets, boolean preferForRegexpMatch, Lookup lookup) {
         this.method = requireValidMethod(method);
         this.lookup = lookup;
+        this.shortFormat = MethodFormat.SHORT.format(method);
+        this.fullFormat = MethodFormat.FULL.format(method);
         this.parameterType = new ParameterType<>(
             name.isEmpty() ? method.getName() : name,
-            Collections.singletonList(pattern),
+            singletonList(pattern),
             this.method.getReturnType(),
             this::execute,
             useForSnippets,
@@ -64,6 +71,11 @@ public ParameterType<?> parameterType() {
         return parameterType;
     }
 
+    @Override
+    public String getLocation(boolean detail) {
+        return detail ? fullFormat : shortFormat;
+    }
+
     private Object execute(Object[] args) throws Throwable {
         return Invoker.invoke(lookup.getInstance(method.getDeclaringClass()), method, 0, args);
     }

java/src/main/java/io/cucumber/java/MethodScanner.java

@@ -85,6 +85,7 @@ private boolean isHookAnnotation(Annotation annotation) {
             || annotationClass.equals(AfterStep.class)
             || annotationClass.equals(ParameterType.class)
             || annotationClass.equals(DataTableType.class)
+            || annotationClass.equals(DefaultParameterTransformer.class)
             ;
     }