[Java8] Add lambda parameter type annotations

core/src/main/java/io/cucumber/core/runner/PickleStepDefinitionMatch.java

@@ -10,6 +10,7 @@
 import io.cucumber.cucumberexpressions.CucumberExpressionException;
 import io.cucumber.datatable.CucumberDataTableException;
 import io.cucumber.datatable.UndefinedDataTableTypeException;
+import io.cucumber.docstring.CucumberDocStringException;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -44,7 +45,7 @@ public void runStep(TestCaseState state) throws Throwable {
             }
         } catch (UndefinedDataTableTypeException e) {
             throw registerTypeInConfiguration(e);
-        } catch (CucumberExpressionException | CucumberDataTableException e) {
+        } catch (CucumberExpressionException | CucumberDataTableException | CucumberDocStringException e) {
             throw couldNotConvertArguments(e);
         } catch (CucumberBackendException e) {
             throw couldNotInvokeArgumentConversion(e);

core/src/test/java/io/cucumber/core/runner/StepDefinitionMatchTest.java

@@ -11,6 +11,7 @@
 import io.cucumber.core.stepexpression.StepTypeRegistry;
 import io.cucumber.cucumberexpressions.ParameterType;
 import io.cucumber.datatable.DataTableType;
+import io.cucumber.docstring.DocStringType;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
 
@@ -240,6 +241,36 @@ void throws_could_not_convert_exception_for_singleton_table_dimension_mismatch()
         )));
     }
 
+    @Test
+    void throws_could_not_convert_exception_for_docstring() {
+        CucumberFeature feature = TestFeatureParser.parse("" +
+            "Feature: Test feature\n" +
+            "  Scenario: Test scenario\n" +
+            "     Given I have some cukes in my belly\n" +
+            "       \"\"\"doc\n" +
+            "        converting this should throw an exception\n" +
+            "       \"\"\"\n"
+        );
+
+        stepTypeRegistry.defineDocStringType(new DocStringType(ItemQuantity.class, "doc", content -> {
+            throw new IllegalArgumentException(content);
+        }));
+
+        CucumberStep step = feature.getPickles().get(0).getSteps().get(0);
+        StepDefinition stepDefinition = new StubStepDefinition("I have some cukes in my belly", ItemQuantity.class);
+        CoreStepDefinition coreStepDefinition = new CoreStepDefinition(stepDefinition, stepTypeRegistry);
+        List<Argument> arguments = coreStepDefinition.matchedArguments(step);
+
+        StepDefinitionMatch stepDefinitionMatch = new PickleStepDefinitionMatch(arguments, stepDefinition, null, step);
+
+        Executable testMethod = () -> stepDefinitionMatch.runStep(null);
+        CucumberException actualThrown = assertThrows(CucumberException.class, testMethod);
+        assertThat(actualThrown.getMessage(), is(equalTo(
+            "Could not convert arguments for step [I have some cukes in my belly] defined at '{stubbed location with details}'.\n" +
+                "The details are in the stacktrace below."
+        )));
+    }
+
     @Test
     void throws_could_not_invoke_argument_conversion_when_argument_could_not_be_got() {
         CucumberFeature feature = TestFeatureParser.parse("file:test.feature", "" +

docstring/pom.xml

@@ -11,7 +11,7 @@
 
     <artifactId>docstring</artifactId>
     <packaging>jar</packaging>
-    <name>Docstring</name>
+    <name>Cucumber-JVM: Docstring</name>
 
     <properties>
         <project.Automatic-Module-Name>io.cucumber.docstring</project.Automatic-Module-Name>

java8/src/main/java/io/cucumber/java8/DataTableCellDefinitionBody.java

@@ -0,0 +1,9 @@
+package io.cucumber.java8;
+
+import org.apiguardian.api.API;
+
+@FunctionalInterface
+@API(status = API.Status.STABLE)
+public interface DataTableCellDefinitionBody<T> {
+    T accept(String cell) throws Throwable;
+}

java8/src/main/java/io/cucumber/java8/DataTableDefinitionBody.java

@@ -0,0 +1,10 @@
+package io.cucumber.java8;
+
+import io.cucumber.datatable.DataTable;
+import org.apiguardian.api.API;
+
+@FunctionalInterface
+@API(status = API.Status.STABLE)
+public interface DataTableDefinitionBody<T> {
+    T accept(DataTable dataTable) throws Throwable;
+}

java8/src/main/java/io/cucumber/java8/DataTableEntryDefinitionBody.java

@@ -0,0 +1,10 @@
+package io.cucumber.java8;
+
+import java.util.Map;
+import org.apiguardian.api.API;
+
+@FunctionalInterface
+@API(status = API.Status.STABLE)
+public interface DataTableEntryDefinitionBody<T> {
+    T accept(Map<String, String> map) throws Throwable;
+}

java8/src/main/java/io/cucumber/java8/DataTableRowDefinitionBody.java

@@ -0,0 +1,10 @@
+package io.cucumber.java8;
+
+import java.util.List;
+import org.apiguardian.api.API;
+
+@FunctionalInterface
+@API(status = API.Status.STABLE)
+public interface DataTableRowDefinitionBody<T> {
+    T accept(List<String> row) throws Throwable;
+}

java8/src/main/java/io/cucumber/java8/DocStringDefinitionBody.java

@@ -0,0 +1,9 @@
+package io.cucumber.java8;
+
+import org.apiguardian.api.API;
+
+@FunctionalInterface
+@API(status = API.Status.STABLE)
+public interface DocStringDefinitionBody<T> {
+    T accept(String docString) throws Throwable;
+}

java8/src/main/java/io/cucumber/java8/Java8Backend.java

@@ -2,9 +2,12 @@
 
 import io.cucumber.core.backend.Backend;
 import io.cucumber.core.backend.Container;
+import io.cucumber.core.backend.DataTableTypeDefinition;
+import io.cucumber.core.backend.DocStringTypeDefinition;
 import io.cucumber.core.backend.Glue;
 import io.cucumber.core.backend.HookDefinition;
 import io.cucumber.core.backend.Lookup;
+import io.cucumber.core.backend.ParameterTypeDefinition;
 import io.cucumber.core.backend.Snippet;
 import io.cucumber.core.backend.StepDefinition;
 import io.cucumber.core.io.ClassFinder;
@@ -105,7 +108,22 @@ public void addBeforeHookDefinition(HookDefinition beforeHook) {
         @Override
         public void addAfterHookDefinition(HookDefinition afterHook) {
             glue.addAfterHook(afterHook);
+        }
+
+        @Override
+        public void addDocStringType(DocStringTypeDefinition docStringTypeDefinition) {
+            glue.addDocStringType(docStringTypeDefinition);
+
+        }
 
+        @Override
+        public void addDataTableType(DataTableTypeDefinition dataTableTypeDefinition) {
+            glue.addDataTableType(dataTableTypeDefinition);
+        }
+
+        @Override
+        public void addParameterType(ParameterTypeDefinition parameterTypeDefinition) {
+            glue.addParameterType(parameterTypeDefinition);
         }
     }
 }

java8/src/main/java/io/cucumber/java8/Java8DataTableTypeDefinition.java

@@ -0,0 +1,58 @@
+package io.cucumber.java8;
+
+import io.cucumber.core.backend.DataTableTypeDefinition;
+import io.cucumber.datatable.DataTable;
+import io.cucumber.datatable.DataTableType;
+import io.cucumber.datatable.TableCellTransformer;
+import io.cucumber.datatable.TableEntryTransformer;
+import io.cucumber.datatable.TableRowTransformer;
+import io.cucumber.datatable.TableTransformer;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+import net.jodah.typetools.TypeResolver;
+
+final class Java8DataTableTypeDefinition extends AbstractGlueDefinition implements DataTableTypeDefinition {
+
+    private final DataTableType dataTableType;
+
+    Java8DataTableTypeDefinition(Object body) {
+        super(body, new Exception().getStackTrace()[3]);
+        this.dataTableType = createDataTableType(method);
+    }
+
+    private DataTableType createDataTableType(Method method) {
+        Class returnType = TypeResolver.resolveRawArguments(DataTableEntryDefinitionBody.class, body.getClass())[0];
+        Type[] parameterTypes = method.getGenericParameterTypes();
+        Type parameterType = parameterTypes[0];
+
+        if (DataTable.class.equals(parameterType)) {
+            return new DataTableType( returnType, (TableTransformer<Object>) this::execute);
+        }
+
+        if (List.class.equals(parameterType)) {
+            return new DataTableType(returnType, (TableRowTransformer<Object>) this::execute);
+        }
+
+        if (Map.class.equals(parameterType)) {
+            return new DataTableType(returnType, (TableEntryTransformer<Object>) this::execute);
+        }
+
+        if (String.class.equals(parameterType)) {
+            return new DataTableType(returnType, (TableCellTransformer<Object>) this::execute);
+        }
+
+        return new DataTableType(returnType, (TableTransformer<Object>) this::execute);
+    }
+
+    @Override
+    public DataTableType dataTableType() {
+        return dataTableType;
+    }
+
+    private Object execute(Object arg) throws Throwable {
+        return Invoker.invoke(this, body, method, arg);
+    }
+}

java8/src/main/java/io/cucumber/java8/Java8DocStringTypeDefinition.java

@@ -0,0 +1,35 @@
+package io.cucumber.java8;
+
+import io.cucumber.core.backend.DocStringTypeDefinition;
+import io.cucumber.core.exception.CucumberException;
+import io.cucumber.docstring.DocStringType;
+import net.jodah.typetools.TypeResolver;
+
+final class Java8DocStringTypeDefinition extends AbstractGlueDefinition implements DocStringTypeDefinition {
+
+    private final DocStringType docStringType;
+
+    @Override
+    public DocStringType docStringType() {
+        return docStringType;
+    }
+
+    Java8DocStringTypeDefinition(Object body, String contentType) {
+        super(body, new Exception().getStackTrace()[3]);
+        if (contentType == null) {
+            throw new CucumberException("Docstring content type couldn't be null, define docstring content type");
+        }
+        if (contentType.isEmpty()) {
+            throw new CucumberException("Docstring content type couldn't be empty, define docstring content type");
+        }
+        Class returnType = TypeResolver.resolveRawArguments(DocStringDefinitionBody.class, body.getClass())[0];
+        this.docStringType = new DocStringType(
+            returnType,
+            contentType,
+            this::execute);
+    }
+
+    private Object execute(String content) throws Throwable {
+        return Invoker.invoke(this, body, method, content);
+    }
+}

java8/src/main/java/io/cucumber/java8/Java8ParameterTypeDefinition.java

@@ -0,0 +1,28 @@
+package io.cucumber.java8;
+
+import java.util.Collections;
+
+import io.cucumber.core.backend.ParameterTypeDefinition;
+import io.cucumber.cucumberexpressions.ParameterType;
+
+import static net.jodah.typetools.TypeResolver.resolveRawArguments;
+
+class Java8ParameterTypeDefinition extends AbstractGlueDefinition implements ParameterTypeDefinition {
+
+    private final ParameterType parameterType;
+
+    @Override
+    public ParameterType<?> parameterType() {
+        return parameterType;
+    }
+
+    <T extends ParameterDefinitionBody> Java8ParameterTypeDefinition(String name, String regex, Class<T> bodyClass, T body) {
+        super(body, new Exception().getStackTrace()[3]);
+        Class<?> returnType = resolveRawArguments(bodyClass, body.getClass())[0];
+        this.parameterType = new ParameterType(name, Collections.singletonList(regex), returnType, this::execute);
+    }
+
+    private Object execute(String[] parameterContent) throws Throwable {
+        return Invoker.invoke(this, body, method, parameterContent);
+    }
+}

java8/src/main/java/io/cucumber/java8/Java8StepDefinition.java

@@ -13,27 +13,19 @@
 
 final class Java8StepDefinition extends AbstractGlueDefinition implements StepDefinition {
 
-    private final long timeoutMillis;
     private final List<ParameterInfo> parameterInfos;
     private final String expression;
     private <T extends StepDefinitionBody> Java8StepDefinition(String expression,
-                                                               long timeoutMillis,
                                                                Class<T> bodyClass,
                                                                T body) {
         super(body, new Exception().getStackTrace()[3]);
-        this.timeoutMillis = timeoutMillis;
         this.expression = requireNonNull(expression, "cucumber-expression may not be null");
         this.parameterInfos = fromTypes(expression, location, resolveRawArguments(bodyClass, body.getClass()));
     }
 
     public static <T extends StepDefinitionBody> Java8StepDefinition create(
         String expression, Class<T> bodyClass, T body) {
-        return new Java8StepDefinition(expression, 0, bodyClass, body);
-    }
-
-    public static <T extends StepDefinitionBody> StepDefinition create(
-        String expression, long timeoutMillis, Class<T> bodyClass, T body) {
-        return new Java8StepDefinition(expression, timeoutMillis, bodyClass, body);
+        return new Java8StepDefinition(expression, bodyClass, body);
     }
 
     private static List<ParameterInfo> fromTypes(String expression, StackTraceElement location, Type[] genericParameterTypes) {