tableschema 0.3.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/etc/schemas/geojson.json

@@ -0,0 +1,209 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "id": "https://raw.githubusercontent.com/fge/sample-json-schemas/master/geojson/geojson.json#",
+    "title": "Geo JSON object",
+    "description": "Schema for a Geo JSON object",
+    "type": "object",
+    "required": [ "type" ],
+    "properties": {
+        "crs": { "$ref": "#/definitions/crs" },
+        "bbox": { "$ref": "#/definitions/bbox" }
+    },
+    "oneOf": [
+        { "$ref": "#/definitions/geometry" },
+        { "$ref": "#/definitions/geometryCollection" },
+        { "$ref": "#/definitions/feature" },
+        { "$ref": "#/definitions/featureCollection" }
+    ],
+    "definitions": {
+        "geometryCollection": {
+            "title": "GeometryCollection",
+            "description": "A collection of geometry objects",
+            "required": [ "geometries" ],
+            "properties": {
+                "type": { "enum": [ "GeometryCollection" ] },
+                "geometries": {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/geometry" }
+                }
+            }
+        },
+        "feature": {
+            "title": "Feature",
+            "description": "A Geo JSON feature object",
+            "required": [ "geometry", "properties" ],
+            "properties": {
+                "type": { "enum": [ "Feature" ] },
+                "geometry": {
+                    "oneOf": [
+                        { "type": "null" },
+                        { "$ref": "#/definitions/geometry" }
+                    ]
+                },
+                "properties": { "type": [ "object", "null" ] },
+                "id": { "FIXME": "may be there, type not known (string? number?)" }
+            }
+        },
+        "featureCollection": {
+            "title": "FeatureCollection",
+            "description": "A Geo JSON feature collection",
+            "required": [ "features" ],
+            "properties": {
+                "type": { "enum": [ "FeatureCollection" ] },
+                "features": {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/feature" }
+                }
+            }
+        },
+        "geometry": {
+            "title": "geometry",
+            "description": "One geometry as defined by GeoJSON",
+            "type": "object",
+            "required": [ "type", "coordinates" ],
+            "oneOf": [
+                {
+                    "title": "Point",
+                    "properties": {
+                        "type": { "enum": [ "Point" ] },
+                        "coordinates": { "$ref": "#/definitions/geometry/definitions/position" }
+                    }
+                },
+                {
+                    "title": "MultiPoint",
+                    "properties": {
+                        "type": { "enum": [ "MultiPoint" ] },
+                        "coordinates": { "$ref": "#/definitions/geometry/definitions/positionArray" }
+                    }
+                },
+                {
+                    "title": "LineString",
+                    "properties": {
+                        "type": { "enum": [ "LineString" ] },
+                        "coordinates": { "$ref": "#/definitions/geometry/definitions/lineString" }
+                    }
+                },
+                {
+                    "title": "MultiLineString",
+                    "properties": {
+                        "type": { "enum": [ "MultiLineString" ] },
+                        "coordinates": {
+                            "type": "array",
+                            "items": { "$ref": "#/definitions/geometry/definitions/lineString" }
+                        }
+                    }
+                },
+                {
+                    "title": "Polygon",
+                    "properties": {
+                        "type": { "enum": [ "Polygon" ] },
+                        "coordinates": { "$ref": "#/definitions/geometry/definitions/polygon" }
+                    }
+                },
+                {
+                    "title": "MultiPolygon",
+                    "properties": {
+                        "type": { "enum": [ "MultiPolygon" ] },
+                        "coordinates": {
+                            "type": "array",
+                            "items": { "$ref": "#/definitions/geometry/definitions/polygon" }
+                        }
+                    }
+                }
+            ],
+            "definitions": {
+                "position": {
+                    "description": "A single position",
+                    "type": "array",
+                    "minItems": 2,
+                    "items": [ { "type": "number" }, { "type": "number" } ],
+                    "additionalItems": false
+                },
+                "positionArray": {
+                    "description": "An array of positions",
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/geometry/definitions/position" }
+                },
+                "lineString": {
+                    "description": "An array of two or more positions",
+                    "allOf": [
+                        { "$ref": "#/definitions/geometry/definitions/positionArray" },
+                        { "minItems": 2 }
+                    ]
+                },
+                "linearRing": {
+                    "description": "An array of four positions where the first equals the last",
+                    "allOf": [
+                        { "$ref": "#/definitions/geometry/definitions/positionArray" },
+                        { "minItems": 4 }
+                    ]
+                },
+                "polygon": {
+                    "description": "An array of linear rings",
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/geometry/definitions/linearRing" }
+                }
+            }
+        },
+        "crs": {
+            "title": "crs",
+            "description": "a Coordinate Reference System object",
+            "type": [ "object", "null" ],
+            "required": [ "type", "properties" ],
+            "properties": {
+                "type": { "type": "string" },
+                "properties": { "type": "object" }
+            },
+            "additionalProperties": false,
+            "oneOf": [
+                { "$ref": "#/definitions/crs/definitions/namedCrs" },
+                { "$ref": "#/definitions/crs/definitions/linkedCrs" }
+            ],
+            "definitions": {
+                "namedCrs": {
+                    "properties": {
+                        "type": { "enum": [ "name" ] },
+                        "properties": {
+                            "required": [ "name" ],
+                            "additionalProperties": false,
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "FIXME": "semantic validation necessary"
+                                }
+                            }
+                        }
+                    }
+                },
+                "linkedObject": {
+                    "type": "object",
+                    "required": [ "href" ],
+                    "properties": {
+                        "href": {
+                            "type": "string",
+                            "format": "uri",
+                            "FIXME": "spec says \"dereferenceable\", cannot enforce that"
+                        },
+                        "type": {
+                            "type": "string",
+                            "description": "Suggested values: proj4, ogjwkt, esriwkt"
+                        }
+                    }
+                },
+                "linkedCrs": {
+                    "properties": {
+                        "type": { "enum": [ "link" ] },
+                        "properties": { "$ref": "#/definitions/crs/definitions/linkedObject" }
+                    }
+                }
+            }
+        },
+        "bbox": {
+            "description": "A bounding box as defined by GeoJSON",
+            "FIXME": "unenforceable constraint: even number of elements in array",
+            "type": "array",
+            "items": { "type": "number" }
+        }
+    }
+}
+

data/etc/schemas/json-table-schema.json

@@ -0,0 +1,102 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "title": "JSON Table Schema",
+    "description": "JSON Schema for validating JSON Table structures",
+    "type": "object",
+    "properties": {
+        "fields": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string"
+                    },
+                    "title": {
+                        "type": "string"
+                    },
+                    "description": {
+                        "type": "string"
+                    },
+                    "type": {
+                        "enum": [ "string", "number", "integer", "date", "time", "datetime", "boolean", "binary", "object", "geopoint", "geojson", "array", "any" ]
+                    },
+                    "format": {
+                        "type": "string"
+                    },
+                    "constraints": {
+                        "type": "object",
+                        "properties": {
+                            "required": {
+                                "type": "boolean"
+                            },
+                            "minLength": {
+                                "type": "integer"
+                            },
+                            "maxLength": {
+                                "type": "integer"
+                            },
+                            "unique": {
+                                "type": "boolean"
+                            },
+                            "pattern": {
+                                "type": "string"
+                            },
+                            "minimum": {
+                                "oneOf": [
+                                    {"type": "string"},
+                                    {"type": "number"}
+                                ]
+                            },
+                            "maximum": {
+                                "oneOf": [
+                                    {"type": "string"},
+                                    {"type": "number"}
+                                ]
+                            }
+                        }
+                    }
+                },
+                "required": ["name"]
+            }
+        },
+        "primaryKey": {
+            "oneOf": [
+                {"type": "string"},
+                {"type": "array"}
+            ]
+        },
+        "foreignKeys": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["fields", "reference"],
+                "properties": {
+                    "fields": {
+                        "oneOf": [
+                            {"type": "string"},
+                            {"type": "array"}
+                        ]
+                    },
+                    "reference": {
+                        "type": "object",
+                        "required": ["resource", "fields"],
+                        "properties": {
+                            "resource": {
+                                "type": "string"
+                            },
+                            "fields": {
+                                "oneOf": [
+                                    {"type": "string"},
+                                    {"type": "array"}
+                                ]
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "required": ["fields"]
+}

data/lib/tableschema.rb

@@ -0,0 +1,42 @@
+require "json"
+require "json-schema"
+require "uuid"
+require "currencies"
+require "date"
+require "tod"
+require "tod/core_extensions"
+require "csv"
+
+require "tableschema/version"
+require "tableschema/exceptions"
+require "tableschema/helpers"
+
+require "tableschema/constraints/constraints"
+
+require "tableschema/types/base"
+require "tableschema/types/any"
+require "tableschema/types/array"
+require "tableschema/types/boolean"
+require "tableschema/types/date"
+require "tableschema/types/datetime"
+require "tableschema/types/geojson"
+require "tableschema/types/geopoint"
+require "tableschema/types/integer"
+require "tableschema/types/null"
+require "tableschema/types/number"
+require "tableschema/types/object"
+require "tableschema/types/string"
+require "tableschema/types/time"
+
+require "tableschema/field"
+require "tableschema/validate"
+require "tableschema/model"
+require "tableschema/data"
+require "tableschema/schema"
+require "tableschema/table"
+require "tableschema/infer"
+
+module TableSchema
+  module Types
+  end
+end

data/lib/tableschema/constraints/constraints.rb

@@ -0,0 +1,76 @@
+require "tableschema/constraints/required"
+require "tableschema/constraints/min_length"
+require "tableschema/constraints/max_length"
+require "tableschema/constraints/minimum"
+require "tableschema/constraints/maximum"
+require "tableschema/constraints/enum"
+require "tableschema/constraints/pattern"
+
+module TableSchema
+  class Constraints
+    include TableSchema::Helpers
+
+    include TableSchema::Constraints::Required
+    include TableSchema::Constraints::MinLength
+    include TableSchema::Constraints::MaxLength
+    include TableSchema::Constraints::Minimum
+    include TableSchema::Constraints::Maximum
+    include TableSchema::Constraints::Enum
+    include TableSchema::Constraints::Pattern
+
+    def initialize(field, value)
+      @field = field
+      @value = value
+      @constraints = @field['constraints'] || {}
+    end
+
+    def validate!
+      result = true
+      @constraints.each do |c|
+        constraint = c.first
+        if is_supported_type?(constraint)
+          result = self.send("check_#{underscore constraint}")
+        else
+          raise(TableSchema::ConstraintNotSupported.new("The field type `#{@field['type']}` does not support the `#{constraint}` constraint"))
+        end
+      end
+      result
+    end
+
+    private
+
+    def underscore(value)
+      value.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+    end
+
+    def is_supported_type?(constraint)
+      klass = get_class_for_type(@field['type'])
+      Kernel.const_get(klass).supported_constraints.include?(constraint)
+    end
+
+    def parse_constraint(constraint)
+      if @value.is_a?(::Integer) && constraint.is_a?(::String)
+        constraint.to_i
+      elsif @value.is_a?(::Tod::TimeOfDay)
+        Tod::TimeOfDay.parse(constraint)
+      elsif @value.is_a?(::DateTime)
+        DateTime.parse(constraint)
+      elsif @value.is_a?(::Date) && constraint.is_a?(::String)
+        Date.parse(constraint)
+      elsif @value.is_a?(::Float) && constraint.is_a?(Array)
+        constraint.map { |c| Float(c) }
+      elsif @value.is_a?(Boolean) && constraint.is_a?(Array)
+        constraint.map { |c| convert_to_boolean(c) }
+      elsif @value.is_a?(Date) && constraint.is_a?(Array)
+        constraint.map { |c| Date.parse(c) }
+      else
+        constraint
+      end
+    end
+
+  end
+end

data/lib/tableschema/constraints/enum.rb

@@ -0,0 +1,14 @@
+module TableSchema
+  class Constraints
+    module Enum
+
+      def check_enum
+        if !parse_constraint(@constraints['enum']).include?(@value)
+          raise TableSchema::ConstraintError.new("The value for the field `#{@field['name']}` must be in the enum array")
+        end
+        true
+      end
+
+    end
+  end
+end