BeanTableDataSource allows for the creation of Tables on Collection of Java Beans.

Author: JohannesJander

docs/table-reading.md

@@ -1,5 +1,20 @@
 # Reading tabular data
 
+- [Reading data the Java way](#reading-tabular-data-the-java-way) explains various ways of reading data
+       as instances of a provided Bean class
+  - [Reading from CSV/JSON data](#reading-from-CSV/JSON-data) Read data and transparently convert them
+       to Java Beans.
+  - [Creating a Table from Java Bean Objects](#creating-a-table-from-java-bean-objects) Construct a Table
+       on a Collection of Java Beans.
+- [Reading data the Frictionless way](#reading-tabular-data-the-frictionless-way) - either as String Arrays, 
+       Object Arrays, or Maps
+  - [Without a Schema](#reading-tabular-data-without-a-schema) Read as String arrays and without
+        format integrity assurance
+  - [With a Schema](#reading-tabular-data-using-a-schema) Read as converted Java object arrays with
+        format integrity assurance
+  - [Read data as Maps](#reading-tabular-data-returning-rows-as-maps) if you prefer your data as
+        key/value pairs
+
 There are basically two distinct ways to read data with the help of the tableschema-java library:
 - The way other language implementation of the Frictionless Tableschema standard handle this
 - In a true native Java way
@@ -17,6 +32,11 @@ Since Java is a strongly typed language, we can derive the data type for each co
 Java bean. This allows us to model our domain model in terms of Java beans, enjoy the format integrity
 of a Table Schema, and while reading data, get it returned as instances of our bean class.
 
+Some limitations apply: the Bean serialization/deserialization does not know all the bells and whistles
+that e.g. Jackson does and you can't use nested data - after all, tabular data is not hierarchical and
+is not well suited for object trees. Also, you can't use custom classes for your members, you need 
+to stick to a pre-defined list of classes.
+
 First we define a Bean class:
 ```java
 public class SimpleDataBean {
@@ -47,7 +67,7 @@ public class SimpleDataBean {
     }
 }
 ```
-
+### Reading from CSV/JSON data
 And with that, we can read the data as `SimpleDataBean` instances:
 ```java
 URL url = new URL("https://raw.githubusercontent.com/frictionlessdata/tableschema-java/master" +
@@ -67,6 +87,28 @@ while (bit.hasNext()) {
 // 3 baz
 ```
 
+### Creating a Table from Java Bean Objects
+
+If we have a Collection of our business objects as data, we can construct a Table with the data as backing. 
+All the iterators from the other examples are available for reading the serialized data - or a Data Package
+could be written.
+
+You can export a synthesized Schema based on the Bean class. It is a regular Table Schema.
+
+```java
+List<EmployeeBeanWithAnnotation> employees = new ArrayList<>();
+
+Table t = new Table(employees, EmployeeBeanWithAnnotation.class);
+
+Schema schema = t.getSchema();
+Iterator<Object[]> iter = table.iterator();
+while(iter.hasNext()){
+    Object[] row = iter.next();
+    System.out.println(Arrays.toString(row));
+}
+```
+
+
 ## Reading tabular data the Frictionless way
 
 ### Reading tabular data without a Schema

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.frictionlessdata</groupId>
     <artifactId>tableschema-java</artifactId>
-    <version>0.6.0-SNAPSHOT</version>
+    <version>0.6.1-SNAPSHOT</version>
     <packaging>jar</packaging>
     <issueManagement>
         <url>https://github.com/frictionlessdata/tableschema-java/issues</url>

src/main/java/io/frictionlessdata/tableschema/Table.java

@@ -1,5 +1,7 @@
 package io.frictionlessdata.tableschema;
 
+import io.frictionlessdata.tableschema.schema.BeanSchema;
+import io.frictionlessdata.tableschema.tabledatasource.BeanTableDataSource;
 import io.frictionlessdata.tableschema.tabledatasource.CsvTableDataSource;
 import io.frictionlessdata.tableschema.tabledatasource.StringArrayTableDataSource;
 import io.frictionlessdata.tableschema.tabledatasource.TableDataSource;
@@ -55,6 +57,18 @@ public class Table{
      */
     public Table() { }
 
+    /**
+     * Constructor for a Table from a Collection of Java Beans and the Bean class.
+     * @param data a {@link java.util.Collection} holding Java Beans of type `type`
+     * @param type the Bean class
+     */
+    public Table(Collection<?> data, Class<?> type) {
+        BeanTableDataSource ds = new BeanTableDataSource(data, type);
+        this.dataSource = ds;
+        schema = BeanSchema.infer(ds.getBeanClass());
+        validate();
+    }
+
     /**
      * Constructor for a Table from String array input data and optionally
      * a Schema. Data is parsed into a TableDataSource object
@@ -69,17 +83,24 @@ public Table(Collection<String[]> data, String[] headers, Schema schema) {
             validate();
     }
 
+    public static Table fromSource(BeanTableDataSource dataSource) {
+        Table table = new Table();
+        table.dataSource = dataSource;
+        table.schema = BeanSchema.infer(dataSource.getBeanClass());
+        return table;
+    }
+
     /**
      * Create Table on an {@link java.io.InputStream} for reading both the CSV/JSON
      * data and the table schema.
-     * @param dataSource InputStream for reading the data from
+     * @param data InputStream for reading the data from
      * @param schema InputStream for reading table schema from. Can be `null`
-     * @param format The expected CSVFormat if dataSource is a CSV-containing InputStream; ignored for JSON data.
+     * @param format The expected CSVFormat if data is a CSV-containing InputStream; ignored for JSON data.
      *               Can be `null`
      */
-    public static Table fromSource(InputStream dataSource, InputStream schema, CSVFormat format){
+    public static Table fromSource(InputStream data, InputStream schema, CSVFormat format){
         Table table = new Table();
-        table.dataSource = TableDataSource.fromSource(dataSource);
+        table.dataSource = TableDataSource.fromSource(data);
         if (null != schema) {
             try {
                 table.schema = Schema.fromJson(schema, true);

src/main/java/io/frictionlessdata/tableschema/annotations/FieldFormat.java

@@ -38,9 +38,9 @@
      *
      * From the specs. https://specs.frictionlessdata.io/table-schema/#types-and-formats
      *  date/time values in this field can be parsed according to
-     * <PATTERN>. <PATTERN> MUST follow the syntax of standard Python / C
+     * &lt;PATTERN&gt;. &lt;PATTERN&gt; MUST follow the syntax of standard Python / C
      * strptime (That is, values in the this field should be parsable
-     * by Python / C standard strptime using <PATTERN>).
+     * by Python / C standard strptime using &lt;PATTERN&gt;).
      * Example for "format": "%d/%m/%y" which would correspond to dates like: 30/11/14
      */
     String format() default "default";

src/main/java/io/frictionlessdata/tableschema/exception/ValidationException.java

@@ -4,10 +4,13 @@
 import io.frictionlessdata.tableschema.schema.FormalSchemaValidator;
 
 import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class ValidationException extends TableSchemaException {
 
 	List<ValidationMessage> validationMessages = new ArrayList<>();
+	List<String> otherMessages = new ArrayList<>();
 
 	public ValidationException(String msg) {
 		super(msg);
@@ -22,17 +25,21 @@ public ValidationException(FormalSchemaValidator schema, Collection<ValidationMe
 		this.validationMessages.addAll(messages);
 	}
 
-	public ValidationException(JsonSchema schema, Collection<ValidationMessage> messages) {
-		this(String.format("%s: %s", schema, "validation failed"));
-		this.validationMessages.addAll(messages);
-	}
-
 	public ValidationException(String schemaName, Collection<ValidationException> exceptions) {
-		this(String.format("%s: %s", schemaName, "validation failed"));
+		this(String.format("%s: %s", schemaName, "validation failed: "));
+		otherMessages.addAll(exceptions
+				.stream().map((Throwable::getMessage)).collect(Collectors.toList()));
 		final Set<ValidationMessage> messages = new LinkedHashSet<>();
 		exceptions.forEach((m) -> {
 			messages.addAll(m.validationMessages);
 		});
 		this.validationMessages.addAll(messages);
 	}
+
+	public List<Object> getMessages() {
+		List<Object> retVal = new ArrayList<>();
+		retVal.addAll(validationMessages);
+		retVal.addAll(otherMessages);
+		return retVal;
+	}
 }

src/main/java/io/frictionlessdata/tableschema/field/AnyField.java

@@ -39,6 +39,11 @@ public String formatValueAsString(Object value, String format, Map<String, Objec
         return value.toString();
     }
 
+    @Override
+    String formatObjectValueAsString(Object value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
+        return value.toString();
+    }
+
 
     @Override
     public String parseFormat(String value, Map<String, Object> options) {

src/main/java/io/frictionlessdata/tableschema/field/ArrayField.java

@@ -8,10 +8,7 @@
 import io.frictionlessdata.tableschema.util.JsonUtil;
 
 import java.net.URI;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 
 
@@ -43,6 +40,32 @@ public Object[] parseValue(String value, String format, Map<String, Object> opti
     @Override
     public String formatValueAsString(Object[] value, String format, Map<String, Object> options)
             throws InvalidCastException, ConstraintsException {
+        return _format(value);
+        /*List<String> vals = new ArrayList<>();
+        String val;
+        for (Object o : value) {
+            if (o instanceof String) {
+                val = "\""+o+"\"";
+            } else {
+                Field f = FieldInferrer.infer(o);
+                val = f.formatValueAsString(o);
+            }
+            vals.add(val);
+        }
+        return "[" + vals.stream().collect(Collectors.joining(",")) +"]";*/
+    }
+
+    @Override
+    String formatObjectValueAsString(Object value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
+        if (value instanceof Collection) {
+            Collection vals = (Collection)value;
+            return _format(vals.toArray(new Object[0]));
+            //return "[" + vals.stream().collect(Collectors.joining(",")) +"]";
+        }
+        return value.toString();
+    }
+
+    private String _format(Object... value) {
         List<String> vals = new ArrayList<>();
         String val;
         for (Object o : value) {
@@ -57,7 +80,6 @@ public String formatValueAsString(Object[] value, String format, Map<String, Obj
         return "[" + vals.stream().collect(Collectors.joining(",")) +"]";
     }
 
-
     @Override
     public String parseFormat(String value, Map<String, Object> options) {
         return "default";

src/main/java/io/frictionlessdata/tableschema/field/BooleanField.java

@@ -70,6 +70,7 @@ public String formatValueAsString(Boolean value) throws InvalidCastException, Co
         return (value) ? _getActualTrueValues().get(0) : _getActualFalseValues().get(0);
     }
 
+
     @Override
     public String formatValueAsString(Boolean value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
         String trueValue = _getActualTrueValues().get(0);
@@ -85,6 +86,12 @@ public String formatValueAsString(Boolean value, String format, Map<String, Obje
         return (value) ? trueValue : falseValue;
     }
 
+
+    @Override
+    String formatObjectValueAsString(Object value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
+        return value.toString();
+    }
+
     @Override
     public String parseFormat(String value, Map<String, Object> options) {
         return "default";

src/main/java/io/frictionlessdata/tableschema/field/DateField.java

@@ -83,6 +83,10 @@ public String formatValueAsString(LocalDate value, String format, Map<String, Ob
         return value.format(DateTimeFormatter.ofPattern(translatedFormat));
     }
 
+    @Override
+    String formatObjectValueAsString(Object value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
+        return value.toString();
+    }
 
     @Override
     public String parseFormat(String value, Map<String, Object> options) {

src/main/java/io/frictionlessdata/tableschema/field/DatetimeField.java

@@ -54,6 +54,10 @@ public String formatValueAsString(ZonedDateTime value, String format, Map<String
         return value.format(formatter);
     }
 
+    @Override
+    String formatObjectValueAsString(Object value, String format, Map<String, Object> options) throws InvalidCastException, ConstraintsException {
+        return value.toString();
+    }
 
     @Override
     public String parseFormat(String value, Map<String, Object> options) {