Add default formatter when no formatter plugin is specified.

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

@@ -31,7 +31,8 @@ public class RuntimeOptions {
     private final List<String> glue = new ArrayList<String>();
     private final List<Object> filters = new ArrayList<Object>();
     private final List<String> featurePaths = new ArrayList<String>();
-    private final List<String> pluginNames = new ArrayList<String>();
+    private final List<String> pluginFormatterNames = new ArrayList<String>();
+    private final List<String> pluginStepDefinitionReporterNames = new ArrayList<String>();
     private final PluginFactory pluginFactory;
     private final List<Object> plugins = new ArrayList<Object>();
     private boolean dryRun;
@@ -81,8 +82,8 @@ public RuntimeOptions(Env env, PluginFactory pluginFactory, List<String> argv) {
             parse(Shellwords.parse(cucumberOptionsFromEnv));
         }
 
-        if (pluginNames.isEmpty()) {
-            pluginNames.add("progress");
+        if (pluginFormatterNames.isEmpty()) {
+            pluginFormatterNames.add("progress");
         }
     }
 
@@ -109,10 +110,10 @@ private void parse(List<String> args) {
             } else if (arg.equals("--tags") || arg.equals("-t")) {
                 parsedFilters.add(args.remove(0));
             } else if (arg.equals("--plugin") || arg.equals("-p")) {
-                pluginNames.add(args.remove(0));
+                addPluginName(args.remove(0));
             } else if (arg.equals("--format") || arg.equals("-f")) {
                 System.err.println("WARNING: Cucumber-JVM's --format option is deprecated. Please use --plugin instead.");
-                pluginNames.add(args.remove(0));
+                addPluginName(args.remove(0));
             } else if (arg.equals("--no-dry-run") || arg.equals("--dry-run") || arg.equals("-d")) {
                 dryRun = !arg.startsWith("--no-");
             } else if (arg.equals("--no-strict") || arg.equals("--strict") || arg.equals("-s")) {
@@ -150,6 +151,16 @@ private void parse(List<String> args) {
         }
     }
 
+    private void addPluginName(String name) {
+        if (pluginFactory.isFormatterName(name)) {
+            pluginFormatterNames.add(name);
+        } else if (pluginFactory.isStepDefinitionResporterName(name)) {
+            pluginStepDefinitionReporterNames.add(name);
+        } else {
+            throw new CucumberException("Unrecognized plugin: " + name);
+        }
+    }
+
     private boolean haveLineFilters(List<String> parsedFeaturePaths) {
         for (String pathName : parsedFeaturePaths) {
             if (pathName.startsWith("@") || PathWithLines.hasLineFilters(pathName)) {
@@ -203,12 +214,16 @@ public List<CucumberFeature> cucumberFeatures(ResourceLoader resourceLoader) {
 
     List<Object> getPlugins() {
         if (!pluginNamesInstantiated) {
-            for (String pluginName : pluginNames) {
+            for (String pluginName : pluginFormatterNames) {
                 Object plugin = pluginFactory.create(pluginName);
                 plugins.add(plugin);
                 setMonochromeOnColorAwarePlugins(plugin);
                 setStrictOnStrictAwarePlugins(plugin);
             }
+            for (String pluginName : pluginStepDefinitionReporterNames) {
+                Object plugin = pluginFactory.create(pluginName);
+                plugins.add(plugin);
+            }
             pluginNamesInstantiated = true;
         }
         return plugins;

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

@@ -1,6 +1,7 @@
 package cucumber.runtime;
 
 import cucumber.api.CucumberOptions;
+import cucumber.runtime.formatter.PluginFactory;
 import cucumber.runtime.io.MultiLoader;
 
 import java.util.ArrayList;
@@ -85,7 +86,9 @@ private void addPlugins(CucumberOptions options, List<String> args) {
         for (String plugin : plugins) {
             args.add("--plugin");
             args.add(plugin);
-            pluginSpecified = true;
+            if (PluginFactory.isFormatterName(plugin)) {
+                pluginSpecified = true;
+            }
         }
     }
 

core/src/main/java/cucumber/runtime/formatter/PluginFactory.java

@@ -1,8 +1,11 @@
 package cucumber.runtime.formatter;
 
+import cucumber.api.StepDefinitionReporter;
 import cucumber.runtime.CucumberException;
 import cucumber.runtime.io.URLOutputStream;
 import cucumber.runtime.io.UTF8OutputStreamWriter;
+import gherkin.formatter.Formatter;
+import gherkin.formatter.Reporter;
 
 import java.io.File;
 import java.io.IOException;
@@ -150,7 +153,7 @@ private <T> Constructor<T> findConstructor(Class<T> pluginClass, Class<?> ctorAr
         }
     }
 
-    private <T> Class<T> pluginClass(String pluginName) {
+    private static <T> Class<T> pluginClass(String pluginName) {
         Class<T> pluginClass = (Class<T>) PLUGIN_CLASSES.get(pluginName);
         if (pluginClass == null) {
             pluginClass = loadClass(pluginName);
@@ -159,7 +162,7 @@ private <T> Class<T> pluginClass(String pluginName) {
     }
 
     @SuppressWarnings("unchecked")
-    private <T> Class<T> loadClass(String className) {
+    private static <T> Class<T> loadClass(String className) {
         try {
             return (Class<T>) Thread.currentThread().getContextClassLoader().loadClass(className);
         } catch (ClassNotFoundException e) {
@@ -181,4 +184,31 @@ private Appendable defaultOutOrFailIfAlreadyUsed(String formatterString) {
             defaultOut = null;
         }
     }
+
+    public static boolean isFormatterName(String name) {
+        Class pluginClass = getPluginClass(name);
+        if (Formatter.class.isAssignableFrom(pluginClass) || Reporter.class.isAssignableFrom(pluginClass)) {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isStepDefinitionResporterName(String name) {
+        Class pluginClass = getPluginClass(name);
+        if (StepDefinitionReporter.class.isAssignableFrom(pluginClass)) {
+            return true;
+        }
+        return false;
+    }
+
+    private static Class getPluginClass(String name) {
+        Matcher pluginWithFile = PLUGIN_WITH_FILE_PATTERN.matcher(name);
+        String pluginName;
+        if (pluginWithFile.matches()) {
+            pluginName = pluginWithFile.group(1);
+        } else {
+            pluginName = name;
+        }
+        return pluginClass(pluginName);
+    }
 }

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

@@ -94,6 +94,21 @@ public void finds_path_for_class_in_toplevel_package() {
         assertEquals("", packageName("TopLevelClass"));
     }
 
+    @Test
+    public void create_null_formatter_when_no_formatter_plugin_is_defined() {
+        RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(ClassWithNoFormatterPlugin.class);
+        RuntimeOptions runtimeOptions = runtimeOptionsFactory.create();
+
+        List<Object> plugins = runtimeOptions.getPlugins();
+        boolean found = false;
+        for (Object plugin : plugins) {
+            if ("cucumber.runtime.formatter.NullFormatter".equals(plugin.getClass().getName())) {
+                found = true;
+            }
+        }
+        assertTrue("NullFormatter not found among plugins", found);
+    }
+
     @Test
     public void inherit_plugin_from_baseclass() {
         RuntimeOptionsFactory runtimeOptionsFactory = new RuntimeOptionsFactory(SubClassWithFormatter.class);
@@ -165,4 +180,9 @@ static class SubClassWithMonoChromeTrue extends BaseClassWithMonoChromeFalse {
     static class BaseClassWithMonoChromeFalse {
         // empty
     }
+
+    @CucumberOptions(plugin = "cucumber.runtime.formatter.AnyStepDefinitionReporter")
+    static class ClassWithNoFormatterPlugin {
+        // empty
+    }
 }

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

@@ -80,6 +80,24 @@ public void creates_html_formatter() {
         assertEquals("cucumber.runtime.formatter.HTMLFormatter", options.getPlugins().get(0).getClass().getName());
     }
 
+    @Test
+    public void creates_progress_formatter_as_default() {
+        RuntimeOptions options = new RuntimeOptions(asList("--glue", "somewhere"));
+        assertEquals("cucumber.runtime.formatter.ProgressFormatter", options.getPlugins().get(0).getClass().getName());
+    }
+
+    @Test
+    public void creates_progress_formatter_when_non_formatter_plugin_is_specified() {
+        RuntimeOptions options = new RuntimeOptions(asList("--plugin", "cucumber.runtime.formatter.AnyStepDefinitionReporter", "--glue", "somewhere"));
+        boolean found = false;
+        for (Object plugin : options.getPlugins()) {
+            if (plugin.getClass().getName() == "cucumber.runtime.formatter.ProgressFormatter") {
+                found = true;
+            }
+        }
+        assertTrue("ProgressFormatter not found among the plugins", found);
+    }
+
     @Test
     public void assigns_strict() {
         RuntimeOptions options = new RuntimeOptions(asList("--strict", "--glue", "somewhere"));
@@ -309,3 +327,4 @@ private void mockResource(ResourceLoader resourceLoader, String featurePath, Str
         when(resourceLoader.resources(featurePath, ".feature")).thenReturn(asList(resource1));
     }
 }
+

core/src/test/java/cucumber/runtime/formatter/AnyStepDefinitionReporter.java

@@ -0,0 +1,17 @@
+package cucumber.runtime.formatter;
+
+import cucumber.api.StepDefinitionReporter;
+import cucumber.runtime.StepDefinition;
+
+public class AnyStepDefinitionReporter implements StepDefinitionReporter {
+
+    public AnyStepDefinitionReporter() {
+        // TODO Auto-generated constructor stub
+    }
+
+    @Override
+    public void stepDefinition(StepDefinition stepDefinition) {
+        // TODO Auto-generated method stub
+    }
+
+}