tableschema 0.3.0

data/lib/tableschema/constraints/max_length.rb

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

data/lib/tableschema/constraints/maximum.rb

@@ -0,0 +1,14 @@
+module TableSchema
+  class Constraints
+    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']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/tableschema/constraints/min_length.rb

@@ -0,0 +1,15 @@
+module TableSchema
+  class Constraints
+    module MinLength
+
+      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']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/tableschema/constraints/minimum.rb

@@ -0,0 +1,14 @@
+module TableSchema
+  class Constraints
+    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']}")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/tableschema/constraints/pattern.rb

@@ -0,0 +1,14 @@
+module TableSchema
+  class Constraints
+    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")
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/tableschema/constraints/required.rb

@@ -0,0 +1,32 @@
+module TableSchema
+  class Constraints
+    module Required
+
+      def check_required
+        if required? && is_empty?
+          raise TableSchema::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/tableschema/data.rb

@@ -0,0 +1,60 @@
+module TableSchema
+  module Data
+
+    attr_reader :errors
+
+    def cast_rows(rows, fail_fast = true, limit = nil)
+      @errors ||= []
+      parsed_rows = []
+      rows.each_with_index do |r, i|
+        begin
+          break if limit && (limit <= i)
+          r = r.fields if r.class == CSV::Row
+          parsed_rows << cast_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
+      parsed_rows
+    end
+
+    alias_method :convert, :cast_rows
+
+    def cast_row(row, fail_fast = true)
+      @errors ||= []
+      raise_header_error(row) if row.count != fields.count
+      fields.each_with_index do |field,i|
+        row[i] = cast_column(field, row[i], fail_fast)
+      end
+      check_for_errors
+      row
+    end
+
+    alias_method :convert_row, :cast_row
+
+    private
+
+    def raise_header_error(row)
+      raise(TableSchema::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(TableSchema::MultipleInvalid.new("There were errors parsing the data")) if @errors.count > 0
+    end
+
+    def cast_column(field, col, fail_fast)
+      field.cast_value(col)
+    rescue Exception => e
+      if fail_fast == true
+        raise e
+      else
+        @errors << e
+      end
+    end
+
+    alias_method :convert_column, :cast_column
+
+  end
+end

data/lib/tableschema/exceptions.rb

@@ -0,0 +1,28 @@
+module TableSchema
+  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

data/lib/tableschema/field.rb

@@ -0,0 +1,41 @@
+module TableSchema
+  class Field < Hash
+    include TableSchema::Helpers
+
+    attr_reader :type_class
+
+    def initialize(descriptor)
+      self.merge! descriptor
+      @type_class = get_type
+    end
+
+    def name
+      self['name']
+    end
+
+    def type
+      self['type'] || 'string'
+    end
+
+    def format
+      self['format'] || 'default'
+    end
+
+    def constraints
+      self['constraints'] || {}
+    end
+
+    def cast_value(col)
+      klass = get_class_for_type(type)
+      converter = Kernel.const_get(klass).new(self)
+      converter.cast(col)
+    end
+
+    private
+
+      def get_type
+        Object.const_get get_class_for_type(type)
+      end
+
+  end
+end

data/lib/tableschema/helpers.rb

@@ -0,0 +1,48 @@
+module TableSchema
+  module Helpers
+
+    def convert_to_boolean(value)
+      if value.is_a?(Boolean)
+        return value
+      elsif true_values.include?(value.to_s.downcase)
+        true
+      elsif false_values.include?(value.to_s.downcase)
+        false
+      else
+        nil
+      end
+    end
+
+    def true_values
+      ['yes', 'y', 'true', 't', '1']
+    end
+
+    def false_values
+      ['no', 'n', 'false', 'f', '0']
+    end
+
+    def get_class_for_type(type)
+      "TableSchema::Types::#{type_class_lookup[type] || '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',
+      }
+    end
+
+  end
+end

data/lib/tableschema/infer.rb

@@ -0,0 +1,143 @@
+module TableSchema
+  class Infer
+
+    include TableSchema::Helpers
+
+    attr_reader :schema
+
+    def initialize(headers, rows, opts = {})
+      @headers = headers
+      @rows = rows
+      @explicit = opts[:explicit]
+      @primary_key = opts[:primary_key]
+      @row_limit = opts[:row_limit]
+
+      @schema = {
+        'fields' => fields
+      }
+      @schema['primaryKey'] = @primary_key if @primary_key
+      infer!
+    end
+
+    def fields
+      @headers.map do |header|
+        descriptor = {
+          '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
+      end
+    end
+
+    def infer!
+      type_matches = []
+      @rows.each_with_index do |row, i|
+        break if @row_limit && i > @row_limit
+        row = row.fields if row.class == CSV::Row
+
+        row_length = row.count
+        headers_length = @headers.count
+
+        if row_length > headers_length
+          row = row[0..headers_length]
+        elsif row_length < headers_length
+          diff = headers_length - row_length
+          fill = [''] * diff
+          row = row.push(fill).flatten
+        end
+
+        row.each_with_index do |col, i|
+          type_matches[i] ||= []
+          type_matches[i] << guess_type(col, i)
+        end
+
+      end
+      resolve_types(type_matches)
+      @schema = TableSchema::Schema.new(@schema)
+    end
+
+    def guess_type(col, index)
+      guessed_type = 'string'
+      guessed_format = 'default'
+
+      available_types.reverse_each do |type|
+        klass = get_class_for_type(type)
+        converter = Kernel.const_get(klass).new(@schema['fields'][index])
+        if converter.test(col) === true
+          guessed_type = type
+          guessed_format = guess_format(converter, col)
+          break
+        end
+      end
+
+      {
+        'type' => guessed_type,
+        'format' => guessed_format
+      }
+    end
+
+    def guess_format(converter, col)
+      guessed_format = 'default'
+      converter.class.instance_methods.grep(/cast_/).each do |method|
+        begin
+          format = method.to_s
+          format.slice!('cast_')
+          next if format == 'default'
+          converter.send(method, col)
+          guessed_format = format
+          break
+        rescue TableSchema::Exception
+        end
+      end
+      guessed_format
+    end
+
+    def resolve_types(results)
+      results.each_with_index do |result,v|
+        result.uniq!
+
+        if result.count == 1
+          rv = result[0]
+        else
+          counts = {}
+          result.each do |r|
+            counts[r] ||= 0
+            counts[r] += 1
+          end
+
+          sorted_counts = counts.sort_by {|_key, value| value}
+          rv = sorted_counts[0][0]
+        end
+
+        @schema['fields'][v].merge!(rv)
+      end
+
+    end
+
+    def available_types
+      [
+        'any',
+        'string',
+        'boolean',
+        'number',
+        'integer',
+        'null',
+        'date',
+        'time',
+        'datetime',
+        'array',
+        'object',
+        'geopoint',
+        'geojson'
+      ]
+    end
+
+  end
+end

data/lib/tableschema/model.rb

@@ -0,0 +1,73 @@
+module TableSchema
+  module Model
+
+    DEFAULTS = {
+      'format' => 'default',
+      'type' => 'string'
+    }
+
+    def headers
+      fields.map { |f| transform(f['name']) }
+    rescue NoMethodError
+      []
+    end
+
+    def fields
+      self['fields']
+    end
+
+    def primary_keys
+      [self['primaryKey']].flatten.reject { |k| k.nil? }
+    end
+
+    def foreign_keys
+      self['foreignKeys'] || []
+    end
+
+    def get_type(key)
+      get_field(key)['type']
+    end
+
+    def get_constraints(key)
+      get_field(key)['constraints'] || {}
+    end
+
+    def required_headers
+      fields.select { |f| f['constraints']!= nil && f['constraints']['required'] == true }
+            .map { |f| transform(f['name']) }
+    rescue NoMethodError
+      []
+    end
+
+    def has_field?(key)
+      get_field(key) != nil
+    end
+
+    def get_field(key)
+      fields.find { |f| f['name'] == key }
+    end
+
+    def get_fields_by_type(type)
+      fields.select { |f| f['type'] == type }
+    end
+
+    private
+
+      def transform(name)
+        name.downcase! if @opts[:case_insensitive_headers]
+        name
+      end
+
+      def expand!
+        (self['fields'] || []).each do |f|
+          f['type'] = DEFAULTS['type'] if f['type'] == nil
+          f['format'] = DEFAULTS['format'] if f['format'] == nil
+        end
+      end
+
+      def load_fields!
+        self['fields'] = (self['fields'] || []).map { |f| TableSchema::Field.new(f) }
+      end
+
+  end
+end