Simplification to Resource definition

Author: JohannesJander

pom.xml

@@ -4,7 +4,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.frictionlessdata</groupId>
     <artifactId>datapackage-java</artifactId>
-    <version>0.7.5-SNAPSHOT</version>
+    <version>0.8.0-SNAPSHOT</version>
     <packaging>jar</packaging>
     <issueManagement>
         <url>https://github.com/frictionlessdata/datapackage-java/issues</url>

src/main/java/io/frictionlessdata/datapackage/BaseInterface.java

@@ -0,0 +1,108 @@
+package io.frictionlessdata.datapackage;
+
+import java.util.List;
+
+public interface BaseInterface {
+
+    /**
+     * @return the name
+     */
+    String getName();
+
+    /**
+     * @param name the name to set
+     */
+    void setName(String name);
+
+    /**
+     * @return the profile
+     */
+    String getProfile();
+
+    /**
+     * @param profile the profile to set
+     */
+    void setProfile(String profile);
+
+    /**
+     * @return the title
+     */
+    String getTitle();
+
+    /**
+     * @param title the title to set
+     */
+    void setTitle(String title);
+
+    /**
+     * @return the description
+     */
+    String getDescription();
+
+    /**
+     * @param description the description to set
+     */
+    void setDescription(String description);
+
+
+    /**
+     * @return the sources
+     */
+    List<Source> getSources();
+
+    /**
+     * @param sources the sources to set
+     */
+    void setSources(List<Source> sources);
+
+    /**
+     * @return the licenses
+     */
+    List<License> getLicenses();
+
+    /**
+     * @param licenses the licenses to set
+     */
+    void setLicenses(List<License> licenses);
+
+    /**
+     * @return the encoding
+     */
+    String getEncoding();
+
+    /**
+     * @param encoding the encoding to set
+     */
+    void setEncoding(String encoding);
+
+    /**
+     * @return the bytes
+     */
+    Integer getBytes();
+
+    /**
+     * @param bytes the bytes to set
+     */
+    void setBytes(Integer bytes);
+
+    /**
+     * @return the hash
+     */
+    String getHash();
+
+    /**
+     * @param hash the hash to set
+     */
+    void setHash(String hash);
+
+    /**
+     * @return the mediaType
+     */
+    String getMediaType();
+
+    /**
+     * @param mediaType the mediaType to set
+     */
+    void setMediaType(String mediaType);
+
+}

src/main/java/io/frictionlessdata/datapackage/JSONBase.java

@@ -4,7 +4,6 @@
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 import io.frictionlessdata.datapackage.exceptions.DataPackageException;
@@ -35,8 +34,7 @@
 import static io.frictionlessdata.datapackage.Validator.isValidUrl;
 
 @JsonInclude(value = Include.NON_EMPTY, content = Include.NON_EMPTY )
-public abstract class JSONBase {
-    static final int JSON_INDENT_FACTOR = 4;// JSON keys.
+public abstract class JSONBase implements BaseInterface {
     public static final String JSON_KEY_NAME = "name";
     public static final String JSON_KEY_PROFILE = "profile";
     public static final String JSON_KEY_PATH = "path";
@@ -68,13 +66,11 @@ public abstract class JSONBase {
     protected String title = null;
     protected String description = null;
 
-    String format = null;
     protected String mediaType = null;
     protected String encoding = null;
     protected Integer bytes = null;
     protected String hash = null;
 
-    Dialect dialect;
     private List<Source> sources = null;
     private List<License> licenses = null;
 
@@ -97,20 +93,6 @@ public abstract class JSONBase {
      */
     public String getProfile(){return profile;}
 
-    /**
-     * @param profile the profile to set
-     */
-    public void setProfile(String profile){
-        if (profile.equals(Profile.PROFILE_TABULAR_DATA_PACKAGE)) {
-            if (this instanceof Package) {
-
-            } else if (this instanceof Resource) {
-                throw new DataPackageValidationException("Cannot set "+Profile.PROFILE_TABULAR_DATA_PACKAGE+" on a resource");
-            }
-        }
-        this.profile = profile;
-    }
-
     /**
      * @return the title
      */

src/main/java/io/frictionlessdata/datapackage/Package.java

@@ -652,7 +652,11 @@ public void writeJson (OutputStream output) throws IOException{
      */
     final void validate() throws IOException, DataPackageException{
         try{
-            Validator.validate(this.getJsonNode());
+            ObjectNode jsonNode = this.getJsonNode();
+            for (Resource r : this.getResources()) {
+                r.validate(this);
+            }
+            Validator.validate(jsonNode);
         } catch(ValidationException | DataPackageException ve){
             if (this.strictValidation){
                 throw ve;
@@ -809,7 +813,7 @@ private void setJson(ObjectNode jsonNodeSource) throws Exception {
                 this.setProperty(k, obj);
             }
         });
-        resources.forEach(Resource::validate);
+        resources.forEach((r) -> r.validate(this));
         validate();
     }
 

src/main/java/io/frictionlessdata/datapackage/Validator.java

@@ -48,12 +48,12 @@ public static void validate(JsonNode jsonObjectToValidate) throws IOException, D
         }
 
         if (!errors.isEmpty()) {
-            throw new ValidationException("Error validating Schema", "profile id: " + profileId, errors);
+            throw new ValidationException(profileId, errors);
         }
     }
 
     /**
-     * Validates a given JSON Object against the a given profile schema.
+     * Validates a given JSON Object against a given profile schema.
      *
      * @param jsonObjectToValidate
      * @param profileId

src/main/java/io/frictionlessdata/datapackage/fk/PackageForeignKey.java

@@ -0,0 +1,72 @@
+package io.frictionlessdata.datapackage.fk;
+
+import io.frictionlessdata.datapackage.Package;
+import io.frictionlessdata.datapackage.resource.Resource;
+import io.frictionlessdata.tableschema.Table;
+import io.frictionlessdata.tableschema.exception.ForeignKeyException;
+import io.frictionlessdata.tableschema.field.Field;
+import io.frictionlessdata.tableschema.fk.ForeignKey;
+import io.frictionlessdata.tableschema.fk.Reference;
+import io.frictionlessdata.tableschema.schema.Schema;
+
+import java.util.*;
+
+/**
+ * PackageForeignKey is a wrapper around the ForeignKey class to validate foreign keys
+ * in the context of a data package. It checks if the referenced resource and fields exist
+ * in the data package and validates the foreign key constraints.
+ *
+ * This class exists because the specification of foreign keys in the tableschema specification
+ * is a bit awkward: it assumes that the target of a foreign key can be resolved to a different table, which is
+ * only possible on a datapackage level, yet the foreign key is defined as part of a Schema.
+ *
+ * In our implementation therefore, we have a ForeignKey class in the TableSchema package which only can
+ * validate self-referencing FKs. This class is used to resolve FKs to different resources of a package
+ */
+public class PackageForeignKey {
+
+    private ForeignKey fk;
+    private Package datapackage;
+    private Resource<?> resource;
+
+    public PackageForeignKey(ForeignKey fk, Resource<?> res, Package pkg) {
+        this.datapackage = pkg;
+        this.resource = res;
+        this.fk = fk;
+    }
+
+    public void validate() throws Exception {
+        Reference reference = fk.getReference();
+        // self-reference, this can be validated by the Tableschema {@link ForeignKey} class
+        if (reference.getResource().equals("")) {
+           for (Table table : resource.getTables()) {
+                fk.validate(table);
+            }
+        } else {
+            // validate the foreign key
+            Resource<?> refResource = datapackage.getResource(reference.getResource());
+            if (refResource == null) {
+                throw new ForeignKeyException("Reference resource not found: " + reference.getResource());
+            }
+            List<String> fieldNames = new ArrayList<>();
+            List<String> foreignFieldNames = new ArrayList<>();
+            List<String> lFields = fk.getFieldNames();
+            Schema foreignSchema = refResource.getSchema();
+            if (null == foreignSchema) {
+                foreignSchema = refResource.inferSchema();
+            }
+            for (int i = 0; i < lFields.size(); i++) {
+                fieldNames.add(lFields.get(i));
+                String foreignFieldName = reference.getFieldNames().get(i);
+                foreignFieldNames.add(foreignFieldName);
+                Field<?> foreignField = foreignSchema.getField(foreignFieldName);
+                if (null == foreignField) {
+                    throw new ForeignKeyException("Foreign key ["+fieldNames.get(i)+ "-> "
+                            +reference.getFieldNames().get(i)+"] violation : expected: "
+                            +reference.getFieldNames().get(i) + ", but not found");
+                }
+            }
+
+        }
+    }
+}

src/main/java/io/frictionlessdata/datapackage/resource/AbstractDataResource.java

@@ -18,7 +18,7 @@
  *
  * @param <T> the data format, either CSV or JSON array
  */
-public abstract class AbstractDataResource<T,C> extends AbstractResource<T,C> {
+public abstract class AbstractDataResource<T,C> extends AbstractResource<T> {
     T data;
 
     AbstractDataResource(String name, T data) {

src/main/java/io/frictionlessdata/datapackage/resource/AbstractReferencebasedResource.java

@@ -13,7 +13,7 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
-public abstract class AbstractReferencebasedResource<T,C> extends AbstractResource<T,C> {
+public abstract class AbstractReferencebasedResource<T,C> extends AbstractResource<T> {
     Collection<T> paths;
 
     AbstractReferencebasedResource(String name, Collection<T> paths) {