Print supported languages details (#1290)

Prints code, name, and native name of supported languages
in a three column list.

```
af              Afrikaans                 Afrikaans
am              Armenian                  հայերեն
ar              Arabic                    العربية
ast             Asturian                  asturianu
az              Azerbaijani               Azərbaycanca
...

Author: tsundberg

core/src/main/java/io/cucumber/core/cli/Main.java

@@ -23,7 +23,7 @@
 @API(status = API.Status.STABLE)
 public class Main {
 
-    public static void main(String[] argv) {
+    public static void main(String... argv) {
         byte exitStatus = run(argv, Thread.currentThread().getContextClassLoader());
         System.exit(exitStatus);
     }

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

@@ -17,6 +17,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.ResourceBundle;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -57,10 +58,22 @@ private static int printI18n(String language) {
         List<String> languages = dialectProvider.getLanguages();
 
         if (language.equalsIgnoreCase("help")) {
-            for (String code : languages) {
-                System.out.println(code);
+            if (language.equalsIgnoreCase("help")) {
+                List<GherkinDialect> dialects = new ArrayList<>();
+                for (String code : languages) {
+                    GherkinDialect dialect = dialectProvider.getDialect(code, null);
+                    dialects.add(dialect);
+                }
+
+                int widestLanguage = findWidest(dialects, GherkinDialect::getLanguage);
+                int widestName = findWidest(dialects, GherkinDialect::getName);
+                int widestNativeName = findWidest(dialects, GherkinDialect::getNativeName);
+
+                for (GherkinDialect dialect : dialects) {
+                    printDialect(dialect, widestLanguage, widestName, widestNativeName);
+                }
+                return 0;
             }
-            return 0;
         }
         if (languages.contains(language)) {
             return printKeywordsFor(dialectProvider.getDialect(language, null));
@@ -70,6 +83,14 @@ private static int printI18n(String language) {
         return 1;
     }
 
+    private static int findWidest(List<GherkinDialect> dialects, Function<GherkinDialect, String> getNativeName) {
+        return dialects.stream()
+            .map(getNativeName)
+            .mapToInt(String::length)
+            .max()
+            .orElse(0);
+    }
+
     private static int printKeywordsFor(GherkinDialect dialect) {
         StringBuilder builder = new StringBuilder();
         List<List<String>> table = new ArrayList<>();
@@ -108,6 +129,21 @@ private static void addKeywordRow(List<List<String>> table, String key, List<Str
         table.add(asList(key, keywords.stream().map(o -> '"' + o + '"').collect(joining(", "))));
     }
 
+    private static void printDialect(GherkinDialect dialect, int widestLanguage, int widestName, int widestNativeName) {
+        String langCode = rightPad(dialect.getLanguage(), widestLanguage);
+        String name = rightPad(dialect.getName(), widestName);
+        String nativeName = rightPad(dialect.getNativeName(), widestNativeName);
+
+        System.out.println(langCode + name + nativeName);
+    }
+
+    private static String rightPad(String text, int maxWidth) {
+        int padding = 7;
+        int width = maxWidth + padding;
+
+        return String.format("%" + -width + "s", text);
+    }
+
     RuntimeOptionsBuilder parse(List<String> args) {
         args = new ArrayList<>(args);
         RuntimeOptionsBuilder parsedOptions = new RuntimeOptionsBuilder();
@@ -122,47 +158,47 @@ RuntimeOptionsBuilder parse(List<String> args) {
                 System.out.println(VERSION);
                 System.exit(0);
             } else if (arg.equals("--i18n")) {
-                String nextArg = args.remove(0);
+                String nextArg = removeArgFor(arg, args);
                 System.exit(printI18n(nextArg));
             } else if (arg.equals("--threads")) {
-                int threads = Integer.parseInt(args.remove(0));
+                int threads = Integer.parseInt(removeArgFor(arg, args));
                 if (threads < 1) {
                     throw new CucumberException("--threads must be > 0");
                 }
                 parsedOptions.setThreads(threads);
             } else if (arg.equals("--glue") || arg.equals("-g")) {
-                String gluePath = args.remove(0);
+                String gluePath = removeArgFor(arg, args);
                 URI parse = GluePath.parse(gluePath);
                 parsedOptions.addGlue(parse);
             } else if (arg.equals("--tags") || arg.equals("-t")) {
-                parsedOptions.addTagFilter(args.remove(0));
+                parsedOptions.addTagFilter(removeArgFor(arg, args));
             } else if (arg.equals("--plugin") || arg.equals("--add-plugin") || arg.equals("-p")) {
-                parsedOptions.addPluginName(args.remove(0), arg.equals("--add-plugin"));
+                parsedOptions.addPluginName(removeArgFor(arg, args), arg.equals("--add-plugin"));
             } else if (arg.equals("--no-dry-run") || arg.equals("--dry-run") || arg.equals("-d")) {
                 parsedOptions.setDryRun(!arg.startsWith("--no-"));
             } else if (arg.equals("--no-strict") || arg.equals("--strict") || arg.equals("-s")) {
                 parsedOptions.setStrict(!arg.startsWith("--no-"));
             } else if (arg.equals("--no-monochrome") || arg.equals("--monochrome") || arg.equals("-m")) {
                 parsedOptions.setMonochrome(!arg.startsWith("--no-"));
             } else if (arg.equals("--snippets")) {
-                String nextArg = args.remove(0);
+                String nextArg = removeArgFor(arg, args);
                 parsedOptions.setSnippetType(SnippetTypeParser.parseSnippetType(nextArg));
             } else if (arg.equals("--name") || arg.equals("-n")) {
-                String nextArg = args.remove(0);
+                String nextArg = removeArgFor(arg, args);
                 Pattern pattern = Pattern.compile(nextArg);
                 parsedOptions.addNameFilter(pattern);
             } else if (arg.equals("--wip") || arg.equals("-w")) {
                 parsedOptions.setWip(true);
             } else if (arg.equals("--order")) {
-                parsedOptions.setPickleOrder(PickleOrderParser.parse(args.remove(0)));
+                parsedOptions.setPickleOrder(PickleOrderParser.parse(removeArgFor(arg, args)));
             } else if (arg.equals("--count")) {
-                int count = Integer.parseInt(args.remove(0));
+                int count = Integer.parseInt(removeArgFor(arg, args));
                 if (count < 1) {
                     throw new CucumberException("--count must be > 0");
                 }
                 parsedOptions.setCount(count);
             } else if (arg.equals("--object-factory")) {
-                String objectFactoryClassName = args.remove(0);
+                String objectFactoryClassName = removeArgFor(arg, args);
                 parsedOptions.setObjectFactoryClass(parseObjectFactory(objectFactoryClassName));
             } else if (arg.startsWith("-")) {
                 printUsage();
@@ -181,4 +217,12 @@ RuntimeOptionsBuilder parse(List<String> args) {
         return parsedOptions;
     }
 
+    private String removeArgFor(String arg, List<String> args) {
+        if (!args.isEmpty()) {
+            return args.remove(0);
+        }
+        printUsage();
+        throw new CucumberException("Missing argument for " + arg);
+    }
+
 }

core/src/test/java/io/cucumber/core/cli/MainDemo.java

@@ -0,0 +1,10 @@
+package io.cucumber.core.cli;
+
+public class MainDemo {
+
+    public static void main(String[] args) {
+//        Main.main("--i18n");
+//        Main.main("--i18n", "help");
+        Main.main("--i18n", "tlh");
+    }
+}

core/src/test/java/io/cucumber/core/options/RuntimeOptionsParserTest.java

@@ -16,7 +16,7 @@ final class RuntimeOptionsParserTest {
 
     @Test
     void testParseWithObjectFactoryArgument() {
-        RuntimeOptionsBuilder optionsBuilder = this.parser.parse(Arrays.asList("--object-factory", TestObjectFactory.class.getName()));
+        RuntimeOptionsBuilder optionsBuilder = parser.parse(Arrays.asList("--object-factory", TestObjectFactory.class.getName()));
         assertNotNull(optionsBuilder);
         RuntimeOptions options = optionsBuilder.build();
         assertNotNull(options);