tableschema 0.3.0

data/lib/tableschema/schema.rb

@@ -0,0 +1,36 @@
+module TableSchema
+  class Schema < Hash
+    include TableSchema::Validate
+    include TableSchema::Model
+    include TableSchema::Data
+    include TableSchema::Helpers
+
+    def initialize(descriptor, opts = {})
+      self.merge! parse_schema(descriptor)
+      @messages = []
+      @opts = opts
+      load_fields!
+      load_validator!
+      expand!
+    end
+
+    def parse_schema(descriptor)
+      if descriptor.class == Hash
+        descriptor
+      elsif descriptor.class == String
+        begin
+          JSON.parse open(descriptor).read
+        rescue Errno::ENOENT
+          raise SchemaException.new("File not found at `#{descriptor}`")
+        rescue OpenURI::HTTPError => e
+          raise SchemaException.new("URL `#{descriptor}` returned #{e.message}")
+        rescue JSON::ParserError
+          raise SchemaException.new("File at `#{descriptor}` is not valid JSON")
+        end
+      else
+        raise SchemaException.new("A schema must be a hash, path or URL")
+      end
+    end
+
+  end
+end

data/lib/tableschema/table.rb

@@ -0,0 +1,51 @@
+module TableSchema
+  class Table
+
+    attr_reader :schema
+
+    def self.infer_schema(csv, opts = {})
+      TableSchema::Table.new(csv, nil, opts)
+    end
+
+    def initialize(csv, descriptor, opts = {})
+      @opts = opts
+      @csv = parse_csv(csv)
+      @schema = descriptor.nil? ? infer_schema(@csv) : TableSchema::Schema.new(descriptor)
+    end
+
+    def parse_csv(csv)
+      csv = csv.is_a?(Array) ? StringIO.new(array_to_csv csv) : open(csv)
+      CSV.new(csv, csv_options)
+    end
+
+    def csv_options
+      (@opts[:csv_options] || {}).merge(headers: true)
+    end
+
+    def rows(opts = {})
+      fail_fast = opts[:fail_fast] || opts[:fail_fast].nil?
+      converted = @schema.cast_rows(@csv, fail_fast, opts[:limit])
+      opts[:keyed] ? coverted_to_hash(@csv.headers, converted) : converted
+    end
+
+    private
+
+      def array_to_csv(array)
+        array.map { |row| row.to_csv(row_sep: nil) }.join("\r\n")
+      end
+
+      def coverted_to_hash(headers, array)
+        array.map do |row|
+          Hash[row.map.with_index { |col, i| [headers[i], col] }]
+        end
+      end
+
+      def infer_schema(csv)
+        headers = csv.first.to_h.keys
+        csv.rewind
+        inferer = TableSchema::Infer.new(headers, csv)
+        inferer.schema
+      end
+
+  end
+end

data/lib/tableschema/types/any.rb

@@ -0,0 +1,23 @@
+module TableSchema
+  module Types
+    class Any < Base
+
+      def name
+        'any'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum'
+        ]
+      end
+
+      def cast_default(value)
+        value
+      end
+
+    end
+  end
+end

data/lib/tableschema/types/array.rb

@@ -0,0 +1,37 @@
+module TableSchema
+  module Types
+    class Array < Base
+
+      def name
+        'array'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum',
+          'minLength',
+          'maxLength',
+        ]
+      end
+
+      def type
+        ::Array
+      end
+
+      def cast_default(value)
+        return value if value.is_a?(type)
+        parsed = JSON.parse(value)
+        if parsed.is_a?(type)
+          return parsed
+        else
+          raise TableSchema::InvalidArrayType.new("#{value} is not a valid array")
+        end
+      rescue
+        raise TableSchema::InvalidArrayType.new("#{value} is not a valid array")
+      end
+
+    end
+  end
+end

data/lib/tableschema/types/base.rb

@@ -0,0 +1,54 @@
+module TableSchema
+  module Types
+    class Base
+      include TableSchema::Helpers
+
+
+      def initialize(field)
+        @field = field
+        @constraints = field['constraints'] || {}
+        @required = ['true', true].include?(@constraints['required'])
+        @type = @field['type']
+        set_format
+      end
+
+      def cast(value, skip_constraints = false)
+        TableSchema::Constraints.new(@field, value).validate! unless skip_constraints
+        return nil if is_null?(value)
+        send("cast_#{@format}", value)
+      rescue NoMethodError => e
+        if e.message.start_with?('undefined method `cast_')
+          raise(TableSchema::InvalidFormat.new("The format `#{@format}` is not supported by the type `#{@type}`"))
+        else
+          raise e
+        end
+      end
+
+      def test(value)
+        cast(value, true)
+        true
+      rescue TableSchema::Exception
+        false
+      end
+
+      def set_format
+        if (@field['format'] || '').start_with?('fmt:')
+          @format, @format_string = *@field['format'].split(':', 2)
+        else
+          @format = @field['format'] || 'default'
+        end
+      end
+
+      private
+
+        def is_null?(value)
+          null_values.include?(value) && @required == false
+        end
+
+        def null_values
+          ['null', 'none', 'nil', 'nan', '-', '']
+        end
+
+    end
+  end
+end

data/lib/tableschema/types/boolean.rb

@@ -0,0 +1,35 @@
+# Hack to check against one type from http://stackoverflow.com/a/3028378/452684
+# because Ruby doesn't have a single boolean class
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+
+module TableSchema
+  module Types
+    class Boolean < Base
+
+      def name
+        'boolean'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum',
+        ]
+      end
+
+      def type
+        ::Boolean
+      end
+
+      def cast_default(value)
+        value = convert_to_boolean(value)
+        raise TableSchema::InvalidCast.new("#{value} is not a #{name}") if value.nil?
+        value
+      end
+
+    end
+  end
+end

data/lib/tableschema/types/date.rb

@@ -0,0 +1,56 @@
+module TableSchema
+  module Types
+    class Date < Base
+
+      def name
+        'date'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum',
+          'minimum',
+          'maximum',
+        ]
+      end
+
+      def type
+        ::Date
+      end
+
+      def iso8601
+        '%Y-%m-%d'
+      end
+
+      def cast_default(value)
+        @format_string = iso8601
+        cast_fmt(value)
+      end
+
+      def cast_any(value)
+        return value if value.is_a?(type)
+
+        date = ::Date._parse(value)
+        if date.values.count == 3
+          ::Date.parse(value)
+        else
+          raise TableSchema::InvalidDateType.new("#{value} is not a valid date")
+        end
+      end
+
+      def cast_fmt(value)
+        return value if value.is_a?(type)
+
+        begin
+          return ::Date.strptime(value, @format_string)
+        rescue ArgumentError
+          raise TableSchema::InvalidDateType.new("#{value} is not a valid date")
+        end
+      end
+
+
+    end
+  end
+end

data/lib/tableschema/types/datetime.rb

@@ -0,0 +1,63 @@
+module TableSchema
+  module Types
+    class DateTime < Base
+
+      def name
+        'datetime'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum',
+          'minimum',
+          'maximum'
+        ]
+      end
+
+      def type
+        ::DateTime
+      end
+
+      def iso8601
+        '%Y-%m-%dT%H:%M:%SZ'
+      end
+
+      # raw_formats = ['DD/MM/YYYYThh/mm/ss']
+      # py_formats = ['%Y/%m/%dT%H:%M:%S']
+      # format_map = dict(zip(raw_formats, py_formats))
+
+      def cast_default(value)
+        @format_string = iso8601
+        cast_fmt(value)
+      end
+
+      def cast_any(value)
+        return value if value.is_a?(type)
+
+        begin
+          date = ::DateTime._parse(value)
+          if date.values.count >= 4
+            ::DateTime.parse(value)
+          else
+            raise TableSchema::InvalidDateTimeType.new("#{value} is not a valid datetime")
+          end
+        rescue ArgumentError
+          raise TableSchema::InvalidDateTimeType.new("#{value} is not a valid datetime")
+        end
+      end
+
+      def cast_fmt(value)
+        return value if value.is_a?(type)
+
+        begin
+          return ::DateTime.strptime(value, @format_string)
+        rescue ArgumentError
+          raise TableSchema::InvalidDateTimeType.new("#{value} is not a valid date")
+        end
+      end
+
+    end
+  end
+end

data/lib/tableschema/types/geojson.rb

@@ -0,0 +1,38 @@
+module TableSchema
+  module Types
+    class GeoJSON < Base
+
+      def name
+        'geojson'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum'
+        ]
+      end
+
+      def type
+        ::Hash
+      end
+
+      def cast_default(value)
+        value = JSON.parse(value) if !value.is_a?(type)
+        JSON::Validator.validate!(geojson_schema, value)
+        value
+      rescue JSON::Schema::ValidationError, JSON::ParserError
+        raise TableSchema::InvalidGeoJSONType.new("#{value} is not valid GeoJSON")
+      end
+
+      private
+
+      def geojson_schema
+        path = File.join( File.dirname(__FILE__), "..", "..", "..", "etc", "schemas", "geojson.json" )
+        @geojson_schema ||= JSON.parse File.read(path)
+      end
+
+    end
+  end
+end

data/lib/tableschema/types/geopoint.rb

@@ -0,0 +1,56 @@
+module TableSchema
+  module Types
+    class GeoPoint < Base
+
+      def name
+        'geopoint'
+      end
+
+      def self.supported_constraints
+        [
+          'required',
+          'pattern',
+          'enum'
+        ]
+      end
+
+      def types
+        [::String, ::Array, ::Hash]
+      end
+
+      def cast_default(value)
+        latlng = value.split(',', 2)
+        cast_array([latlng[0], latlng[1]])
+      end
+
+      def cast_object(value)
+        value = JSON.parse(value) if value.is_a?(::String)
+        cast_array([value['longitude'], value['latitude']])
+      rescue JSON::ParserError
+        raise TableSchema::InvalidGeoPointType.new("#{value} is not a valid geopoint")
+      end
+
+      def cast_array(value)
+        value = JSON.parse(value) if value.is_a?(::String)
+        value = [Float(value[0]), Float(value[1])]
+        check_latlng_range(value)
+        value
+      rescue JSON::ParserError, ArgumentError, TypeError
+        raise TableSchema::InvalidGeoPointType.new("#{value} is not a valid geopoint")
+      end
+
+      private
+
+      def check_latlng_range(geopoint)
+        longitude = geopoint[0]
+        latitude = geopoint[1]
+        if longitude >= 180 or longitude <= -180
+          raise TableSchema::InvalidGeoPointType.new("longtitude should be between -180 and 180, found `#{longitude}`")
+        elsif latitude >= 90 or latitude <= -90
+          raise TableSchema::InvalidGeoPointType.new("longtitude should be between -90 and 90, found `#{latitude}`")
+        end
+      end
+
+    end
+  end
+end