Make it easier to create a DataTable

aslakhellesoy · aslakhellesoy · commit 97f14d5240ae · 2012-04-11T00:23:30.000+01:00
diff --git a/History.md b/History.md
@@ -1,3 +1,7 @@
+## [Git master](https://github.com/cucumber/cucumber-jvm/compare/v1.0.1...master)
+
+* [Core] Added DataTable.toTable(List<?> other) for creating a new table. Handy for printing a table when diffing isn't helpful. (Aslak Hellesøy)
+
 ## [1.0.2](https://github.com/cucumber/cucumber-jvm/compare/v1.0.1...v1.0.2)
 
 * [Java] Snippets using a table have a hint about how to use List<YourClass>. (Aslak Hellesøy)
diff --git a/core/src/main/java/cucumber/runtime/StepDefinitionMatch.java b/core/src/main/java/cucumber/runtime/StepDefinitionMatch.java
@@ -134,7 +134,7 @@ public List<String> map(DataTableRow row) {
     }
 
     private Object tableArgument(Step step, int argIndex, XStream xStream, String dateFormat) {
-        DataTable table = new DataTable(step.getRows(), new TableConverter(xStream, dateFormat));
+        DataTable table = new DataTable(step.getRows(), new TableConverter(xStream));
 
         Type listType = getGenericListType(argIndex);
         if (listType != null) {
diff --git a/core/src/main/java/cucumber/table/DataTable.java b/core/src/main/java/cucumber/table/DataTable.java
@@ -1,5 +1,7 @@
 package cucumber.table;
 
+import cucumber.runtime.converters.LocalizedXStreams;
+import gherkin.I18n;
 import gherkin.formatter.PrettyFormatter;
 import gherkin.formatter.model.DataTableRow;
 import gherkin.formatter.model.Row;
@@ -14,6 +16,11 @@ public class DataTable {
     private final List<DataTableRow> gherkinRows;
     private final TableConverter tableConverter;
 
+    public static DataTable create(List<?> raw) {
+        TableConverter tableConverter = new TableConverter(new LocalizedXStreams(Thread.currentThread().getContextClassLoader()).get(new I18n("en")));
+        return tableConverter.toTable(raw);
+    }
+
     public DataTable(List<DataTableRow> gherkinRows, TableConverter tableConverter) {
         this.gherkinRows = gherkinRows;
         this.tableConverter = tableConverter;
@@ -54,11 +61,28 @@ private List<String> toStrings(Row row) {
         return strings;
     }
 
-    public void diff(List<List<String>> other) {
-        diff(tableConverter.toTable(other));
+    public DataTable toTable(List<?> raw) {
+        return tableConverter.toTable(raw);
+    }
+
+    /**
+     * Diffs this table with {@code other}, which can be a {@code List<List<String>>} or a
+     * {@code List<YourType>}.
+     *
+     * @param other the other table to diff with.
+     * @throws TableDiffException if the tables are different.
+     */
+    public void diff(List<?> other) throws TableDiffException {
+        diff(toTable(other));
     }
 
-    private void diff(DataTable other) {
+    /**
+     * Diffs this table with {@code other}.
+     *
+     * @param other the other table to diff with.
+     * @throws TableDiffException if the tables are different.
+     */
+    public void diff(DataTable other) throws TableDiffException {
         new TableDiffer(this, other).calculateDiffs();
     }
 
diff --git a/core/src/main/java/cucumber/table/TableConverter.java b/core/src/main/java/cucumber/table/TableConverter.java
@@ -23,11 +23,9 @@
 
 public class TableConverter {
     private final XStream xStream;
-    private final String dateFormat;
 
-    public TableConverter(XStream xStream, String dateFormat) {
+    public TableConverter(XStream xStream) {
         this.xStream = xStream;
-        this.dateFormat = dateFormat;
     }
 
     /**
@@ -51,10 +49,11 @@ public <T> List<T> toList(Type itemType, DataTable dataTable) {
     /**
      * Converts a List of objects to a DataTable.
      *
-     * @param objects the objects to convers
+     * @param objects     the objects to convert
+     * @param columnNames an explicit list of column names (currently not used)
      * @return a DataTable
      */
-    public DataTable toTable(List<?> objects) {
+    public DataTable toTable(List<?> objects, String... columnNames) {
         DataTableWriter writer;
         if (isListOfListOfSingleValue(objects)) {
             objects = wrapLists((List<List<?>>) objects);
diff --git a/core/src/main/java/cucumber/table/TableDiffer.java b/core/src/main/java/cucumber/table/TableDiffer.java
@@ -28,7 +28,7 @@ private void checkColumns(DataTable a, DataTable b) {
         }
     }
 
-    public void calculateDiffs() {
+    public void calculateDiffs() throws TableDiffException {
         Patch patch = DiffUtils.diff(orig.diffableRows(), other.diffableRows());
         List<Delta> deltas = patch.getDeltas();
         if (!deltas.isEmpty()) {
diff --git a/core/src/test/java/cucumber/table/DataTableTest.java b/core/src/test/java/cucumber/table/DataTableTest.java
@@ -5,7 +5,6 @@
 import gherkin.I18n;
 import gherkin.formatter.model.Comment;
 import gherkin.formatter.model.DataTableRow;
-import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -16,24 +15,41 @@
 
 public class DataTableTest {
 
-    private DataTable simpleTable;
-
-    @Before
-    public void initSimpleTable() {
-        List<DataTableRow> simpleRows = new ArrayList<DataTableRow>();
-        simpleRows.add(new DataTableRow(new ArrayList<Comment>(), asList("one", "four", "seven"), 1));
-        simpleRows.add(new DataTableRow(new ArrayList<Comment>(), asList("4444", "55555", "666666"), 2));
-        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        XStream xStream = new LocalizedXStreams(classLoader).get(new I18n("en"));
-        simpleTable = new DataTable(simpleRows, new TableConverter(xStream, null));
-    }
-
     @Test
     public void rawShouldHaveThreeColumnsAndTwoRows() {
-        List<List<String>> raw = simpleTable.raw();
+        List<List<String>> raw = createSimpleTable().raw();
         assertEquals("Rows size", 2, raw.size());
         for (List<String> list : raw) {
             assertEquals("Cols size: " + list, 3, list.size());
         }
     }
+
+    @Test
+    public void canCreateTableFromListOfListOfString() {
+        DataTable dataTable = createSimpleTable();
+        DataTable other = dataTable.toTable(dataTable.raw());
+        assertEquals("" +
+                "      | one  | four  | seven  |\n" +
+                "      | 4444 | 55555 | 666666 |\n",
+                other.toString());
+    }
+
+    @Test
+    public void canCreateTableFromListOfListOfStringWithoutOtherTable() {
+        DataTable dataTable = createSimpleTable();
+        DataTable other = DataTable.create(dataTable.raw());
+        assertEquals("" +
+                "      | one  | four  | seven  |\n" +
+                "      | 4444 | 55555 | 666666 |\n",
+                other.toString());
+    }
+
+    public DataTable createSimpleTable() {
+        List<DataTableRow> simpleRows = new ArrayList<DataTableRow>();
+        simpleRows.add(new DataTableRow(new ArrayList<Comment>(), asList("one", "four", "seven"), 1));
+        simpleRows.add(new DataTableRow(new ArrayList<Comment>(), asList("4444", "55555", "666666"), 2));
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        XStream xStream = new LocalizedXStreams(classLoader).get(new I18n("en"));
+        return new DataTable(simpleRows, new TableConverter(xStream));
+    }
 }
diff --git a/core/src/test/java/cucumber/table/TableParser.java b/core/src/test/java/cucumber/table/TableParser.java
@@ -74,6 +74,6 @@ public void eof() {
         });
         l.scan(source);
         ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-        return new DataTable(rows, new TableConverter(new LocalizedXStreams(classLoader).get(new I18n("en")), null));
+        return new DataTable(rows, new TableConverter(new LocalizedXStreams(classLoader).get(new I18n("en"))));
     }
 }
diff --git a/core/src/test/java/cucumber/table/ToDataTableTest.java b/core/src/test/java/cucumber/table/ToDataTableTest.java
@@ -6,6 +6,7 @@
 import cucumber.runtime.converters.TimeConverter;
 import gherkin.I18n;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import java.lang.reflect.Type;
@@ -22,7 +23,7 @@ public class ToDataTableTest {
     @Before
     public void createTableConverterWithDateFormat() {
         XStream xStream = new LocalizedXStreams(Thread.currentThread().getContextClassLoader()).get(new I18n("en"));
-        tc = new TableConverter(xStream, null);
+        tc = new TableConverter(xStream);
         SingleValueConverterWrapperExt converterWrapper = (SingleValueConverterWrapperExt) xStream.getConverterLookup().lookupConverterForType(Date.class);
         TimeConverter timeConverter = (TimeConverter) converterWrapper.getConverter();
         timeConverter.setOnlyFormat("dd/MM/yyyy", Locale.UK);
@@ -32,13 +33,35 @@ public void createTableConverterWithDateFormat() {
     public void converts_list_of_beans_to_table() {
         List<UserPojo> users = tc.toList(UserPojo.class, personTable());
         DataTable table = tc.toTable(users);
+        assertEquals("" +
+                "      | credits | name        | birthDate  |\n" +
+                "      | 1,000   | Sid Vicious | 10/05/1957 |\n" +
+                "      | 3,000   | Frank Zappa | 21/12/1940 |\n" +
+                "", table.toString());
+    }
+
+    @Test
+    @Ignore
+    public void converts_list_of_beans_to_table_with_explicit_columns() {
+        List<UserPojo> users = tc.toList(UserPojo.class, personTable());
+        DataTable table = tc.toTable(users, "name", "birthDate", "credits");
         assertEquals("" +
                 "      | name        | birthDate  | credits |\n" +
                 "      | Sid Vicious | 10/05/1957 | 1,000   |\n" +
                 "      | Frank Zappa | 21/12/1940 | 3,000   |\n" +
                 "", table.toString());
     }
 
+    /**
+     * TODO: To make this pass we have to make sure the columns are the same.
+     */
+    @Test
+    @Ignore
+    public void diffs_round_trip() {
+        List<UserPojo> users = tc.toList(UserPojo.class, personTable());
+        personTable().diff(users);
+    }
+
     private DataTable personTable() {
         return TableParser.parse("" +
                 "| name        | birthDate  | credits  |\n" +
@@ -63,9 +86,9 @@ public void converts_list_of_single_value_to_table() {
 
     // No setters
     public static class UserPojo {
+        public Integer credits;
         public String name;
         public Date birthDate;
-        public Integer credits;
 
         public UserPojo(int foo) {
         }
diff --git a/examples/groovy-calculator/pom.xml b/examples/groovy-calculator/pom.xml
@@ -37,6 +37,17 @@
             <artifactId>groovy-all</artifactId>
             <scope>provided</scope>
         </dependency>
+        <!-- These dependencies are required in order to find classes when running in an IDE - they haven't been jar-jarred -->
+        <dependency>
+            <groupId>com.thoughtworks.xstream</groupId>
+            <artifactId>xstream</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.java-diff-utils</groupId>
+            <artifactId>diffutils</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/examples/java-webbit-websockets-selenium/pom.xml b/examples/java-webbit-websockets-selenium/pom.xml
@@ -48,5 +48,16 @@
             <artifactId>junit</artifactId>
             <scope>test</scope>
         </dependency>
+        <!-- These dependencies are required in order to find classes when running in an IDE - they haven't been jar-jarred -->
+        <dependency>
+            <groupId>com.thoughtworks.xstream</groupId>
+            <artifactId>xstream</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.googlecode.java-diff-utils</groupId>
+            <artifactId>diffutils</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ public List<String> map(DataTableRow row) {`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`private Object tableArgument(Step step, int argIndex, XStream xStream, String dateFormat) {`
`137`		`- DataTable table = new DataTable(step.getRows(), new TableConverter(xStream, dateFormat));`
	`137`	`+ DataTable table = new DataTable(step.getRows(), new TableConverter(xStream));`
`138`	`138`
`139`	`139`	`Type listType = getGenericListType(argIndex);`
`140`	`140`	`if (listType != null) {`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ private void checkColumns(DataTable a, DataTable b) {`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`- public void calculateDiffs() {`
	`31`	`+ public void calculateDiffs() throws TableDiffException {`
`32`	`32`	`Patch patch = DiffUtils.diff(orig.diffableRows(), other.diffableRows());`
`33`	`33`	`List<Delta> deltas = patch.getDeltas();`
`34`	`34`	`if (!deltas.isEmpty()) {`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,6 @@ public void eof() {`
`74`	`74`	`});`
`75`	`75`	`l.scan(source);`
`76`	`76`	`ClassLoader classLoader = Thread.currentThread().getContextClassLoader();`
`77`		`- return new DataTable(rows, new TableConverter(new LocalizedXStreams(classLoader).get(new I18n("en")), null));`
	`77`	`+ return new DataTable(rows, new TableConverter(new LocalizedXStreams(classLoader).get(new I18n("en"))));`
`78`	`78`	`}`
`79`	`79`	`}`