tableschema 0.3.1 → 0.4.0

data/lib/profiles/topojson.json

@@ -0,0 +1,311 @@
+{
+    "$schema":"http://json-schema.org/draft-04/schema#",
+    "title":"TopoJSON object",
+    "description":"Schema for a TopoJSON object",
+    "type":"object",
+    "required":[
+        "type"
+    ],
+    "properties":{
+        "bbox":{
+            "$ref":"#/definitions/bbox"
+        }
+    },
+    "oneOf":[
+        {
+            "$ref":"#/definitions/topology"
+        },
+        {
+            "$ref":"#/definitions/geometry"
+        }
+    ],
+    "definitions":{
+        "bbox":{
+            "title":"TopoJSON bounding box",
+            "description":"A bounding box as defined by TopoJSON",
+            "type":"array",
+            "items":{
+                "$ref":"#/definitions/bbox/definitions/dimension"
+            },
+            "minItems":2,
+            "maxItems":2,
+            "definitions":{
+                "dimension":{
+                    "type":"array",
+                    "description":"This array should have an entry per dimension in the geometries",
+                    "items":{
+                        "type":"number"
+                    }
+                }
+            }
+        },
+        "geometry":{
+            "title":"Geometry objects",
+            "description":"A Geometry object as defined by TopoJSON",
+            "type":"object",
+            "required":[
+                "type"
+            ],
+            "properties":{
+                "id":{
+                    "type":[
+                        "string",
+                        "integer"
+                    ]
+                },
+                "properties":{
+                    "type":"object"
+                }
+            },
+            "oneOf":[
+                {
+                    "title":"Point",
+                    "description":"A Point Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "coordinates"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "Point"
+                            ]
+                        },
+                        "coordinates":{
+                            "$ref":"#/definitions/geometry/definitions/position"
+                        }
+                    }
+                },
+                {
+                    "title":"MultiPoint",
+                    "description":"A MultiPoint Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "coordinates"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "MultiPoint"
+                            ]
+                        },
+                        "coordinates":{
+                            "type":"array",
+                            "items":{
+                                "$ref":"#/definitions/geometry/definitions/position"
+                            }
+                        }
+                    }
+                },
+                {
+                    "title":"LineString",
+                    "description":"A LineString Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "arcs"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "LineString"
+                            ]
+                        },
+                        "arcs":{
+                            "type":"array",
+                            "items":{
+                                "type":"integer"
+                            }
+                        }
+                    }
+                },
+                {
+                    "title":"MultiLineString",
+                    "description":"A MultiLineString Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "arcs"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "MultiLineString"
+                            ]
+                        },
+                        "arcs":{
+                            "type":"array",
+                            "items":{
+                                "type":"array",
+                                "items":{
+                                    "type":"integer"
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "title":"Polygon",
+                    "description":"A Polygon Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "arcs"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "Polygon"
+                            ]
+                        },
+                        "arcs":{
+                            "TODO":"Check if arcs refer to valid LinearRings",
+                            "type":"array",
+                            "items":{
+                                "type":"array",
+                                "items":{
+                                    "type":"integer"
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "title":"MultiPolygon",
+                    "description":"A MultiPolygon Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "arcs"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "MultiPolygon"
+                            ]
+                        },
+                        "arcs":{
+                            "type":"array",
+                            "items":{
+                                "type":"array",
+                                "items":{
+                                    "type":"array",
+                                    "items":{
+                                        "type":"integer"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    "title":"GeometryCollection",
+                    "description":"A MultiPolygon Geometry object as defined by TopoJSON",
+                    "required":[
+                        "type",
+                        "geometries"
+                    ],
+                    "properties":{
+                        "type":{
+                            "enum":[
+                                "GeometryCollection"
+                            ]
+                        },
+                        "geometries":{
+                            "type":"array",
+                            "items":{
+                                "$ref":"#/definitions/geometry"
+                            }
+                        }
+                    }
+                }
+            ],
+            "definitions":{
+                "position":{
+                    "type":"array",
+                    "items":{
+                        "type":"number"
+                    },
+                    "minItems":2
+                }
+            }
+
+        },
+        "topology":{
+            "title":"Topology",
+            "description":"A Topology object as defined by TopoJSON",
+            "type":"object",
+            "required":[
+                "objects",
+                "arcs"
+            ],
+            "properties":{
+                "type":{
+                    "enum":[
+                        "Topology"
+                    ]
+                },
+                "objects":{
+                    "type":"object",
+                    "additionalProperties":{
+                        "$ref":"#/definitions/geometry"
+                    }
+                },
+                "arcs":{
+                    "$ref":"#/definitions/topology/definitions/arcs"
+                },
+                "transform":{
+                    "$ref":"#/definitions/topology/definitions/transform"
+                },
+                "bbox":{
+                    "$ref":"#/definitions/bbox"
+                }
+            },
+            "definitions":{
+                "transform":{
+                    "type":"object",
+                    "required":[
+                        "scale",
+                        "translate"
+                    ],
+                    "properties":{
+                        "scale":{
+                            "type":"array",
+                            "items":{
+                                "type":"number"
+                            },
+                            "minItems":2
+                        },
+                        "translate":{
+                            "type":"array",
+                            "items":{
+                                "type":"number"
+                            },
+                            "minItems":2
+                        }
+                    }
+                },
+                "arcs":{
+                    "type":"array",
+                    "items":{
+                        "type":"array",
+                        "items":{
+                            "oneOf":[
+                                {
+                                    "$ref":"#/definitions/topology/definitions/position"
+                                },
+                                {
+                                    "type":"null"
+                                }
+                            ]
+                        },
+                        "minItems":2
+                    }
+                },
+                "position":{
+                    "type":"array",
+                    "items":{
+                        "type":"number"
+                    },
+                    "minItems":2
+                }
+            }
+        }
+    }
+}

data/lib/tableschema.rb

@@ -1,11 +1,11 @@
 require "json"
 require "json-schema"
 require "uuid"
-require "currencies"
 require "date"
 require "tod"
 require "tod/core_extensions"
 require "csv"
+require "active_support/duration"
 
 require "tableschema/version"
 require "tableschema/exceptions"
@@ -22,16 +22,18 @@ 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/types/year"
+require "tableschema/types/yearmonth"
+require "tableschema/types/duration"
+require "tableschema/defaults"
 
 require "tableschema/field"
 require "tableschema/validate"
 require "tableschema/model"
-require "tableschema/data"
 require "tableschema/schema"
 require "tableschema/table"
 require "tableschema/infer"

data/lib/tableschema/constraints/constraints.rb

@@ -5,6 +5,7 @@ require "tableschema/constraints/minimum"
 require "tableschema/constraints/maximum"
 require "tableschema/constraints/enum"
 require "tableschema/constraints/pattern"
+require "tableschema/constraints/unique"
 
 module TableSchema
   class Constraints
@@ -17,21 +18,22 @@ module TableSchema
     include TableSchema::Constraints::Maximum
     include TableSchema::Constraints::Enum
     include TableSchema::Constraints::Pattern
+    include TableSchema::Constraints::Unique
 
     def initialize(field, value)
       @field = field
       @value = value
-      @constraints = @field['constraints'] || {}
+      @constraints = ordered_constraints
     end
 
     def validate!
       result = true
       @constraints.each do |c|
-        constraint = c.first
+        constraint = c.first.to_s
         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"))
+          raise(TableSchema::ConstraintNotSupported.new("The field type `#{@field[:type]}` does not support the `#{constraint}` constraint"))
         end
       end
       result
@@ -47,29 +49,15 @@ module TableSchema
             downcase
     end
 
-    def is_supported_type?(constraint)
-      klass = get_class_for_type(@field['type'])
-      Kernel.const_get(klass).supported_constraints.include?(constraint)
+    def ordered_constraints
+      constraints = @field.fetch(:constraints, {})
+      ordered_constraints = constraints.select{ |key| key == :required}
+      ordered_constraints.merge!(constraints)
     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
+    def is_supported_type?(constraint)
+      klass = get_class_for_type(@field[:type])
+      Kernel.const_get(klass).supported_constraints.include?(constraint)
     end
 
   end

data/lib/tableschema/constraints/enum.rb

@@ -3,12 +3,16 @@ module TableSchema
     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")
+        unless parsed_enum.include?(@value)
+          raise TableSchema::ConstraintError.new("The value for the field `#{@field[:name]}` must be in the enum array")
         end
         true
       end
 
+      def parsed_enum
+        @constraints[:enum].map{ |value| @field.cast_type(value) }
+      end
+
     end
   end
 end

data/lib/tableschema/constraints/max_length.rb

@@ -4,12 +4,16 @@ module TableSchema
 
       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']}")
+        if @value.length > parsed_max_length
+          raise TableSchema::ConstraintError.new("The field `#{@field[:name]}` must have a maximum length of #{@constraints[:maxLength]}")
         end
         true
       end
 
+      def parsed_max_length
+         @constraints[:maxLength].to_i
+      end
+
     end
   end
 end