json-schema 1.2.1 → 2.0.0

data/README.textile

@@ -1,6 +1,10 @@
 h1. Ruby JSON Schema Validator
 
-This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03. Legacy support for "JSON Schema Draft 2":http://tools.ietf.org/html/draft-zyp-json-schema-02 and "JSON Schema Draft 1":http://tools.ietf.org/html/draft-zyp-json-schema-01 is also included.
+This library is intended to provide Ruby with an interface for validating JSON objects against a JSON schema conforming to "JSON Schema Draft 4":http://tools.ietf.org/html/draft-zyp-json-schema-04. Legacy support for "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03, "JSON Schema Draft 2":http://tools.ietf.org/html/draft-zyp-json-schema-02, and "JSON Schema Draft 1":http://tools.ietf.org/html/draft-zyp-json-schema-01 is also included.
+
+h2. Version 2.0.0 Upgrade Notes
+
+Please be aware that the upgrade to version 2.0.0 will use Draft-04 *by default*, so schemas that do not declare a validator using the `$schema` keyword will use Draft-04 now instead of Draft-03. This is the reason for the major version upgrade.
 
 h2. Dependencies
 
@@ -18,7 +22,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-1.2.1.gem
+$ gem install json-schema-2.0.0.gem
 </pre>
 
 
@@ -28,7 +32,7 @@ Three base validation methods exist: <code>validate</code>, <code>validate!</cod
 
 All methods take two arguments, which can be either a JSON string, a file containing JSON, or a Ruby object representing JSON data. The first argument to these methods is always the schema, the second is always the data to validate. An optional third options argument is also accepted; available options are used in the examples below.
 
-By default, the validator uses the "JSON Schema Draft 3":http://tools.ietf.org/html/draft-zyp-json-schema-03 specification for validation; however, the user is free to specify additional specifications or extend existing ones. Legacy support for Draft 1 and Draft 2 is included by either passing an optional <code>:version</code> parameter to the <code>validate</code> method (set either as <code>:draft1</code> or <code>draft2</code>), or by declaring the <code>$schema</code> attribute in the schema and referencing the appropriate specification URI. Note that the <code>$schema</code> attribute takes precedence over the <code>:version</code> option during parsing and validation.
+By default, the validator uses the "JSON Schema Draft 4":http://tools.ietf.org/html/draft-zyp-json-schema-04 specification for validation; however, the user is free to specify additional specifications or extend existing ones. Legacy support for Draft 1, Draft 2, and Draft 3 is included by either passing an optional <code>:version</code> parameter to the <code>validate</code> method (set either as <code>:draft1</code> or <code>draft2</code>), or by declaring the <code>$schema</code> attribute in the schema and referencing the appropriate specification URI. Note that the <code>$schema</code> attribute takes precedence over the <code>:version</code> option during parsing and validation.
 
 h3. Validate Ruby objects against a Ruby schema
 
@@ -38,8 +42,9 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => true}
+    "a" => {"type" => "integer"}
   }
 }
 
@@ -69,27 +74,6 @@ data = ['user','user','user']
 JSON::Validator.validate('user.json', data, :list => true)
 </pre>
 
-h3. Strictly validate an object's properties
-
-With the <code>:strict</code>code> option, validation fails when an object contains properties that are not defined in the schema's property list or doesn't match the <code>additionalProperties</code> property. Furthermore, all properties are treated as <code>required</code> by default.
-
-<pre>
-require 'rubygems'
-require 'json-schema'
-
-schema = {
-  "type" => "object",
-  "properties" => {
-    "a" => {"type" => "integer"},
-    "b" => {"type" => "integer"}
-  }
-}
-
-JSON::Validator.validate(schema, {"a" => 1, "b" => 2}, :strict => true)            # ==> true
-JSON::Validator.validate(schema, {"a" => 1, "b" => 2, "c" => 3}, :strict => true)  # ==> false
-JSON::Validator.validate(schema, {"a" => 1}, :strict => true)                      # ==> false
-</pre>
-
 h3. Catch a validation error and print it out
 
 <pre>
@@ -98,8 +82,9 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => true}
+    "a" => {"type" => "integer"}
   }
 }
 
@@ -123,9 +108,10 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a","b"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => true},
-    "b" => {"type" => "string", "required" => "true"}
+    "a" => {"type" => "integer"},
+    "b" => {"type" => "string"}
   }
 }
 
@@ -146,9 +132,10 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a","b"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => true},
-    "b" => {"type" => "string", "required" => "true"}
+    "a" => {"type" => "integer"},
+    "b" => {"type" => "string"}
   }
 }
 
@@ -170,8 +157,9 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer", "required" => "true"}  # This will fail schema validation!
+    "a" => {"type" => "integer"}  # This will fail schema validation!
   }
 }
 
@@ -193,8 +181,9 @@ require 'json-schema'
 
 schema = {
   "type" => "object",
+  "required" => ["a"],
   "properties" => {
-    "a" => {"type" => "integer", "default" => 42, "required" => "true"},
+    "a" => {"type" => "integer", "default" => 42},
     "b" => {"type" => "integer"}
   }
 }

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

@@ -0,0 +1,37 @@
+module JSON
+  class Schema
+    class AllOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create an array to hold errors that are generated during validation
+        errors = []
+        valid = true
+
+        current_schema.schema['allOf'].each do |element|
+          schema = JSON::Schema.new(element,current_schema.uri,validator)
+
+          # We're going to add a little cruft here to try and maintain any validation errors that occur in the allOf
+          # We'll handle this by keeping an error count before and after validation, extracting those errors and pushing them onto an error array
+          pre_validation_error_count = validation_errors(processor).count
+
+          begin
+            schema.validate(data,fragments,processor,options)
+          rescue ValidationError
+            valid = false
+          end
+
+          diff = validation_errors(processor).count - pre_validation_error_count
+          while diff > 0
+            diff = diff - 1
+            errors.push(validation_errors(processor).pop)
+          end
+        end
+
+        if !valid
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match all of the required schemas"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          validation_errors(processor).last.sub_errors = errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module JSON
+  class Schema
+    class AnyOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create an array to hold errors that are generated during validation
+        errors = []
+        valid = false
+
+        current_schema.schema['anyOf'].each do |element|
+          schema = JSON::Schema.new(element,current_schema.uri,validator)
+
+          # We're going to add a little cruft here to try and maintain any validation errors that occur in the anyOf
+          # We'll handle this by keeping an error count before and after validation, extracting those errors and pushing them onto a union error
+          pre_validation_error_count = validation_errors(processor).count
+
+          begin
+            schema.validate(data,fragments,processor,options)
+            valid = true
+          rescue ValidationError
+            # We don't care that these schemas don't validate - we only care that one validated
+          end
+
+          diff = validation_errors(processor).count - pre_validation_error_count
+          valid = false if diff > 0
+          while diff > 0
+            diff = diff - 1
+            errors.push(validation_errors(processor).pop)
+          end
+
+          break if valid
+        end
+
+        if !valid
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the required schemas"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          validation_errors(processor).last.sub_errors = errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module JSON
+  class Schema
+    class DependenciesV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['dependencies'].each do |property,dependency_value|
+            if data.has_key?(property) && dependency_value.is_a?(Array)
+              dependency_value.each do |value|
+                if !data.has_key?(value)
+                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                  validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MaxPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash) && (data.size > current_schema.schema['maxProperties'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of properties #{current_schema.schema['maxProperties']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MinPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash) && (data.size < current_schema.schema['minProperties'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of properties #{current_schema.schema['minProperties']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module JSON
+  class Schema
+    class MultipleOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Numeric)
+          if current_schema.schema['multipleOf'] == 0 ||
+             current_schema.schema['multipleOf'] == 0.0 ||
+             (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['multipleOf'].to_s)).to_f != 0
+             message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['multipleOf']}"
+             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module JSON
+  class Schema
+    class NotAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+
+        schema = JSON::Schema.new(current_schema.schema['not'],current_schema.uri,validator)
+        failed = true
+        begin
+          schema.validate(data,fragments,processor,options)
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched the disallowed schema"
+          failed = false
+        rescue
+          # Yay, we failed validation
+        end
+
+        unless failed
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module JSON
+  class Schema
+    class OneOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        matched = false
+        valid = false
+
+        current_schema.schema['oneOf'].each do |element|
+          schema = JSON::Schema.new(element,current_schema.uri,validator)
+
+          begin
+            schema.validate(data,fragments,processor,options)
+            if matched
+              valid = false
+            else
+              matched = true
+              valid = true
+            end
+          rescue ValidationError
+          end
+
+        end
+
+        if !valid
+          if matched
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched more than one of the required schemas"
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match any of the required schemas"
+          end
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module JSON
               data[property] = (default.is_a?(Hash) ? default.clone : default)
             end
 
-            if (property_schema['required'] || options[:strict] == true) and !data.has_key?(property)
+            if property_schema['required'] and !data.has_key?(property)
               message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
               validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
             end
@@ -21,31 +21,6 @@ module JSON
               fragments.pop
             end
           end
-
-          # When strict is true, ensure no undefined properties exist in the data
-          if (options[:strict] == true && !current_schema.schema.has_key?('additionalProperties'))
-            diff = data.select do |k,v|
-              if current_schema.schema.has_key?('patternProperties')
-                match = false
-                current_schema.schema['patternProperties'].each do |property,property_schema|
-                  r = Regexp.new(property)
-                  if r.match(k)
-                    match = true
-                    break
-                  end
-                end
-
-                !current_schema.schema['properties'].has_key?(k.to_s) && !current_schema.schema['properties'].has_key?(k.to_sym) && !match
-              else
-                !current_schema.schema['properties'].has_key?(k.to_s) && !current_schema.schema['properties'].has_key?(k.to_sym)
-              end
-            end
-
-            if diff.size > 0
-              message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{diff.keys.join(", ")}'"
-              validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-            end
-          end
         end
       end
     end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class PropertiesV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['properties'].each do |property,property_schema|
+            if !data.has_key?(property) and property_schema['default'] and !property_schema['readonly'] and options[:insert_defaults]
+              default = property_schema['default']
+              data[property] = (default.is_a?(Hash) ? default.clone : default)
+            end
+
+            if data.has_key?(property)
+              schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
+              fragments << property
+              schema.validate(data[property],fragments,processor,options)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class RequiredAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['required'].each do |property,property_schema|
+            if !data.has_key?(property)
+              prop_defaults = options[:insert_defaults] &&
+                              current_schema.schema['properties'] &&
+                              current_schema.schema['properties'][property] &&
+                              !current_schema.schema['properties'][property]["default"].nil? &&
+                              !current_schema.schema['properties'][property]["readonly"]
+              if !prop_defaults
+                message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+                validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,6 @@ module JSON
     class TypeAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         union = true
-
         if options[:disallow]
           types = current_schema.schema['disallow']
         else
@@ -15,28 +14,28 @@ module JSON
           union = false
         end
         valid = false
-        
+
         # Create an array to hold errors that are generated during union validation
         union_errors = []
-        
+
         types.each do |type|
           if type.is_a?(String)
             valid = data_valid_for_type?(data, type)
           elsif type.is_a?(Hash) && union
             # Validate as a schema
             schema = JSON::Schema.new(type,current_schema.uri,validator)
-            
+
             # We're going to add a little cruft here to try and maintain any validation errors that occur in this union type
             # We'll handle this by keeping an error count before and after validation, extracting those errors and pushing them onto a union error
             pre_validation_error_count = validation_errors(processor).count
-            
+
             begin
               schema.validate(data,fragments,processor,options)
               valid = true
             rescue ValidationError
               # We don't care that these schemas don't validate - we only care that one validated
             end
-            
+
             diff = validation_errors(processor).count - pre_validation_error_count
             valid = false if diff > 0
             while diff > 0
@@ -66,7 +65,7 @@ module JSON
             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])            
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end