[Core] Updated core for the use of Gherkin v4.0.0.

Author: brasmusson

core/src/main/java/cucumber/api/DataTable.java

@@ -6,10 +6,11 @@
 import cucumber.runtime.table.TableConverter;
 import cucumber.runtime.table.TableDiffException;
 import cucumber.runtime.table.TableDiffer;
+import cucumber.runtime.table.TablePrinter;
 import cucumber.runtime.xstream.LocalizedXStreams;
-import gherkin.formatter.PrettyFormatter;
-import gherkin.formatter.model.DataTableRow;
-import gherkin.formatter.model.Row;
+import gherkin.pickles.PickleCell;
+import gherkin.pickles.PickleRow;
+import gherkin.pickles.PickleTable;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -24,7 +25,7 @@
 public class DataTable {
 
     private final List<List<String>> raw;
-    private final List<DataTableRow> gherkinRows;
+    private final PickleTable pickleTable;
     private final TableConverter tableConverter;
 
     public static DataTable create(List<?> raw) {
@@ -48,17 +49,19 @@ private static DataTable create(List<?> raw, Locale locale, String format, Strin
     /**
      * Creates a new DataTable. This constructor should not be called by Cucumber users - it's used internally only.
      *
-     * @param gherkinRows    the underlying rows.
+     * @param pickleTable    the underlying table.
      * @param tableConverter how to convert the rows.
      */
-    public DataTable(List<DataTableRow> gherkinRows, TableConverter tableConverter) {
-        this.gherkinRows = gherkinRows;
+    public DataTable(PickleTable pickleTable, TableConverter tableConverter) {
+        this.pickleTable = pickleTable;
         this.tableConverter = tableConverter;
-        int columns = gherkinRows.isEmpty() ? 0 : gherkinRows.get(0).getCells().size();
+        int columns = pickleTable.getRows().isEmpty() ? 0 : pickleTable.getRows().get(0).getCells().size();
         List<List<String>> raw = new ArrayList<List<String>>();
-        for (Row row : gherkinRows) {
+        for (PickleRow row : pickleTable.getRows()) {
             List<String> list = new ArrayList<String>();
-            list.addAll(row.getCells());
+            for (PickleCell cell : row.getCells()) {
+                list.add(cell.getValue());
+            }
             if (columns != row.getCells().size()) {
                 throw new CucumberException(String.format("Table is unbalanced: expected %s column(s) but found %s.", columns, row.getCells().size()));
             }
@@ -67,8 +70,8 @@ public DataTable(List<DataTableRow> gherkinRows, TableConverter tableConverter)
         this.raw = Collections.unmodifiableList(raw);
     }
 
-    private DataTable(List<DataTableRow> gherkinRows, List<List<String>> raw, TableConverter tableConverter) {
-        this.gherkinRows = gherkinRows;
+    private DataTable(PickleTable pickleTable, List<List<String>> raw, TableConverter tableConverter) {
+        this.pickleTable = pickleTable;
         this.tableConverter = tableConverter;
         this.raw = Collections.unmodifiableList(raw);
     }
@@ -206,24 +209,23 @@ public void unorderedDiff(List<?> other) throws TableDiffException {
      *
      * @return a list of raw rows.
      */
-    public List<DataTableRow> getGherkinRows() {
-        return Collections.unmodifiableList(gherkinRows);
+    public List<PickleRow> getPickleRows() {
+        return Collections.unmodifiableList(pickleTable.getRows());
     }
 
     @Override
     public String toString() {
         StringBuilder result = new StringBuilder();
-        PrettyFormatter pf = new PrettyFormatter(result, true, false);
-        pf.table(getGherkinRows());
-        pf.eof();
+        TablePrinter printer = createTablePrinter();
+        printer.printTable(raw, result);
         return result.toString();
     }
 
     public List<DiffableRow> diffableRows() {
         List<DiffableRow> result = new ArrayList<DiffableRow>();
         List<List<String>> convertedRows = raw();
         for (int i = 0; i < convertedRows.size(); i++) {
-            result.add(new DiffableRow(getGherkinRows().get(i), convertedRows.get(i)));
+            result.add(new DiffableRow(getPickleRows().get(i), convertedRows.get(i)));
         }
         return result;
     }
@@ -234,9 +236,9 @@ public TableConverter getTableConverter() {
 
     public DataTable transpose() {
         List<List<String>> transposed = new ArrayList<List<String>>();
-        for (int i = 0; i < gherkinRows.size(); i++) {
-            Row gherkinRow = gherkinRows.get(i);
-            for (int j = 0; j < gherkinRow.getCells().size(); j++) {
+        for (int i = 0; i < pickleTable.getRows().size(); i++) {
+            PickleRow pickleRow = pickleTable.getRows().get(i);
+            for (int j = 0; j < pickleRow.getCells().size(); j++) {
                 List<String> row = null;
                 if (j < transposed.size()) {
                     row = transposed.get(j);
@@ -245,10 +247,10 @@ public DataTable transpose() {
                     row = new ArrayList<String>();
                     transposed.add(row);
                 }
-                row.add(gherkinRow.getCells().get(j));
+                row.add(pickleRow.getCells().get(j).getValue());
             }
         }
-        return new DataTable(this.gherkinRows, transposed, this.tableConverter);
+        return new DataTable(this.pickleTable, transposed, this.tableConverter);
     }
 
     @Override
@@ -267,4 +269,8 @@ public boolean equals(Object o) {
     public int hashCode() {
         return raw.hashCode();
     }
+
+    protected TablePrinter createTablePrinter() {
+        return new TablePrinter();
+    }
 }

core/src/main/java/cucumber/api/HookType.java

@@ -0,0 +1,10 @@
+package cucumber.api;
+
+public enum HookType {
+    Before, After;
+
+    @Override
+    public String toString() {
+        return super.toString().toLowerCase();
+    }
+}

core/src/main/java/cucumber/api/Result.java

@@ -0,0 +1,85 @@
+package cucumber.api;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Collections;
+import java.util.List;
+
+public class Result {
+    private static final long serialVersionUID = 1L;
+
+    private final String status;
+    private final Long duration;
+    private final Throwable error;
+    private final List<String> snippets;
+    public static final Result SKIPPED = new Result("skipped", null, null);
+    public static final String UNDEFINED = "undefined";
+    public static final String PASSED = "passed";
+    public static final String PENDING = "pending";
+    public static final String FAILED = "failed";
+
+    /**
+     * Used at runtime
+     *
+     * @param status
+     * @param duration
+     * @param error
+     */
+    public Result(String status, Long duration, Throwable error) {
+        this(status, duration, error, Collections.<String>emptyList());
+    }
+
+    /**
+     * Used at runtime
+     *
+     * @param status
+     * @param duration
+     * @param error
+     * @param snippets
+     */
+    public Result(String status, Long duration, Throwable error, List<String> snippets) {
+        this.status = status;
+        this.duration = duration;
+        this.error = error;
+        this.snippets = snippets;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public Long getDuration() {
+        return duration;
+    }
+
+    public String getErrorMessage() {
+        return error != null ? getErrorMessage(error) : null;
+    }
+
+    public Throwable getError() {
+        return error;
+    }
+
+    public List<String> getSnippets() {
+        return snippets;
+    }
+
+    public boolean isOk(boolean isStrict) {
+        return hasAlwaysOkStatus() || !isStrict && hasOkWhenNotStrictStatus();
+    }
+
+    private boolean hasAlwaysOkStatus() {
+        return Result.PASSED.equals(status) || Result.SKIPPED.getStatus().equals(status);
+    }
+
+    private boolean hasOkWhenNotStrictStatus() {
+        return Result.UNDEFINED.equals(status) || Result.PENDING.equals(status);
+    }
+
+    private String getErrorMessage(Throwable error) {
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter printWriter = new PrintWriter(stringWriter);
+        error.printStackTrace(printWriter);
+        return stringWriter.getBuffer().toString();
+    }
+}

core/src/main/java/cucumber/api/Scenario.java

@@ -51,9 +51,4 @@ public interface Scenario {
      * @return the name of the Scenario
      */
     String getName();
-
-    /**
-     * @return the id of the Scenario.
-     */
-    String getId();
 }

core/src/main/java/cucumber/api/TestCase.java

@@ -0,0 +1,70 @@
+package cucumber.api;
+
+import cucumber.api.event.TestCaseFinished;
+import cucumber.api.event.TestCaseStarted;
+import cucumber.runner.EventBus;
+import cucumber.runtime.ScenarioImpl;
+import gherkin.pickles.Pickle;
+import gherkin.pickles.PickleLocation;
+import gherkin.pickles.PickleTag;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+import java.util.List;
+
+public class TestCase {
+    private final Pickle pickle;
+    private final List<TestStep> testSteps;
+
+    public TestCase(List<TestStep> testSteps, Pickle pickle) {
+        this.testSteps = testSteps;
+        this.pickle = pickle;
+    }
+
+    public void run(EventBus bus, String language) {
+        boolean skipNextStep = false;
+        bus.send(new TestCaseStarted(this));
+        ScenarioImpl scenarioResult = new ScenarioImpl(bus, pickle);
+        for (TestStep step : testSteps) {
+            Result stepResult = step.run(bus, language, scenarioResult, skipNextStep);
+            if (stepResult.getStatus() != Result.PASSED) {
+                skipNextStep = true;
+            }
+            scenarioResult.add(stepResult);
+        }
+        bus.send(new TestCaseFinished(this, new Result(scenarioResult.getStatus(), null, null)));
+    }
+
+    public String getName() {
+        return pickle.getName();
+    }
+
+    public String getScenarioDesignation() {
+        return fileColonLine(pickle.getLocations().get(0)) + " # " + getName();
+    }
+
+    public String getPath() {
+        return pickle.getLocations().get(0).getPath();
+    }
+
+    public int getLine() {
+        return pickle.getLocations().get(0).getLine();
+    }
+
+    private String fileColonLine(PickleLocation location) {
+        return location.getPath() + ":" + Integer.toString(location.getLine());
+    }
+
+    public List<PickleTag> getTags() {
+        List<PickleTag> tags;
+        try { // TODO: Fix when Gherkin provide a getter for the tags.
+            Field f;
+            f = pickle.getClass().getDeclaredField("tags");
+            f.setAccessible(true);
+            tags = (List<PickleTag>) f.get(pickle);
+        } catch (Exception e) {
+            tags = Collections.<PickleTag>emptyList();
+        }
+        return tags;
+    }
+}