tableschema 0.3.1 → 0.4.0

data/lib/tableschema/constraints/maximum.rb

@@ -3,12 +3,22 @@ module TableSchema
     module Maximum
 
       def check_maximum
-        if @value > parse_constraint(@constraints['maximum'])
-          raise TableSchema::ConstraintError.new("The field `#{@field['name']}` must not be more than #{@constraints['maximum']}")
+        if @field.type == 'yearmonth'
+          valid = Date.new(@value[:year], @value[:month]) <= Date.new(parsed_maximum[:year], parsed_maximum[:month])
+        else
+          valid = @value <= parsed_maximum
+        end
+
+        unless valid
+          raise TableSchema::ConstraintError.new("The field `#{@field[:name]}` must not be more than #{@constraints[:maximum]}")
         end
         true
       end
 
+      def parsed_maximum
+        @field.cast_type(@constraints[:maximum])
+      end
+
     end
   end
 end

data/lib/tableschema/constraints/min_length.rb

@@ -4,12 +4,16 @@ module TableSchema
 
       def check_min_length
         return if @value.nil?
-        if @value.length < @constraints['minLength'].to_i
-          raise TableSchema::ConstraintError.new("The field `#{@field['name']}` must have a minimum length of #{@constraints['minLength']}")
+        if @value.length < parsed_min_length
+          raise TableSchema::ConstraintError.new("The field `#{@field[:name]}` must have a minimum length of #{@constraints[:minLength]}")
         end
         true
       end
 
+      def parsed_min_length
+        @constraints[:minLength].to_i
+      end
+
     end
   end
 end

data/lib/tableschema/constraints/minimum.rb

@@ -3,12 +3,22 @@ module TableSchema
     module Minimum
 
       def check_minimum
-        if @value < parse_constraint(@constraints['minimum'])
-          raise TableSchema::ConstraintError.new("The field `#{@field['name']}` must not be less than #{@constraints['minimum']}")
+        if @field.type == 'yearmonth'
+          valid = Date.new(@value[:year], @value[:month]) >= Date.new(parsed_minimum[:year], parsed_minimum[:month])
+        else
+          valid = @value >= parsed_minimum
+        end
+
+        unless valid
+          raise TableSchema::ConstraintError.new("The field `#{@field[:name]}` must not be less than #{@constraints[:minimum]}")
         end
         true
       end
 
+      def parsed_minimum
+        @field.cast_type(@constraints[:minimum])
+      end
+
     end
   end
 end

data/lib/tableschema/constraints/pattern.rb

@@ -3,8 +3,15 @@ module TableSchema
     module Pattern
 
       def check_pattern
-        if !@value.to_json.match /#{@constraints['pattern']}/
-          raise TableSchema::ConstraintError.new("The value for the field `#{@field['name']}` must match the pattern")
+        constraint = lambda { |value| value.match(/#{@constraints[:pattern]}/) }
+        if @field.type == 'yearmonth'
+          valid = constraint.call(Date.new(@value[:year], @value[:month]).strftime('%Y-%m'))
+        else
+          valid = constraint.call(@value.to_json)
+        end
+
+        unless valid
+          raise TableSchema::ConstraintError.new("The value for the field `#{@field[:name]}` must match the pattern")
         end
         true
       end

data/lib/tableschema/constraints/required.rb

@@ -3,30 +3,21 @@ module TableSchema
     module Required
 
       def check_required
-        if required? && is_empty?
-          raise TableSchema::ConstraintError.new("The field `#{@field['name']}` requires a value")
+        if parsed_required == true && value_is_empty?
+          raise TableSchema::ConstraintError.new("The field `#{@field[:name]}` requires a value")
         end
         true
       end
 
       private
 
-      def required?
-        required == true && @field['type'] != 'null'
+      def value_is_empty?
+        @value.nil? || @value == ''
       end
 
-      def is_empty?
-        null_values.include?(@value)
+      def parsed_required
+        @constraints[:required].to_s == 'true'
       end
-
-      def required
-        @constraints['required'].to_s == 'true'
-      end
-
-      def null_values
-        ['null', 'none', 'nil', 'nan', '-', '']
-      end
-
     end
   end
 end

data/lib/tableschema/constraints/unique.rb

@@ -0,0 +1,12 @@
+module TableSchema
+  class Constraints
+    module Unique
+
+      def check_unique
+        # This check is done in Table because it needs the previous values in the column
+        true
+      end
+
+    end
+  end
+end

data/lib/tableschema/defaults.rb

@@ -0,0 +1,9 @@
+module TableSchema
+  DEFAULTS = {
+    format: 'default',
+    type: 'string',
+    missing_values: [''],
+    group_char: ',',
+    decimal_char: '.'
+  }.freeze
+end

data/lib/tableschema/exceptions.rb

@@ -1,6 +1,6 @@
 module TableSchema
   class Exception < ::Exception ; end
-  
+
   class SchemaException < Exception
     attr_reader :message
 
@@ -9,20 +9,33 @@ module TableSchema
     end
   end
 
+  class MultipleInvalid < Exception
+    attr_reader :message, :errors
+
+    def initialize(message, errors=[])
+      @message = message
+      @errors = errors
+    end
+  end
+
   class InvalidFormat < Exception ; end
   class InvalidCast < Exception ; end
   class InvalidEmail < Exception ; end
   class InvalidURI < Exception ; end
   class InvalidUUID < Exception ; end
+  class InvalidBinary < Exception ; end
   class InvalidObjectType < Exception ; end
   class InvalidArrayType < Exception ; end
   class InvalidDateType < Exception ; end
   class InvalidTimeType < Exception ; end
   class InvalidDateTimeType < Exception ; end
+  class InvalidYearType < Exception; end
+  class InvalidYearMonthType < Exception; end
+  class InvalidDurationType < Exception; end
   class InvalidGeoJSONType < Exception ; end
+  class InvalidTopoJSONType < Exception ; end
   class InvalidGeoPointType < Exception ; end
   class ConstraintError < Exception ; end
   class ConstraintNotSupported < Exception ; end
   class ConversionError < Exception ; end
-  class MultipleInvalid < Exception ; end
 end

data/lib/tableschema/field.rb

@@ -1,40 +1,59 @@
+require 'tableschema/defaults'
+
 module TableSchema
   class Field < Hash
     include TableSchema::Helpers
 
-    attr_reader :type_class
-
-    def initialize(descriptor)
-      self.merge! descriptor
-      @type_class = get_type
-    end
+    attr_reader :name, :type, :format, :missing_values, :constraints
 
-    def name
-      self['name']
+    def initialize(descriptor, missing_values=nil)
+      self.merge! deep_symbolize_keys(descriptor)
+      @name = self[:name]
+      @type = self[:type] = self.fetch(:type, TableSchema::DEFAULTS[:type])
+      @format = self[:format] = self.fetch(:format, TableSchema::DEFAULTS[:format])
+      @constraints = self[:constraints] = self.fetch(:constraints, {})
+      @missing_values = missing_values || default_missing_values
     end
 
-    def type
-      self['type'] || 'string'
+    def descriptor
+      self.to_h
     end
 
-    def format
-      self['format'] || 'default'
+    def cast_value(value, check_constraints: true)
+      cast_value = cast_type(value)
+      return cast_value if check_constraints == false
+      TableSchema::Constraints.new(self, cast_value).validate!
+      cast_value
     end
 
-    def constraints
-      self['constraints'] || {}
+    def test_value(value, check_constraints: true)
+      cast_value(value, check_constraints: check_constraints)
+      true
+    rescue TableSchema::Exception
+      false
     end
 
-    def cast_value(col)
-      klass = get_class_for_type(type)
-      converter = Kernel.const_get(klass).new(self)
-      converter.cast(col)
+    def cast_type(value)
+      if is_null?(value)
+        nil
+      else
+        type_class.new(self).cast(value)
+      end
     end
 
     private
 
-      def get_type
-        Object.const_get get_class_for_type(type)
+      def default_missing_values
+        defaults = TableSchema::DEFAULTS[:missing_values]
+        @type == 'string' ? defaults - [''] : defaults
+      end
+
+      def type_class
+        Object.const_get get_class_for_type(@type)
+      end
+
+      def is_null?(value)
+        @missing_values.include?(value)
       end
 
   end

data/lib/tableschema/helpers.rb

@@ -1,6 +1,21 @@
 module TableSchema
   module Helpers
 
+    def deep_symbolize_keys(descriptor)
+      case descriptor
+      when Hash
+        descriptor.inject({}) do |new_descriptor, (key, val)|
+          key_sym = key.respond_to?(:to_sym) ? key.to_sym : key
+          new_descriptor[key_sym] = deep_symbolize_keys(val)
+          new_descriptor
+        end
+      when Enumerable
+        descriptor.map{ |el| deep_symbolize_keys(el)}
+      else
+        descriptor
+      end
+    end
+
     def convert_to_boolean(value)
       if value.is_a?(Boolean)
         return value
@@ -22,25 +37,27 @@ module TableSchema
     end
 
     def get_class_for_type(type)
-      "TableSchema::Types::#{type_class_lookup[type] || 'String'}"
+      "TableSchema::Types::#{type_class_lookup[type.to_sym] || 'String'}"
     end
 
     def type_class_lookup
       {
-        'any' => 'Any',
-        'array' => 'Array',
-        'base' => 'Base',
-        'boolean' => 'Boolean',
-        'date' => 'Date',
-        'datetime' => 'DateTime',
-        'geojson' => 'GeoJSON',
-        'geopoint' => 'GeoPoint',
-        'integer' => 'Integer',
-        'null' => 'Null',
-        'number' => 'Number',
-        'object' => 'Object',
-        'string' => 'String',
-        'time' => 'Time',
+        any: 'Any',
+        array: 'Array',
+        base: 'Base',
+        boolean: 'Boolean',
+        date: 'Date',
+        datetime: 'DateTime',
+        geojson: 'GeoJSON',
+        geopoint: 'GeoPoint',
+        integer: 'Integer',
+        number: 'Number',
+        object: 'Object',
+        string: 'String',
+        time: 'Time',
+        year: 'Year',
+        yearmonth: 'YearMonth',
+        duration: 'Duration',
       }
     end
 

data/lib/tableschema/infer.rb

@@ -1,3 +1,6 @@
+require 'tableschema/defaults'
+require 'tableschema/field'
+
 module TableSchema
   class Infer
 
@@ -5,41 +8,41 @@ module TableSchema
 
     attr_reader :schema
 
-    def initialize(headers, rows, opts = {})
+    def initialize(headers, rows, explicit: false, primary_key: nil, row_limit: nil)
       @headers = headers
       @rows = rows
-      @explicit = opts[:explicit]
-      @primary_key = opts[:primary_key]
-      @row_limit = opts[:row_limit]
+      @explicit = explicit
+      @primary_key = primary_key
+      @row_limit = row_limit
 
       @schema = {
-        'fields' => fields
+        fields: fields
       }
-      @schema['primaryKey'] = @primary_key if @primary_key
+      @schema[:primaryKey] = @primary_key if @primary_key
       infer!
     end
 
     def fields
       @headers.map do |header|
         descriptor = {
-          'name' => header,
-          'title' => '',
-          'description' => '',
+          name: header,
+          title: '',
+          description: '',
         }
 
         constraints = {}
-        constraints['required'] = @explicit === true
-        constraints['unique'] = (header == @primary_key)
-        constraints.delete_if { |k,v| v == false } unless @explicit === true
-        descriptor['constraints'] = constraints if constraints.count > 0
-        descriptor
+        constraints[:required] = @explicit === true
+        constraints[:unique] = (header == @primary_key)
+        constraints.delete_if { |_,v| v == false } unless @explicit === true
+        descriptor[:constraints] = constraints if constraints.count > 0
+        TableSchema::Field.new(descriptor)
       end
     end
 
     def infer!
       type_matches = []
-      @rows.each_with_index do |row, i|
-        break if @row_limit && i > @row_limit
+      @rows.each_with_index do |row, index|
+        break if @row_limit && index > @row_limit
         row = row.fields if row.class == CSV::Row
 
         row_length = row.count
@@ -53,9 +56,9 @@ module TableSchema
           row = row.push(fill).flatten
         end
 
-        row.each_with_index do |col, i|
-          type_matches[i] ||= []
-          type_matches[i] << guess_type(col, i)
+        row.each_with_index do |col, idx|
+          type_matches[idx] ||= []
+          type_matches[idx] << guess_type(col, idx)
         end
 
       end
@@ -64,12 +67,12 @@ module TableSchema
     end
 
     def guess_type(col, index)
-      guessed_type = 'string'
-      guessed_format = 'default'
+      guessed_type = TableSchema::DEFAULTS[:type]
+      guessed_format = TableSchema::DEFAULTS[:format]
 
       available_types.reverse_each do |type|
         klass = get_class_for_type(type)
-        converter = Kernel.const_get(klass).new(@schema['fields'][index])
+        converter = Kernel.const_get(klass).new(@schema[:fields][index])
         if converter.test(col) === true
           guessed_type = type
           guessed_format = guess_format(converter, col)
@@ -78,22 +81,23 @@ module TableSchema
       end
 
       {
-        'type' => guessed_type,
-        'format' => guessed_format
+        type: guessed_type,
+        format: guessed_format
       }
     end
 
     def guess_format(converter, col)
-      guessed_format = 'default'
+      guessed_format = TableSchema::DEFAULTS[:format]
       converter.class.instance_methods.grep(/cast_/).each do |method|
         begin
           format = method.to_s
           format.slice!('cast_')
-          next if format == 'default'
+          next if format == TableSchema::DEFAULTS[:format]
           converter.send(method, col)
           guessed_format = format
           break
         rescue TableSchema::Exception
+          next
         end
       end
       guessed_format
@@ -116,7 +120,7 @@ module TableSchema
           rv = sorted_counts[0][0]
         end
 
-        @schema['fields'][v].merge!(rv)
+        @schema[:fields][v].merge!(rv)
       end
 
     end
@@ -128,7 +132,6 @@ module TableSchema
         'boolean',
         'number',
         'integer',
-        'null',
         'date',
         'time',
         'datetime',