jsontableschema 0.1.0

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/jsontableschema.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsontableschema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jsontableschema"
+  spec.version       = JsonTableSchema::VERSION
+  spec.authors       = ["pezholio"]
+  spec.email         = ["pezholio@gmail.com"]
+
+  spec.summary       = "A Ruby library for working with JSON Table Schema"
+  spec.homepage      = "https://github.com/theodi/jsontableschema.rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10.0"
+  spec.add_development_dependency "webmock", "~> 2.1.0"
+  spec.add_development_dependency "coveralls", "~> 0.8.13"
+
+  spec.add_dependency "json-schema", "~> 2.6.0"
+  spec.add_dependency "uuid", "~> 2.3.8"
+  spec.add_dependency "currencies", "~> 0.4.2"
+  spec.add_dependency "tod", "~> 2.1.0"
+end

data/lib/jsontableschema.rb

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

data/lib/jsontableschema/constraints/constraints.rb

@@ -0,0 +1,76 @@
+require "jsontableschema/constraints/required"
+require "jsontableschema/constraints/min_length"
+require "jsontableschema/constraints/max_length"
+require "jsontableschema/constraints/minimum"
+require "jsontableschema/constraints/maximum"
+require "jsontableschema/constraints/enum"
+require "jsontableschema/constraints/pattern"
+
+module JsonTableSchema
+  class Constraints
+    include JsonTableSchema::Helpers
+
+    include JsonTableSchema::Constraints::Required
+    include JsonTableSchema::Constraints::MinLength
+    include JsonTableSchema::Constraints::MaxLength
+    include JsonTableSchema::Constraints::Minimum
+    include JsonTableSchema::Constraints::Maximum
+    include JsonTableSchema::Constraints::Enum
+    include JsonTableSchema::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(JsonTableSchema::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/jsontableschema/constraints/enum.rb

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

data/lib/jsontableschema/constraints/max_length.rb

@@ -0,0 +1,15 @@
+module JsonTableSchema
+  class Constraints
+    module MaxLength
+
+      def check_max_length
+        return if @value.nil?
+        if @value.length > @constraints['maxLength'].to_i
+          raise JsonTableSchema::ConstraintError.new("The field `#{@field['name']}` must have a maximum length of #{@constraints['maxLength']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/constraints/maximum.rb

@@ -0,0 +1,14 @@
+module JsonTableSchema
+  class Constraints
+    module Maximum
+
+      def check_maximum
+        if @value > parse_constraint(@constraints['maximum'])
+          raise JsonTableSchema::ConstraintError.new("The field `#{@field['name']}` must not be more than #{@constraints['maximum']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/constraints/min_length.rb

@@ -0,0 +1,15 @@
+module JsonTableSchema
+  class Constraints
+    module MinLength
+
+      def check_min_length
+        return if @value.nil?
+        if @value.length < @constraints['minLength'].to_i
+          raise JsonTableSchema::ConstraintError.new("The field `#{@field['name']}` must have a minimum length of #{@constraints['minLength']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/constraints/minimum.rb

@@ -0,0 +1,14 @@
+module JsonTableSchema
+  class Constraints
+    module Minimum
+
+      def check_minimum
+        if @value < parse_constraint(@constraints['minimum'])
+          raise JsonTableSchema::ConstraintError.new("The field `#{@field['name']}` must not be less than #{@constraints['minimum']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/constraints/pattern.rb

@@ -0,0 +1,14 @@
+module JsonTableSchema
+  class Constraints
+    module Pattern
+
+      def check_pattern
+        if !@value.to_json.match /#{@constraints['pattern']}/
+          raise JsonTableSchema::ConstraintError.new("The value for the field `#{@field['name']}` must match the pattern")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/constraints/required.rb

@@ -0,0 +1,32 @@
+module JsonTableSchema
+  class Constraints
+    module Required
+
+      def check_required
+        if required? && is_empty?
+          raise JsonTableSchema::ConstraintError.new("The field `#{@field['name']}` requires a value")
+        end
+        true
+      end
+
+      private
+
+      def required?
+        required == true && @field['type'] != 'null'
+      end
+
+      def is_empty?
+        null_values.include?(@value)
+      end
+
+      def required
+        @constraints['required'].to_s == 'true'
+      end
+
+      def null_values
+        ['null', 'none', 'nil', 'nan', '-', '']
+      end
+
+    end
+  end
+end

data/lib/jsontableschema/data.rb

@@ -0,0 +1,57 @@
+module JsonTableSchema
+  module Data
+
+    attr_reader :errors
+
+    def convert(rows, fail_fast = true)
+      @errors ||= []
+      rows.map! do |r|
+        begin
+          convert_row(r, fail_fast)
+        rescue MultipleInvalid, ConversionError => e
+          raise e if fail_fast == true
+          @errors << e if e.is_a?(ConversionError)
+        end
+      end
+      check_for_errors
+      rows
+    end
+
+    def convert_row(row, fail_fast = true)
+      @errors ||= []
+      raise_header_error(row) if row.count != fields.count
+      fields.each_with_index do |field,i|
+        row[i] = convert_column(row[i], field, fail_fast)
+      end
+      check_for_errors
+      row
+    end
+
+    def cast(field_name, value)
+      convert_column(value, get_field(field_name), true)
+    end
+
+    private
+
+    def raise_header_error(row)
+      raise(JsonTableSchema::ConversionError.new("The number of items to convert (#{row.count}) does not match the number of headers in the schema (#{fields.count})"))
+    end
+
+    def check_for_errors
+      raise(JsonTableSchema::MultipleInvalid.new("There were errors parsing the data")) if @errors.count > 0
+    end
+
+    def convert_column(col, field, fail_fast)
+      klass = get_class_for_type(field['type'] || 'string')
+      converter = Kernel.const_get(klass).new(field)
+      converter.cast(col)
+    rescue Exception => e
+      if fail_fast == true
+        raise e
+      else
+        @errors << e
+      end
+    end
+
+  end
+end

data/lib/jsontableschema/exceptions.rb

@@ -0,0 +1,28 @@
+module JsonTableSchema
+  class Exception < ::Exception ; end
+  
+  class SchemaException < Exception
+    attr_reader :message
+
+    def initialize message
+      @message = message
+    end
+  end
+
+  class InvalidFormat < Exception ; end
+  class InvalidCast < Exception ; end
+  class InvalidEmail < Exception ; end
+  class InvalidURI < Exception ; end
+  class InvalidUUID < Exception ; end
+  class InvalidObjectType < Exception ; end
+  class InvalidArrayType < Exception ; end
+  class InvalidDateType < Exception ; end
+  class InvalidTimeType < Exception ; end
+  class InvalidDateTimeType < Exception ; end
+  class InvalidGeoJSONType < Exception ; end
+  class InvalidGeoPointType < Exception ; end
+  class ConstraintError < Exception ; end
+  class ConstraintNotSupported < Exception ; end
+  class ConversionError < Exception ; end
+  class MultipleInvalid < Exception ; end
+end