[Core] Add Before and AfterStep hooks

core/src/main/java/cucumber/api/HookType.java

@@ -1,7 +1,7 @@
 package cucumber.api;
 
 public enum HookType {
-    Before, After;
+    Before, After, AfterStep;
 
     @Override
     public String toString() {

core/src/main/java/cucumber/runner/Runner.java

@@ -128,6 +128,9 @@ private void addTestStepsForPickleSteps(List<TestStep> testSteps, PickleEvent pi
                 match = new FailedStepInstantiationMatch(pickleEvent.uri, step, t);
             }
             testSteps.add(new PickleTestStep(pickleEvent.uri, step, match));
+            if (!runtimeOptions.isDryRun()) {
+                addTestStepsForAfterStepHooks(testSteps, pickleEvent.pickle.getTags());
+            }
         }
     }
 
@@ -139,6 +142,10 @@ private void addTestStepsForAfterHooks(List<TestStep> testSteps, List<PickleTag>
         addTestStepsForHooks(testSteps, tags, glue.getAfterHooks(), HookType.After);
     }
 
+    private void addTestStepsForAfterStepHooks(List<TestStep> testSteps, List<PickleTag> tags) {
+        addTestStepsForHooks(testSteps, tags, glue.getAfterStepHooks(), HookType.AfterStep);
+    }
+
     private void addTestStepsForHooks(List<TestStep> testSteps, List<PickleTag> tags,  List<HookDefinition> hooks, HookType hookType) {
         for (HookDefinition hook : hooks) {
             if (hook.matches(tags)) {

core/src/main/java/cucumber/runtime/Glue.java

@@ -17,10 +17,14 @@ public interface Glue {
 
     void addAfterHook(HookDefinition hookDefinition);
 
+    void addAfterStepHook(HookDefinition hookDefinition);
+
     List<HookDefinition> getBeforeHooks();
 
     List<HookDefinition> getAfterHooks();
 
+    List<HookDefinition> getAfterStepHooks();
+
     StepDefinitionMatch stepDefinitionMatch(String featurePath, PickleStep step);
 
     void reportStepDefinitions(StepDefinitionReporter stepDefinitionReporter);

core/src/main/java/cucumber/runtime/RuntimeGlue.java

@@ -16,6 +16,7 @@ public class RuntimeGlue implements Glue {
     final Map<String, StepDefinition> stepDefinitionsByPattern = new TreeMap<String, StepDefinition>();
     final List<HookDefinition> beforeHooks = new ArrayList<HookDefinition>();
     final List<HookDefinition> afterHooks = new ArrayList<HookDefinition>();
+    final List<HookDefinition> afterStepHooks = new ArrayList<HookDefinition>();
     final Map<String, CacheEntry> matchedStepDefinitionsCache = new HashMap<String, CacheEntry>();
     private final LocalizedXStreams localizedXStreams;
 
@@ -49,6 +50,12 @@ public void addAfterHook(HookDefinition hookDefinition) {
         Collections.sort(afterHooks, new HookComparator(false));
     }
 
+    @Override
+    public void addAfterStepHook(HookDefinition hookDefinition) {
+        afterStepHooks.add(hookDefinition);
+        Collections.sort(afterStepHooks, new HookComparator(false));
+    }
+
     @Override
     public List<HookDefinition> getBeforeHooks() {
         return beforeHooks;
@@ -59,6 +66,11 @@ public List<HookDefinition> getAfterHooks() {
         return afterHooks;
     }
 
+    @Override
+    public List<HookDefinition> getAfterStepHooks() {
+        return afterStepHooks;
+    }
+
     @Override
     public StepDefinitionMatch stepDefinitionMatch(String featurePath, PickleStep step) {
         String stepText = step.getText();

core/src/test/java/cucumber/runtime/HookOrderTest.java

@@ -80,6 +80,25 @@ public void after_hooks_execute_in_reverse_order() throws Throwable {
         inOrder.verify(hooks.get(0)).execute(Matchers.<Scenario>any());
     }
 
+    @Test
+    public void after_step_hooks_execute_in_reverse_order() throws Throwable {
+        List<HookDefinition> hooks = mockHooks(Integer.MIN_VALUE, 2, Integer.MAX_VALUE, 4, -1, 0, 10000);
+        for (HookDefinition hook : hooks) {
+            glue.addAfterStepHook(hook);
+        }
+
+        runner.runPickle(pickleEvent);
+
+        InOrder inOrder = inOrder(hooks.toArray());
+        inOrder.verify(hooks.get(2)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(6)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(3)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(1)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(5)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(4)).execute(Matchers.<Scenario>any());
+        inOrder.verify(hooks.get(0)).execute(Matchers.<Scenario>any());
+    }
+
     @Test
     public void hooks_order_across_many_backends() throws Throwable {
         List<HookDefinition> backend1Hooks = mockHooks(3, Integer.MAX_VALUE, 1);

java/src/main/java/cucumber/api/java/AfterStep.java

@@ -0,0 +1,26 @@
+package cucumber.api.java;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface AfterStep {
+    /**
+     * @return a tag expression
+     */
+    String[] value() default {};
+
+    /**
+     * @return max amount of milliseconds this is allowed to run for. 0 (default) means no restriction.
+     */
+    long timeout() default 0;
+
+    /**
+     * @return the order in which this hook should run. Higher numbers are run first.
+     * The default order is 10000.
+     */
+    int order() default 10000;
+}

java/src/main/java/cucumber/runtime/java/JavaBackend.java

@@ -5,6 +5,7 @@
 import static java.lang.Thread.currentThread;
 
 import cucumber.api.java.After;
+import cucumber.api.java.AfterStep;
 import cucumber.api.java.Before;
 import cucumber.api.java.ObjectFactory;
 import cucumber.api.java8.GlueBase;
@@ -161,10 +162,14 @@ void addHook(Annotation annotation, Method method) {
                 String[] tagExpressions = ((Before) annotation).value();
                 long timeout = ((Before) annotation).timeout();
                 addBeforeHookDefinition(new JavaHookDefinition(method, tagExpressions, ((Before) annotation).order(), timeout, objectFactory));
-            } else {
+            } else if (annotation.annotationType().equals(After.class)) {
                 String[] tagExpressions = ((After) annotation).value();
                 long timeout = ((After) annotation).timeout();
                 addAfterHookDefinition(new JavaHookDefinition(method, tagExpressions, ((After) annotation).order(), timeout, objectFactory));
+            } else if (annotation.annotationType().equals(AfterStep.class)) {
+                String[] tagExpressions = ((AfterStep) annotation).value();
+                long timeout = ((AfterStep) annotation).timeout();
+                addAfterStepHookDefinition(new JavaHookDefinition(method, tagExpressions, ((AfterStep) annotation).order(), timeout, objectFactory));
             }
         }
     }
@@ -179,6 +184,11 @@ public void addAfterHookDefinition(HookDefinition afterHook) {
         glue.addAfterHook(afterHook);
     }
 
+    @Override
+    public void addAfterStepHookDefinition(HookDefinition afterStepHook) {
+        glue.addAfterStepHook(afterStepHook);
+    }
+
     private Pattern pattern(Annotation annotation) throws Throwable {
         Method regexpMethod = annotation.getClass().getMethod("value");
         String regexpString = (String) Utils.invoke(annotation, regexpMethod, 0);

java/src/main/java/cucumber/runtime/java/LambdaGlueRegistry.java

@@ -8,6 +8,8 @@ public interface LambdaGlueRegistry {
 
     void addStepDefinition(StepDefinition stepDefinition);
 
+    void addAfterStepHookDefinition(HookDefinition afterStepHook);
+
     void addBeforeHookDefinition(HookDefinition beforeHook);
 
     void addAfterHookDefinition(HookDefinition afterHook);

java/src/main/java/cucumber/runtime/java/MethodScanner.java

@@ -1,6 +1,7 @@
 package cucumber.runtime.java;
 
 import cucumber.api.java.After;
+import cucumber.api.java.AfterStep;
 import cucumber.api.java.Before;
 import cucumber.runtime.ClassFinder;
 import cucumber.runtime.CucumberException;
@@ -76,7 +77,7 @@ private void validateMethod(Method method, Class<?> glueCodeClass) {
 
     private boolean isHookAnnotation(Annotation annotation) {
         Class<? extends Annotation> annotationClass = annotation.annotationType();
-        return annotationClass.equals(Before.class) || annotationClass.equals(After.class);
+        return annotationClass.equals(Before.class) || annotationClass.equals(After.class) || annotationClass.equals(AfterStep.class);
     }
 
     private boolean isStepdefAnnotation(Annotation annotation) {

java/src/test/java/cucumber/runtime/java/JavaBackendTest.java

@@ -71,6 +71,11 @@ public void addBeforeHook(HookDefinition hookDefinition) {
             throw new UnsupportedOperationException();
         }
 
+        @Override
+        public void addAfterStepHook(HookDefinition hookDefinition) {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
         public void addAfterHook(HookDefinition hookDefinition) {
             throw new UnsupportedOperationException();
@@ -81,6 +86,11 @@ public List<HookDefinition> getBeforeHooks() {
             throw new UnsupportedOperationException();
         }
 
+        @Override
+        public List<HookDefinition> getAfterStepHooks() {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
         public List<HookDefinition> getAfterHooks() {
             throw new UnsupportedOperationException();

java/src/test/java/cucumber/runtime/java/JavaHookTest.java

@@ -2,6 +2,7 @@
 
 import cucumber.api.Scenario;
 import cucumber.api.java.After;
+import cucumber.api.java.AfterStep;
 import cucumber.api.java.Before;
 import cucumber.runtime.ClassFinder;
 import cucumber.runtime.CucumberException;
@@ -29,12 +30,14 @@
 public class JavaHookTest {
     private static final Method BEFORE;
     private static final Method AFTER;
+    private static final Method AFTERSTEP;
     private static final Method BAD_AFTER;
 
     static {
         try {
             BEFORE = HasHooks.class.getMethod("before");
             AFTER = HasHooks.class.getMethod("after");
+            AFTERSTEP = HasHooks.class.getMethod("afterStep");
             BAD_AFTER = BadHook.class.getMethod("after", String.class);
         } catch (NoSuchMethodException e) {
             throw new InternalError("dang");
@@ -71,6 +74,16 @@ public void before_hooks_get_registered() throws Exception {
         assertEquals(BEFORE, hookDef.getMethod());
     }
 
+    @Test
+    public void after_step_hooks_get_registered() throws Exception {
+        objectFactory.setInstance(new HasHooks());
+        backend.buildWorld();
+        backend.addHook(AFTERSTEP.getAnnotation(AfterStep.class), AFTERSTEP);
+        JavaHookDefinition hookDef = (JavaHookDefinition) glue.getAfterStepHooks().get(0);
+        assertEquals(0, glue.getBeforeHooks().size());
+        assertEquals(AFTERSTEP, hookDef.getMethod());
+    }
+
     @Test
     public void after_hooks_get_registered() throws Exception {
         objectFactory.setInstance(new HasHooks());
@@ -138,6 +151,11 @@ public void before() {
 
         }
 
+        @AfterStep
+        public void afterStep() {
+
+        }
+
         @After(order = 1)
         public void after() {
 

java8/src/test/java/cucumber/runtime/java8/Java8LambdaStepDefinitionMarksCorrectStackElementTest.java

@@ -52,6 +52,11 @@ public void addBeforeHookDefinition(HookDefinition beforeHook) {
 
         }
 
+        @Override
+        public void addAfterStepHookDefinition(HookDefinition afterStepHook) {
+
+        }
+
         @Override
         public void addAfterHookDefinition(HookDefinition afterHook) {