[Core] Add --publish option

.travis.yml

@@ -20,13 +20,19 @@ jobs:
     - stage: test
       jdk: openjdk11
       script: mvn verify -P-spotless-apply --toolchains .travis-toolchains.xml
-      env: VERIFY=true
+      env:
+      - VERIFY=true
+        # Override https://messages.cucumber.io/api/reports because the subdomain is not yet set up
+        # Remove this when it is.
+      - CUCUMBER_PLUGIN_PUBLISH_URL=https://b1f2yk58d8.execute-api.eu-west-3.amazonaws.com/api/reports
+      - CUCUMBER_PLUGIN_PUBLISH_TOKEN=trigger/build/with/publish/plugin
 
       # 1.3 Coverage
     - stage: test
       jdk: openjdk11
       script: mvn jacoco:prepare-agent verify jacoco:report coveralls:report --toolchains .travis-toolchains.xml
-      env: COVERAGE=true
+      env:
+      - COVERAGE=true
 
     # 1.4 Javadoc
     - jdk: openjdk11

core/src/main/java/io/cucumber/core/options/CommandlineOptionsParser.java

@@ -91,6 +91,8 @@ private RuntimeOptionsBuilder parse(List<String> args) {
                 parsedOptions.addGlue(parse);
             } else if (arg.equals("--tags") || arg.equals("-t")) {
                 parsedOptions.addTagFilter(TagExpressionParser.parse(removeArgFor(arg, args)));
+            } else if (arg.equals("--publish")) {
+                parsedOptions.setPublish(true);
             } else if (arg.equals("--plugin") || arg.equals("-p")) {
                 parsedOptions.addPluginName(removeArgFor(arg, args));
             } else if (arg.equals("--no-dry-run") || arg.equals("--dry-run") || arg.equals("-d")) {
@@ -140,6 +142,7 @@ private RuntimeOptionsBuilder parse(List<String> args) {
                 }
             }
         }
+
         return parsedOptions;
     }
 

core/src/main/java/io/cucumber/core/options/Constants.java

@@ -152,6 +152,29 @@ public final class Constants {
      */
     public static final String PLUGIN_PROPERTY_NAME = "cucumber.plugin";
 
+    /**
+     * Setting this to true will enable publishing.
+     */
+    public static final String PLUGIN_PUBLISH_ENABLED_PROPERTY_NAME = "cucumber.plugin.publish.enabled";
+
+    // TODO: Document consistently with other parameters.
+    /**
+     * Setting this to true will enable publishing with a Bearer token.
+     */
+    public static final String PLUGIN_PUBLISH_TOKEN_PROPERTY_NAME = "cucumber.plugin.publish.token";
+
+    /**
+     * Defining this will override the publishing URL (it is not sufficient to
+     * activate publishing).
+     */
+    public static final String PLUGIN_PUBLISH_URL_PROPERTY_NAME = "cucumber.plugin.publish.url";
+
+    /**
+     * Setting this to true will prevent the publish advertising banner from
+     * being printed.
+     */
+    public static final String PLUGIN_PUBLISH_QUIET_PROPERTY_NAME = "cucumber.plugin.publish.quiet";
+
     /**
      * Property name to control naming convention for generated snippets:
      * {@value}

core/src/main/java/io/cucumber/core/options/CucumberOptionsAnnotationParser.java

@@ -39,6 +39,7 @@ public RuntimeOptionsBuilder parse(Class<?> clazz) {
                 addMonochrome(options, args);
                 addTags(classWithOptions, options, args);
                 addPlugins(options, args);
+                addPublish(options, args);
                 addStrict(options, args);
                 addName(options, args);
                 addSnippets(options, args);
@@ -87,6 +88,12 @@ private void addPlugins(CucumberOptions options, RuntimeOptionsBuilder args) {
         }
     }
 
+    private void addPublish(CucumberOptions options, RuntimeOptionsBuilder args) {
+        if (options.publish()) {
+            args.setPublish(true);
+        }
+    }
+
     private void addStrict(CucumberOptions options, RuntimeOptionsBuilder args) {
         if (!options.strict()) {
             throw new CucumberException(
@@ -199,6 +206,8 @@ public interface CucumberOptions {
 
         String[] plugin();
 
+        boolean publish();
+
         boolean monochrome();
 
         String[] name();

core/src/main/java/io/cucumber/core/options/CucumberProperties.java

@@ -5,13 +5,16 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.AbstractMap;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Set;
 
 import static io.cucumber.core.options.Constants.CUCUMBER_PROPERTIES_FILE_NAME;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Store properties.
@@ -58,43 +61,37 @@ public static Map<String, String> fromPropertiesFile() {
 
     public static Map<String, String> fromEnvironment() {
         Map<String, String> p = System.getenv();
-        CucumberPropertiesMap properties = new CucumberPropertiesMap();
-        properties.putAll(p);
-        return properties;
+        return new CucumberPropertiesMap(p);
     }
 
     public static Map<String, String> fromSystemProperties() {
         Properties p = System.getProperties();
         return CucumberPropertiesMap.create(p);
     }
 
-    static class CucumberPropertiesMap extends HashMap<String, String> {
+    static class CucumberPropertiesMap extends AbstractMap<String, String> {
 
         private final CucumberPropertiesMap parent;
+        private final Map<String, String> delegate;
 
-        CucumberPropertiesMap() {
-            this(null);
-        }
-
-        CucumberPropertiesMap(CucumberPropertiesMap parent) {
-            this(parent, Collections.emptyMap());
+        CucumberPropertiesMap(CucumberPropertiesMap parent, Map<String, String> delegate) {
+            this.delegate = requireNonNull(delegate);
+            this.parent = parent;
         }
 
-        CucumberPropertiesMap(CucumberPropertiesMap parent, Map<String, String> properties) {
-            super(properties);
-            this.parent = parent;
+        CucumberPropertiesMap(Map<String, String> delegate) {
+            this(null, delegate);
         }
 
-        CucumberPropertiesMap(Map<String, String> properties) {
-            this(null, properties);
+        @Override
+        public Set<Entry<String, String>> entrySet() {
+            return delegate.entrySet();
         }
 
         private static CucumberPropertiesMap create(Properties p) {
-            CucumberPropertiesMap properties = new CucumberPropertiesMap();
-            for (String key : p.stringPropertyNames()) {
-                properties.put(key, p.getProperty(key));
-            }
-            return properties;
+            Map<String, String> copy = new HashMap<>();
+            p.stringPropertyNames().forEach(s -> copy.put(s, p.getProperty(s)));
+            return new CucumberPropertiesMap(copy);
         }
 
         @Override

core/src/main/java/io/cucumber/core/options/CucumberPropertiesParser.java

@@ -26,6 +26,9 @@
 import static io.cucumber.core.options.Constants.GLUE_PROPERTY_NAME;
 import static io.cucumber.core.options.Constants.OBJECT_FACTORY_PROPERTY_NAME;
 import static io.cucumber.core.options.Constants.PLUGIN_PROPERTY_NAME;
+import static io.cucumber.core.options.Constants.PLUGIN_PUBLISH_ENABLED_PROPERTY_NAME;
+import static io.cucumber.core.options.Constants.PLUGIN_PUBLISH_QUIET_PROPERTY_NAME;
+import static io.cucumber.core.options.Constants.PLUGIN_PUBLISH_TOKEN_PROPERTY_NAME;
 import static io.cucumber.core.options.Constants.SNIPPET_TYPE_PROPERTY_NAME;
 import static io.cucumber.core.options.Constants.WIP_PROPERTY_NAME;
 import static io.cucumber.core.options.OptionsFileParser.parseFeatureWithLinesFile;
@@ -97,6 +100,21 @@ public RuntimeOptionsBuilder parse(Map<String, String> properties) {
             splitAndMap(Function.identity()),
             builder::addPluginName);
 
+        parse(properties,
+            PLUGIN_PUBLISH_TOKEN_PROPERTY_NAME,
+            PublishTokenParser::parse,
+            builder::setPublishToken);
+
+        parse(properties,
+            PLUGIN_PUBLISH_ENABLED_PROPERTY_NAME,
+            Boolean::parseBoolean,
+            builder::setPublish);
+
+        parse(properties,
+            PLUGIN_PUBLISH_QUIET_PROPERTY_NAME,
+            Boolean::parseBoolean,
+            builder::setPublishQuiet);
+
         parse(properties,
             SNIPPET_TYPE_PROPERTY_NAME,
             SnippetTypeParser::parseSnippetType,

core/src/main/java/io/cucumber/core/options/CurlOption.java

@@ -13,7 +13,7 @@ public final class CurlOption {
     private final HttpMethod method;
     private final List<Entry<String, String>> headers;
 
-    CurlOption(URI uri, HttpMethod method, List<Entry<String, String>> headers) {
+    public CurlOption(URI uri, HttpMethod method, List<Entry<String, String>> headers) {
         this.uri = uri;
         this.method = method;
         this.headers = headers;

core/src/main/java/io/cucumber/core/options/PluginOption.java

@@ -31,6 +31,7 @@
 
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Collections.unmodifiableSet;
+import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.joining;
 
 public class PluginOption implements Options.Plugin {
@@ -88,8 +89,8 @@ public class PluginOption implements Options.Plugin {
     private final String argument;
 
     private PluginOption(String pluginString, Class<? extends Plugin> pluginClass, String argument) {
-        this.pluginString = pluginString;
-        this.pluginClass = pluginClass;
+        this.pluginString = requireNonNull(pluginString);
+        this.pluginClass = requireNonNull(pluginClass);
         this.argument = argument;
     }
 
@@ -104,6 +105,19 @@ public static PluginOption parse(String pluginSpecification) {
         return new PluginOption(pluginSpecification, pluginClass, pluginWithFile.group(2));
     }
 
+    public static PluginOption forClass(Class<? extends Plugin> pluginClass, String argument) {
+        requireNonNull(pluginClass);
+        requireNonNull(argument);
+        String name = pluginClass.getName();
+        return new PluginOption(name + ":" + argument, pluginClass, argument);
+    }
+
+    public static PluginOption forClass(Class<? extends Plugin> pluginClass) {
+        requireNonNull(pluginClass);
+        String name = pluginClass.getName();
+        return new PluginOption(name, pluginClass, null);
+    }
+
     @SuppressWarnings("unchecked")
     private static Class<? extends Plugin> parsePluginName(String pluginSpecification, String pluginName) {
         // Refuse plugins known to implement the old API

core/src/main/java/io/cucumber/core/options/PublishTokenParser.java

@@ -0,0 +1,20 @@
+package io.cucumber.core.options;
+
+import java.util.regex.Pattern;
+
+public final class PublishTokenParser {
+
+    private PublishTokenParser() {
+
+    }
+
+    public static String parse(String argument) {
+        Pattern pattern = Pattern.compile("^[A-Za-z0-9+/=]+$");
+        if (argument == null || !pattern.matcher(argument).matches()) {
+            throw new IllegalArgumentException(
+                "Invalid token. A token must consist of a RFC4648 Base64 encoded string");
+        }
+        return argument;
+    }
+
+}

core/src/main/java/io/cucumber/core/options/RuntimeOptions.java

@@ -4,6 +4,8 @@
 import io.cucumber.core.feature.FeatureWithLines;
 import io.cucumber.core.order.PickleOrder;
 import io.cucumber.core.order.StandardPickleOrders;
+import io.cucumber.core.plugin.NoPublishFormatter;
+import io.cucumber.core.plugin.PublishFormatter;
 import io.cucumber.core.snippets.SnippetType;
 import io.cucumber.tagexpressions.Expression;
 
@@ -20,6 +22,7 @@
 
 import static io.cucumber.core.resource.ClasspathSupport.rootPackageUri;
 import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
 import static java.util.Collections.unmodifiableList;
 import static java.util.Collections.unmodifiableMap;
 
@@ -44,6 +47,9 @@ public final class RuntimeOptions implements
     private PickleOrder pickleOrder = StandardPickleOrders.lexicalUriOrder();
     private int count = 0;
     private Class<? extends ObjectFactory> objectFactoryClass;
+    private String publishToken;
+    private boolean publish;
+    private boolean publishQuiet;
 
     private RuntimeOptions() {
 
@@ -102,9 +108,23 @@ public List<Plugin> plugins() {
         List<Plugin> plugins = new ArrayList<>();
         plugins.addAll(formatters);
         plugins.addAll(summaryPrinters);
+        plugins.addAll(getPublishPlugin());
         return plugins;
     }
 
+    private List<Plugin> getPublishPlugin() {
+        if (publishToken != null) {
+            return singletonList(PluginOption.forClass(PublishFormatter.class, publishToken));
+        }
+        if (publish) {
+            return singletonList(PluginOption.forClass(PublishFormatter.class));
+        }
+        if (publishQuiet) {
+            return emptyList();
+        }
+        return singletonList(PluginOption.forClass(NoPublishFormatter.class));
+    }
+
     @Override
     public boolean isMonochrome() {
         return monochrome;
@@ -229,4 +249,15 @@ void setPickleOrder(PickleOrder pickleOrder) {
         this.pickleOrder = pickleOrder;
     }
 
+    void setPublishToken(String token) {
+        this.publishToken = token;
+    }
+
+    public void setPublish(boolean publish) {
+        this.publish = publish;
+    }
+
+    public void setPublishQuiet(boolean publishQuiet) {
+        this.publishQuiet = publishQuiet;
+    }
 }

core/src/main/java/io/cucumber/core/options/RuntimeOptionsBuilder.java

@@ -36,6 +36,9 @@ public final class RuntimeOptionsBuilder {
     private boolean addDefaultFormatterIfAbsent;
     private boolean addDefaultGlueIfAbsent;
     private boolean addDefaultFeaturePathIfAbsent;
+    private String parsedPublishToken = null;
+    private Boolean parsedPublish;
+    private Boolean parsedPublishQuiet;
 
     public RuntimeOptionsBuilder addRerun(Collection<FeatureWithLines> featureWithLines) {
         if (parsedRerunPaths == null) {
@@ -149,6 +152,18 @@ public RuntimeOptions build(RuntimeOptions runtimeOptions) {
             runtimeOptions.addDefaultFeaturePathIfAbsent();
         }
 
+        if (parsedPublishToken != null) {
+            runtimeOptions.setPublishToken(parsedPublishToken);
+        }
+
+        if (parsedPublish != null) {
+            runtimeOptions.setPublish(parsedPublish);
+        }
+
+        if (parsedPublishQuiet != null) {
+            runtimeOptions.setPublishQuiet(parsedPublishQuiet);
+        }
+
         return runtimeOptions;
     }
 
@@ -224,4 +239,16 @@ public RuntimeOptionsBuilder addDefaultFeaturePathIfAbsent() {
     public void setObjectFactoryClass(Class<? extends ObjectFactory> objectFactoryClass) {
         this.parsedObjectFactoryClass = objectFactoryClass;
     }
+
+    public void setPublishToken(String token) {
+        this.parsedPublishToken = token;
+    }
+
+    public void setPublish(boolean publish) {
+        this.parsedPublish = publish;
+    }
+
+    public void setPublishQuiet(boolean publishQuiet) {
+        this.parsedPublishQuiet = publishQuiet;
+    }
 }

core/src/main/java/io/cucumber/core/plugin/AnsiEscapes.java

@@ -1,7 +1,6 @@
 package io.cucumber.core.plugin;
 
 final class AnsiEscapes {
-
     static final AnsiEscapes RESET = color(0);
     static final AnsiEscapes BLACK = color(30);
     static final AnsiEscapes RED = color(31);