[Core] Decouple UndefinedStepsTracker from Glue

 Glue only served to pass the UndefinedStepsTracker between Runtime and
 Runtime. Decoupling this removes some pointless complexity.

 The constructor `RuntimeGlue(UndefinedStepsTracker tracker, LocalizedXStreams localizedXStreams)`
 has been deprecated to avoid breaking existing implementations.

 The Runtime will not use the provided UndefinedStepsTracker but this is
 consistent with the behaviour prior to  #1019.

 Third parties interested in undefined steps can use the subscribe their own
 UndefinedStepsTracker to the event bus.

Author: mpkorstanje

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

@@ -26,6 +26,4 @@ public interface Glue {
     void reportStepDefinitions(StepDefinitionReporter stepDefinitionReporter);
 
     void removeScenarioScopedGlue();
-
-    UndefinedStepsTracker getTracker();
 }

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

@@ -27,7 +27,7 @@
 public class Runtime {
 
     final Stats stats; // package private to be avaiable for tests.
-    private final UndefinedStepsTracker undefinedStepsTracker;
+    private final UndefinedStepsTracker undefinedStepsTracker = new UndefinedStepsTracker();
 
     private final RuntimeOptions runtimeOptions;
 
@@ -59,13 +59,7 @@ public Runtime(ResourceLoader resourceLoader, ClassLoader classLoader, Collectio
         this.classLoader = classLoader;
         this.runtimeOptions = runtimeOptions;
         final Glue glue;
-        if (optionalGlue == null) {
-            this.undefinedStepsTracker = new UndefinedStepsTracker();
-            glue = new RuntimeGlue(undefinedStepsTracker, new LocalizedXStreams(classLoader));
-        } else {
-            this.undefinedStepsTracker = optionalGlue.getTracker();
-            glue = optionalGlue;
-        }
+        glue = optionalGlue == null ? new RuntimeGlue(new LocalizedXStreams(classLoader)) : optionalGlue;
         this.stats = new Stats(runtimeOptions.isMonochrome());
         this.bus = new EventBus(stopWatch);
         this.runner = new Runner(glue, bus, backends, runtimeOptions);

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

@@ -16,11 +16,14 @@ public class RuntimeGlue implements Glue {
     final List<HookDefinition> beforeHooks = new ArrayList<HookDefinition>();
     final List<HookDefinition> afterHooks = new ArrayList<HookDefinition>();
 
-    private final UndefinedStepsTracker tracker;
     private final LocalizedXStreams localizedXStreams;
 
+    public RuntimeGlue(LocalizedXStreams localizedXStreams) {
+        this(null, localizedXStreams);
+    }
+
+    @Deprecated
     public RuntimeGlue(UndefinedStepsTracker tracker, LocalizedXStreams localizedXStreams) {
-        this.tracker = tracker;
         this.localizedXStreams = localizedXStreams;
     }
 
@@ -113,7 +116,4 @@ private void removeScenarioScopedStepdefs() {
         }
     }
 
-    public UndefinedStepsTracker getTracker() {
-        return tracker;
-    }
 }

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

@@ -1,8 +1,5 @@
 package cucumber.runtime;
 
-import cucumber.api.Result;
-import cucumber.api.TestCase;
-import cucumber.api.TestStep;
 import cucumber.api.event.EventHandler;
 import cucumber.api.event.EventListener;
 import cucumber.api.event.EventPublisher;
@@ -32,7 +29,6 @@ public class UndefinedStepsTracker implements EventListener {
     private final Map<String, String> pathToSourceMap = new HashMap<String, String>();
     private final Map<String, FeatureStepMap> pathToStepMap = new HashMap<String, FeatureStepMap>();
     private boolean hasUndefinedSteps = false;
-    private String currentUri;
 
     private EventHandler<TestSourceRead> testSourceReadHandler = new EventHandler<TestSourceRead>() {
         @Override
@@ -160,21 +156,21 @@ private String convertToCodeKeyword(String keyword) {
         return keyword.replaceAll("[\\s',!]", "");
     }
 
-    private class FeatureStepMap {
-        public final GherkinDialect dialect;
-        public final Map<Integer, StepNode> stepMap;
+    private static final class FeatureStepMap {
+        final GherkinDialect dialect;
+        final Map<Integer, StepNode> stepMap;
 
-        public FeatureStepMap(GherkinDialect dialect, Map<Integer, StepNode> stepMap) {
+        FeatureStepMap(GherkinDialect dialect, Map<Integer, StepNode> stepMap) {
             this.dialect = dialect;
             this.stepMap = stepMap;
         }
     }
 
-    private class StepNode {
-        public final Step step;
-        public final StepNode previous;
+    private static final class StepNode {
+        final Step step;
+        final StepNode previous;
 
-        public StepNode(Step step, StepNode previous) {
+        StepNode(Step step, StepNode previous) {
             this.step = step;
             this.previous = previous;
         }

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

@@ -11,7 +11,7 @@
 public class RuntimeGlueTest {
     @Test
     public void throws_duplicate_error_on_dupe_stepdefs() {
-        RuntimeGlue glue = new RuntimeGlue(new UndefinedStepsTracker(), new LocalizedXStreams(Thread.currentThread().getContextClassLoader()));
+        RuntimeGlue glue = new RuntimeGlue(new LocalizedXStreams(Thread.currentThread().getContextClassLoader()));
 
         StepDefinition a = mock(StepDefinition.class);
         when(a.getPattern()).thenReturn("hello");
@@ -35,7 +35,7 @@ public void removes_glue_that_is_scenario_scoped() {
         // But it was too much hassle creating a better test without refactoring RuntimeGlue
         // and probably some of its immediate collaborators... Aslak.
 
-        RuntimeGlue glue = new RuntimeGlue(new UndefinedStepsTracker(), new LocalizedXStreams(Thread.currentThread().getContextClassLoader()));
+        RuntimeGlue glue = new RuntimeGlue(new LocalizedXStreams(Thread.currentThread().getContextClassLoader()));
 
         StepDefinition sd = mock(StepDefinition.class);
         when(sd.isScenarioScoped()).thenReturn(true);

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

@@ -543,20 +543,14 @@ private Runtime createRuntimeWithMockedGlue(StepDefinitionMatch match, boolean i
         }
         RuntimeOptions runtimeOptions = new RuntimeOptions(args);
         Backend backend = mock(Backend.class);
-        RuntimeGlue glue = mockGlue();
+        RuntimeGlue glue = mock(RuntimeGlue.class);
         mockMatch(glue, match, isAmbiguous);
         mockHook(glue, hook, isBefore);
         Collection<Backend> backends = Arrays.asList(backend);
 
         return new Runtime(resourceLoader, classLoader, backends, runtimeOptions, glue);
     }
 
-    private RuntimeGlue mockGlue() {
-        RuntimeGlue glue = mock(RuntimeGlue.class);
-        when(glue.getTracker()).thenReturn(new UndefinedStepsTracker());
-        return glue;
-    }
-
     private void mockMatch(RuntimeGlue glue, StepDefinitionMatch match, boolean isAmbiguous) {
         if (isAmbiguous) {
             Exception exception = new AmbiguousStepDefinitionsException(mock(PickleStep.class), Arrays.asList(match, match));

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

@@ -159,7 +159,6 @@ private static RuntimeGlue createMockedRuntimeGlueThatMatchesTheSteps(final Map<
                                                                           final List<SimpleEntry<String, Result>> hooks, final List<String> hookLocations,
                                                                           final List<Answer<Object>> hookActions) throws Throwable {
         RuntimeGlue glue = mock(RuntimeGlue.class);
-        when(glue.getTracker()).thenReturn(new UndefinedStepsTracker());
         TestHelper.mockSteps(glue, stepsToResult, stepsToLocation);
         TestHelper.mockHooks(glue, hooks, hookLocations, hookActions);
         return glue;