[Core] Extract interfaces for options

cucumber · Dec 2, 2018 · 170f8d2 · 170f8d2
1 parent cf8b320
commit 170f8d2
Show file tree

Hide file tree

Showing 21 changed files with 122 additions and 83 deletions.
diff --git a/core/src/main/java/cucumber/runner/Runner.java b/core/src/main/java/cucumber/runner/Runner.java
@@ -5,7 +5,7 @@
 import cucumber.api.event.SnippetsSuggestedEvent;
 import cucumber.runtime.Backend;
 import cucumber.runtime.HookDefinition;
-import cucumber.runtime.RuntimeOptions;
+import io.cucumber.core.options.RunnerOptions;
 import gherkin.events.PickleEvent;
 import gherkin.pickles.PickleStep;
 import gherkin.pickles.PickleTag;
@@ -18,14 +18,14 @@ public final class Runner {
     private final Glue glue = new Glue();
     private final EventBus bus;
     private final Collection<? extends Backend> backends;
-    private final RuntimeOptions runtimeOptions;
+    private final RunnerOptions runnerOptions;
 
-    public Runner(EventBus bus, Collection<? extends Backend> backends, RuntimeOptions runtimeOptions) {
+    public Runner(EventBus bus, Collection<? extends Backend> backends, RunnerOptions runnerOptions) {
         this.bus = bus;
-        this.runtimeOptions = runtimeOptions;
+        this.runnerOptions = runnerOptions;
         this.backends = backends;
         for (Backend backend : backends) {
-            backend.loadGlue(glue, runtimeOptions.getGlue());
+            backend.loadGlue(glue, runnerOptions.getGlue());
         }
 
     }
@@ -54,7 +54,7 @@ private TestCase createTestCaseForPickle(PickleEvent pickleEvent) {
             addTestStepsForPickleSteps(testSteps, pickleEvent);
             addTestStepsForAfterHooks(afterHooks, pickleEvent.pickle.getTags());
         }
-        return new TestCase(testSteps, beforeHooks, afterHooks, pickleEvent, runtimeOptions.isDryRun());
+        return new TestCase(testSteps, beforeHooks, afterHooks, pickleEvent, runnerOptions.isDryRun());
     }
 
     private void addTestStepsForPickleSteps(List<PickleStepTestStep> testSteps, PickleEvent pickleEvent) {
@@ -65,7 +65,7 @@ private void addTestStepsForPickleSteps(List<PickleStepTestStep> testSteps, Pick
                 if (match == null) {
                     List<String> snippets = new ArrayList<>();
                     for (Backend backend : backends) {
-                        List<String> snippet = backend.getSnippet(step, "**KEYWORD**", runtimeOptions.getSnippetType().getFunctionNameGenerator());
+                        List<String> snippet = backend.getSnippet(step, "**KEYWORD**", runnerOptions.getSnippetType().getFunctionNameGenerator());
                         snippets.addAll(snippet);
                     }
                     if (!snippets.isEmpty()) {

diff --git a/core/src/main/java/cucumber/runner/RunnerSupplier.java b/core/src/main/java/cucumber/runner/RunnerSupplier.java
@@ -1,7 +1,5 @@
 package cucumber.runner;
 
-import cucumber.runner.Runner;
-
 public interface RunnerSupplier {
     Runner get();
 }
diff --git a/core/src/main/java/cucumber/runner/SingletonRunnerSupplier.java b/core/src/main/java/cucumber/runner/SingletonRunnerSupplier.java
@@ -1,7 +1,7 @@
 package cucumber.runner;
 
 import cucumber.runtime.BackendSupplier;
-import cucumber.runtime.RuntimeOptions;
+import io.cucumber.core.options.RunnerOptions;
 
 /**
  * Returns a single unique runner.
@@ -11,18 +11,18 @@
 public class SingletonRunnerSupplier implements RunnerSupplier {
 
     private final BackendSupplier backendSupplier;
-    private final RuntimeOptions runtimeOptions;
+    private final RunnerOptions runnerOptions;
     private final EventBus eventBus;
     private Runner runner;
 
 
     public SingletonRunnerSupplier(
-        RuntimeOptions runtimeOptions,
+        RunnerOptions runnerOptions,
         EventBus eventBus,
         BackendSupplier backendSupplier
     ) {
         this.backendSupplier = backendSupplier;
-        this.runtimeOptions = runtimeOptions;
+        this.runnerOptions = runnerOptions;
         this.eventBus = eventBus;
     }
 
@@ -35,7 +35,7 @@ public Runner get() {
     }
 
     private Runner createRunner() {
-        return new Runner(eventBus, backendSupplier.get(), runtimeOptions);
+        return new Runner(eventBus, backendSupplier.get(), runnerOptions);
     }
 
 }
diff --git a/core/src/main/java/cucumber/runner/ThreadLocalRunnerSupplier.java b/core/src/main/java/cucumber/runner/ThreadLocalRunnerSupplier.java
@@ -2,10 +2,8 @@
 
 import cucumber.api.event.Event;
 import cucumber.api.event.EventHandler;
-import cucumber.runner.AbstractEventBus;
-import cucumber.runner.EventBus;
 import cucumber.runtime.BackendSupplier;
-import cucumber.runtime.RuntimeOptions;
+import io.cucumber.core.options.RunnerOptions;
 
 /**
  * Creates a distinct runner for each calling thread. Each runner has its own bus, backend- and glue-suppliers.
@@ -15,7 +13,7 @@
 public class ThreadLocalRunnerSupplier implements RunnerSupplier {
 
     private final BackendSupplier backendSupplier;
-    private final RuntimeOptions runtimeOptions;
+    private final RunnerOptions runnerOptions;
     private final SynchronizedEventBus sharedEventBus;
 
     private final ThreadLocal<Runner> runners = new ThreadLocal<Runner>() {
@@ -26,11 +24,11 @@ protected Runner initialValue() {
     };
 
     public ThreadLocalRunnerSupplier(
-        RuntimeOptions runtimeOptions,
+        RunnerOptions runnerOptions,
         EventBus sharedEventBus,
         BackendSupplier backendSupplier
     ) {
-        this.runtimeOptions = runtimeOptions;
+        this.runnerOptions = runnerOptions;
         this.sharedEventBus = SynchronizedEventBus.synchronize(sharedEventBus);
         this.backendSupplier = backendSupplier;
     }
@@ -41,7 +39,7 @@ public Runner get() {
     }
 
     private Runner createRunner() {
-        return new Runner(new LocalEventBus(sharedEventBus), backendSupplier.get(), runtimeOptions);
+        return new Runner(new LocalEventBus(sharedEventBus), backendSupplier.get(), runnerOptions);
     }
 
     private static final class LocalEventBus extends AbstractEventBus {

diff --git a/core/src/main/java/cucumber/runtime/BackendModuleBackendSupplier.java b/core/src/main/java/cucumber/runtime/BackendModuleBackendSupplier.java
@@ -3,6 +3,7 @@
 import cucumber.api.TypeRegistryConfigurer;
 import cucumber.runtime.io.MultiLoader;
 import cucumber.runtime.io.ResourceLoader;
+import io.cucumber.core.options.RunnerOptions;
 import io.cucumber.stepexpression.TypeRegistry;
 
 import java.util.Collection;
@@ -18,17 +19,17 @@ public final class BackendModuleBackendSupplier implements BackendSupplier {
 
     private final ResourceLoader resourceLoader;
     private final ClassFinder classFinder;
-    private final RuntimeOptions runtimeOptions;
+    private final RunnerOptions runnerOptions;
     private final List<String> packages;
 
-    public BackendModuleBackendSupplier(ResourceLoader resourceLoader, ClassFinder classFinder, RuntimeOptions runtimeOptions) {
+    public BackendModuleBackendSupplier(ResourceLoader resourceLoader, ClassFinder classFinder, RunnerOptions runnerOptions) {
-        this(resourceLoader, classFinder, runtimeOptions, singletonList("cucumber.runtime"));
+        this(resourceLoader, classFinder, runnerOptions, singletonList("cucumber.runtime"));
     }
 
-    BackendModuleBackendSupplier(ResourceLoader resourceLoader, ClassFinder classFinder, RuntimeOptions runtimeOptions, List<String> packages) {
+    BackendModuleBackendSupplier(ResourceLoader resourceLoader, ClassFinder classFinder, RunnerOptions runnerOptions, List<String> packages) {
         this.resourceLoader = resourceLoader;
         this.classFinder = classFinder;
-        this.runtimeOptions = runtimeOptions;
+        this.runnerOptions = runnerOptions;
         this.packages = packages;
     }
 
@@ -43,7 +44,7 @@ public Collection<? extends Backend> get() {
 
     private Collection<? extends Backend> loadBackends() {
         Reflections reflections = new Reflections(classFinder);
-        TypeRegistryConfigurer typeRegistryConfigurer = reflections.instantiateExactlyOneSubclass(TypeRegistryConfigurer.class, MultiLoader.packageName(runtimeOptions.getGlue()), new Class[0], new Object[0], new DefaultTypeRegistryConfiguration());
+        TypeRegistryConfigurer typeRegistryConfigurer = reflections.instantiateExactlyOneSubclass(TypeRegistryConfigurer.class, MultiLoader.packageName(runnerOptions.getGlue()), new Class[0], new Object[0], new DefaultTypeRegistryConfiguration());
         TypeRegistry typeRegistry = new TypeRegistry(typeRegistryConfigurer.locale());
         typeRegistryConfigurer.configureTypeRegistry(typeRegistry);
 

diff --git a/core/src/main/java/cucumber/runtime/FeaturePathFeatureSupplier.java b/core/src/main/java/cucumber/runtime/FeaturePathFeatureSupplier.java
@@ -2,6 +2,7 @@
 
 import cucumber.runtime.model.CucumberFeature;
 import cucumber.runtime.model.FeatureLoader;
+import io.cucumber.core.options.FeatureOptions;
 
 import java.util.List;
 
@@ -10,15 +11,15 @@
  */
 public class FeaturePathFeatureSupplier implements FeatureSupplier {
     private final FeatureLoader featureLoader;
-    private final RuntimeOptions runtimeOptions;
+    private final FeatureOptions featureOptions;
 
-    public FeaturePathFeatureSupplier(FeatureLoader featureLoader, RuntimeOptions runtimeOptions) {
+    public FeaturePathFeatureSupplier(FeatureLoader featureLoader, FeatureOptions featureOptions) {
         this.featureLoader = featureLoader;
-        this.runtimeOptions = runtimeOptions;
+        this.featureOptions = featureOptions;
     }
 
     @Override
     public List<CucumberFeature> get() {
-        return featureLoader.load(runtimeOptions.getFeaturePaths(), System.out);
+        return featureLoader.load(featureOptions.getFeaturePaths(), System.out);
     }
 }
diff --git a/core/src/main/java/cucumber/runtime/RuntimeOptions.java b/core/src/main/java/cucumber/runtime/RuntimeOptions.java
@@ -1,6 +1,10 @@
 package cucumber.runtime;
 
 import cucumber.api.SnippetType;
+import io.cucumber.core.options.FeatureOptions;
+import io.cucumber.core.options.FilterOptions;
+import io.cucumber.core.options.PluginOptions;
+import io.cucumber.core.options.RunnerOptions;
 import io.cucumber.datatable.DataTable;
 import cucumber.runtime.formatter.PluginFactory;
 import cucumber.runtime.model.PathWithLines;
@@ -9,7 +13,6 @@
 import gherkin.GherkinDialect;
 import gherkin.GherkinDialectProvider;
 import gherkin.IGherkinDialectProvider;
-import io.cucumber.datatable.DataTable;
 
 import java.io.InputStreamReader;
 import java.io.Reader;
@@ -25,7 +28,7 @@
 import static java.util.Arrays.asList;
 
 // IMPORTANT! Make sure USAGE.txt is always uptodate if this class changes.
-public class RuntimeOptions {
+public class RuntimeOptions implements FeatureOptions, FilterOptions, PluginOptions, RunnerOptions {
     public static final String VERSION = ResourceBundle.getBundle("cucumber.version").getString("cucumber-jvm.version");
     public static final String USAGE_RESOURCE = "/cucumber/api/cli/USAGE.txt";
 
@@ -111,18 +114,6 @@ public RuntimeOptions noSummaryPrinter() {
         return this;
     }
 
-    public List<String> getPluginFormatterNames() {
-        return pluginFormatterNames;
-    }
-
-    public List<String> getPluginSummaryPrinterNames() {
-        return pluginSummaryPrinterNames;
-    }
-
-    public List<String> getPluginStepDefinitionReporterNames() {
-        return pluginStepDefinitionReporterNames;
-    }
-
     private void parse(List<String> args) {
         List<String> parsedTagFilters = new ArrayList<String>();
         List<Pattern> parsedNameFilters = new ArrayList<Pattern>();
@@ -300,14 +291,26 @@ private void addKeywordRow(List<List<String>> table, String key, List<String> ke
         table.add(cells);
     }
 
+    @Override
+    public List<String> getPluginNames() {
+        List<String> pluginNames = new ArrayList<>();
+        pluginNames.addAll(pluginFormatterNames);
+        pluginNames.addAll(pluginStepDefinitionReporterNames);
+        pluginNames.addAll(pluginSummaryPrinterNames);
+        return pluginNames;
+    }
+
+    @Override
     public List<String> getGlue() {
         return glue;
     }
 
+    @Override
     public boolean isStrict() {
         return strict;
     }
 
+    @Override
     public boolean isDryRun() {
         return dryRun;
     }
@@ -316,26 +319,32 @@ public boolean isWip() {
         return wip;
     }
 
+    @Override
     public List<String> getFeaturePaths() {
         return featurePaths;
     }
 
+    @Override
     public List<Pattern> getNameFilters() {
         return nameFilters;
     }
 
+    @Override
     public List<String> getTagFilters() {
         return tagFilters;
     }
 
+    @Override
     public Map<String, List<Long>> getLineFilters() {
         return lineFilters;
     }
 
+    @Override
     public boolean isMonochrome() {
         return monochrome;
     }
 
+    @Override
     public SnippetType getSnippetType() {
         return snippetType;
     }

diff --git a/core/src/main/java/cucumber/runtime/filter/Filters.java b/core/src/main/java/cucumber/runtime/filter/Filters.java
@@ -1,7 +1,7 @@
 package cucumber.runtime.filter;
 
-import cucumber.runtime.RuntimeOptions;
 import gherkin.events.PickleEvent;
+import io.cucumber.core.options.FilterOptions;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -11,23 +11,23 @@
 public class Filters {
 
     private final List<PicklePredicate> filters;
-    private final RuntimeOptions runtimeOptions;
+    private final FilterOptions runtimeOptions;
     private final RerunFilters rerunFilters;
 
-    public Filters(RuntimeOptions runtimeOptions, RerunFilters rerunFilters) {
+    public Filters(FilterOptions filterOPtions, RerunFilters rerunFilters) {
-        this.runtimeOptions = runtimeOptions;
+        this.runtimeOptions = filterOPtions;
         this.rerunFilters = rerunFilters;
 
         filters = new ArrayList<PicklePredicate>();
         List<String> tagFilters = this.runtimeOptions.getTagFilters();
         if (!tagFilters.isEmpty()) {
             this.filters.add(new TagPredicate(tagFilters));
         }
-        List<Pattern> nameFilters = runtimeOptions.getNameFilters();
+        List<Pattern> nameFilters = filterOPtions.getNameFilters();
         if (!nameFilters.isEmpty()) {
             this.filters.add(new NamePredicate(nameFilters));
         }
-        Map<String, List<Long>> lineFilters = runtimeOptions.getLineFilters();
+        Map<String, List<Long>> lineFilters = filterOPtions.getLineFilters();
         Map<String, List<Long>> rerunlineFilters = rerunFilters.processRerunFiles();
         for (Map.Entry<String,List<Long>> line: rerunlineFilters.entrySet()) {
             addLineFilters(lineFilters, line.getKey(), line.getValue());

diff --git a/core/src/main/java/cucumber/runtime/filter/RerunFilters.java b/core/src/main/java/cucumber/runtime/filter/RerunFilters.java
@@ -1,6 +1,6 @@
 package cucumber.runtime.filter;
 
-import cucumber.runtime.RuntimeOptions;
+import io.cucumber.core.options.FeatureOptions;
 import cucumber.runtime.model.FeatureLoader;
 import cucumber.runtime.model.PathWithLines;
 
@@ -9,18 +9,17 @@
 import java.util.Map;
 
 public class RerunFilters {
-    private final RuntimeOptions runtimeOptions;
+    private final FeatureOptions featureOptions;
     private final FeatureLoader featureLoader;
 
-    public RerunFilters(RuntimeOptions runtimeOptions, FeatureLoader featureLoader) {
+    public RerunFilters(FeatureOptions featureOptions, FeatureLoader featureLoader) {
-        this.runtimeOptions = runtimeOptions;
+        this.featureOptions = featureOptions;
         this.featureLoader = featureLoader;
     }
 
-
     Map<String, List<Long>> processRerunFiles() {
         final Map<String, List<Long>> lineFilters = new HashMap<String, List<Long>>();
-        for (String featurePath : runtimeOptions.getFeaturePaths()) {
+        for (String featurePath : featureOptions.getFeaturePaths()) {
             if (featurePath.startsWith("@")) {
                 for (PathWithLines pathWithLines : featureLoader.loadRerunFile(featurePath.substring(1))) {
                     addLineFilters(lineFilters, pathWithLines.path, pathWithLines.lines);