json-schema 1.2.1 → 2.0.0

data/lib/json-schema/attributes/type_v4.rb

@@ -0,0 +1,54 @@
+module JSON
+  class Schema
+    class TypeV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        union = true
+        types = current_schema.schema['type']
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        end
+        valid = false
+
+        # Create an array to hold errors that are generated during union validation
+        union_errors = []
+
+        types.each do |type|
+          valid = data_valid_for_type?(data, type)
+          break if valid
+        end
+
+        if !valid
+          if union
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the following types:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+            validation_errors(processor).last.sub_errors = union_errors
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match the following type:"
+            types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
+            message.chop!
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+
+      TYPE_CLASS_MAPPINGS = {
+        "string" => String,
+        "number" => Numeric,
+        "integer" => Integer,
+        "boolean" => [TrueClass, FalseClass],
+        "object" => Hash,
+        "array" => Array,
+        "null" => NilClass,
+        "any" => Object
+      }
+
+      def self.data_valid_for_type?(data, type)
+        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
+        Array(valid_classes).any? { |c| data.is_a?(c) }
+      end
+    end
+  end
+end

data/lib/json-schema/schema.rb

@@ -4,11 +4,11 @@ module JSON
   class Schema
 
     attr_accessor :schema, :uri, :validator
-    
+
     def initialize(schema,uri,parent_validator=nil)
       @schema = schema
       @uri = uri
-      
+
       # If there is an ID on this schema, use it to generate the URI
       if @schema['id']
         temp_uri = URI.parse(@schema['id'])
@@ -19,7 +19,7 @@ module JSON
         @uri = temp_uri
       end
       @uri.fragment = ''
-      
+
       # If there is a $schema on this schema, use it to determine which validator to use
       if @schema['$schema']
         u = URI.parse(@schema['$schema'])
@@ -31,13 +31,13 @@ module JSON
         @validator = parent_validator
       else
         @validator = JSON::Validator.default_validator
-      end  
+      end
     end
-    
+
     def validate(data, fragments, processor, options = {})
       @validator.validate(self, data, fragments, processor, options)
     end
-    
+
     def base_uri
       parts = @uri.to_s.split('/')
       parts.pop

data/lib/json-schema/validator.rb

@@ -111,8 +111,7 @@ module JSON
       :validate_schema => false,
       :record_errors => false,
       :errors_as_objects => false,
-      :insert_defaults => false,
-      :strict => false
+      :insert_defaults => false
     }
     @@validators = {}
     @@default_validator = nil
@@ -123,8 +122,10 @@ module JSON
 
     def self.version_string_for(version)
       # I'm not a fan of this, but it's quick and dirty to get it working for now
-      return "draft-03" unless version
+      return "draft-04" unless version
       case version.to_s
+      when "draft4"
+        "draft-04"
       when "draft3"
         "draft-03"
       when "draft2"
@@ -145,7 +146,7 @@ module JSON
       @errors = []
 
       # I'm not a fan of this, but it's quick and dirty to get it working for now
-      version_string = "draft-03"
+      version_string = "draft-04"
       if @options[:version]
         version_string = @options[:version] = self.class.version_string_for(@options[:version])
         u = URI.parse("http://json-schema.org/#{@options[:version]}/schema#")
@@ -155,7 +156,6 @@ module JSON
 
       @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
       @validation_options[:insert_defaults] = true if @options[:insert_defaults]
-      @validation_options[:strict] = true if @options[:strict] == true
 
       # validate the schema, if requested
       if @options[:validate_schema]
@@ -248,6 +248,13 @@ module JSON
         end
       end
 
+      # "definitions" are schemas in V4
+      if parent_schema.schema["definitions"]
+        parent_schema.schema["definitions"].each do |k,v|
+          handle_schema(parent_schema, v)
+        end
+      end
+
       # All properties are schemas
       if parent_schema.schema["properties"]
         parent_schema.schema["properties"].each do |k,v|
@@ -286,7 +293,7 @@ module JSON
     def handle_schema(parent_schema, obj)
       if obj.is_a?(Hash)
         schema_uri = parent_schema.uri.clone
-        schema = JSON::Schema.new(obj,schema_uri,@options[:version])
+        schema = JSON::Schema.new(obj,schema_uri,parent_schema.validator)
         if obj['id']
           Validator.add_schema(schema)
         end
@@ -504,7 +511,11 @@ module JSON
           schema_uri = URI.parse(fake_uri(schema))
           schema = JSON::Validator.parse(schema)
           if @options[:list]
-            schema = {"type" => "array", "items" => schema}
+            new_schema = {"type" => "array", "items" => schema}
+            if !schema["$schema"].nil?
+              new_schema["$schema"] = schema["$schema"]
+            end
+            schema = new_schema
           end
           schema = JSON::Schema.new(schema,schema_uri,@options[:version])
           Validator.add_schema(schema)
@@ -522,7 +533,11 @@ module JSON
           if Validator.schemas[schema_uri.to_s].nil?
             schema = JSON::Validator.parse(open(schema_uri.to_s).read)
             if @options[:list]
-              schema = {"type" => "array", "items" => schema}
+              new_schema = {"type" => "array", "items" => schema}
+              if !schema["$schema"].nil?
+                new_schema["$schema"] = schema["$schema"]
+              end
+              schema = new_schema
             end
             schema = JSON::Schema.new(schema,schema_uri,@options[:version])
             Validator.add_schema(schema)
@@ -532,7 +547,11 @@ module JSON
         end
       elsif schema.is_a?(Hash)
         if @options[:list]
-          schema = {"type" => "array", "items" => schema}
+          new_schema = {"type" => "array", "items" => schema}
+          if !schema["$schema"].nil?
+            new_schema["$schema"] = schema["$schema"]
+          end
+          schema = new_schema
         end
         schema_uri = URI.parse(fake_uri(serialize(schema)))
         schema = JSON::Schema.new(schema,schema_uri,@options[:version])

data/lib/json-schema/validators/draft4.rb

@@ -0,0 +1,45 @@
+module JSON
+  class Schema
+
+    class Draft4 < Validator
+      def initialize
+        super
+        @attributes = {
+          "type" => JSON::Schema::TypeV4Attribute,
+          "allOf" => JSON::Schema::AllOfAttribute,
+          "anyOf" => JSON::Schema::AnyOfAttribute,
+          "oneOf" => JSON::Schema::OneOfAttribute,
+          "not" => JSON::Schema::NotAttribute,
+          "disallow" => JSON::Schema::DisallowAttribute,
+          "format" => JSON::Schema::FormatAttribute,
+          "maximum" => JSON::Schema::MaximumAttribute,
+          "minimum" => JSON::Schema::MinimumAttribute,
+          "minItems" => JSON::Schema::MinItemsAttribute,
+          "maxItems" => JSON::Schema::MaxItemsAttribute,
+          "minProperties" => JSON::Schema::MinPropertiesAttribute,
+          "maxProperties" => JSON::Schema::MaxPropertiesAttribute,
+          "uniqueItems" => JSON::Schema::UniqueItemsAttribute,
+          "minLength" => JSON::Schema::MinLengthAttribute,
+          "maxLength" => JSON::Schema::MaxLengthAttribute,
+          "multipleOf" => JSON::Schema::MultipleOfAttribute,
+          "enum" => JSON::Schema::EnumAttribute,
+          "properties" => JSON::Schema::PropertiesV4Attribute,
+          "required" => JSON::Schema::RequiredAttribute,
+          "pattern" => JSON::Schema::PatternAttribute,
+          "patternProperties" => JSON::Schema::PatternPropertiesAttribute,
+          "additionalProperties" => JSON::Schema::AdditionalPropertiesAttribute,
+          "items" => JSON::Schema::ItemsAttribute,
+          "additionalItems" => JSON::Schema::AdditionalItemsAttribute,
+          "dependencies" => JSON::Schema::DependenciesV4Attribute,
+          "extends" => JSON::Schema::ExtendsAttribute,
+          "$ref" => JSON::Schema::RefAttribute
+        }
+        @uri = URI.parse("http://json-schema.org/draft-04/schema#")
+      end
+
+      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_default_validator(self.new)
+    end
+
+  end
+end

data/resources/draft-04.json

@@ -0,0 +1,174 @@
+{
+    "$schema": "http://json-schema.org/draft-03/schema#",
+    "id": "http://json-schema.org/draft-03/schema#",
+    "type": "object",
+    
+    "properties": {
+        "type": {
+            "type": [ "string", "array" ],
+            "items": {
+                "type": [ "string", { "$ref": "#" } ]
+            },
+            "uniqueItems": true,
+            "default": "any"
+        },
+        
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        
+        "additionalProperties": {
+            "type": [ { "$ref": "#" }, "boolean" ],
+            "default": {}
+        },
+        
+        "items": {
+            "type": [ { "$ref": "#" }, "array" ],
+            "items": { "$ref": "#" },
+            "default": {}
+        },
+        
+        "additionalItems": {
+            "type": [ { "$ref": "#" }, "boolean" ],
+            "default": {}
+        },
+        
+        "required": {
+            "type": "boolean",
+            "default": false
+        },
+        
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "type": [ "string", "array", { "$ref": "#" } ],
+                "items": {
+                    "type": "string"
+                }
+            },
+            "default": {}
+        },
+        
+        "minimum": {
+            "type": "number"
+        },
+        
+        "maximum": {
+            "type": "number"
+        },
+        
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        
+        "minItems": {
+            "type": "integer",
+            "minimum": 0,
+            "default": 0
+        },
+        
+        "maxItems": {
+            "type": "integer",
+            "minimum": 0
+        },
+        
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        
+        "minLength": {
+            "type": "integer",
+            "minimum": 0,
+            "default": 0
+        },
+        
+        "maxLength": {
+            "type": "integer"
+        },
+        
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        
+        "default": {
+            "type": "any"
+        },
+        
+        "title": {
+            "type": "string"
+        },
+        
+        "description": {
+            "type": "string"
+        },
+        
+        "format": {
+            "type": "string"
+        },
+        
+        "divisibleBy": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true,
+            "default": 1
+        },
+        
+        "disallow": {
+            "type": [ "string", "array" ],
+            "items": {
+                "type": [ "string", { "$ref": "#" } ]
+            },
+            "uniqueItems": true
+        },
+        
+        "extends": {
+            "type": [ { "$ref": "#" }, "array" ],
+            "items": { "$ref": "#" },
+            "default": {}
+        },
+        
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        
+        "$ref": {
+            "type": "string",
+            "format": "uri"
+        },
+        
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        }
+    },
+    
+    "dependencies": {
+        "exclusiveMinimum": "minimum",
+        "exclusiveMaximum": "maximum"
+    },
+    
+    "default": {}
+}

data/test/{test_files.rb → test_files_v3.rb}

@@ -2,37 +2,37 @@ require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/json-schema'
 
 class JSONSchemaTest < Test::Unit::TestCase
-  
+
   #
   # These tests are ONLY run if there is an appropriate JSON backend parser available
   #
-  
+
   def test_schema_from_file
     data = {"a" => 5}
     assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
     data = {"a" => "bad"}
     assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
   end
-  
+
   def test_data_from_file
-    schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+    schema = {"$schema" => "http://json-schema.org/draft-03/schema#","type" => "object", "properties" => {"a" => {"type" => "integer"}}}
     assert(JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
     assert(!JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
   end
-  
+
   def test_data_from_json
     if JSON::Validator.json_backend != nil
-      schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+      schema = {"$schema" => "http://json-schema.org/draft-03/schema#","type" => "object", "properties" => {"a" => {"type" => "integer"}}}
       assert(JSON::Validator.validate_json(schema, %Q({"a" : 5})))
       assert(!JSON::Validator.validate_json(schema, %Q({"a" : "poop"})))
     end
   end
-  
+
   def test_both_from_file
     assert(JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
     assert(!JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
   end
-    
+
   def test_file_ref
     data = {"b" => {"a" => 5}}
     assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_2.json"),data))