json-schema 1.0.3 → 1.0.4

data/README.textile

@@ -18,7 +18,7 @@ From the git repo:
 
 <pre>
 $ gem build json-schema.gemspec
-$ gem install json-schema-1.0.3.gem
+$ gem install json-schema-1.0.4.gem
 </pre>
 
 

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

@@ -5,7 +5,7 @@ module JSON
         if data.is_a?(Array) && current_schema.schema['items'].is_a?(Array)
           if current_schema.schema['additionalItems'] == false && current_schema.schema['items'].length != data.length
             message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           elsif current_schema.schema['additionalItems'].is_a?(Hash)
             schema = JSON::Schema.new(current_schema.schema['additionalItems'],current_schema.uri,validator)
             data.each_with_index do |item,i|

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

@@ -23,7 +23,7 @@ module JSON
 
           if current_schema.schema['additionalProperties'] == false && !extra_properties.empty?
             message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           elsif current_schema.schema['additionalProperties'].is_a?(Hash)
             extra_properties.each do |key|
               schema = JSON::Schema.new(current_schema.schema['additionalProperties'],current_schema.uri,validator)

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

@@ -8,13 +8,13 @@ module JSON
               if dependency_value.is_a?(String)
                 if !data.has_key?(dependency_value)
                   message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
-                  validation_error(message, fragments, current_schema, options[:record_errors])
+                  validation_error(message, fragments, current_schema, self, options[:record_errors])
                 end
               elsif 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(message, fragments, current_schema, options[:record_errors])
+                    validation_error(message, fragments, current_schema, self, options[:record_errors])
                   end
                 end
               else

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

@@ -7,7 +7,7 @@ module JSON
              current_schema.schema['divisibleBy'] == 0.0 ||
              (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['divisibleBy'].to_s)).to_f != 0
              message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['divisibleBy']}"
-             validation_error(message, fragments, current_schema, options[:record_errors])
+             validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -16,7 +16,7 @@ module JSON
             end
           }
           message.chop!
-          validation_error(message, fragments, current_schema, options[:record_errors])
+          validation_error(message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -8,26 +8,26 @@ module JSON
         when 'date-time'
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a date/time in the ISO-8601 format of YYYY-MM-DDThh:mm:ssZ"
-            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
             r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)Z$')
             if (m = r.match(data))
               parts = data.split("T")
               begin
                 Date.parse(parts[0])
               rescue Exception
-                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
               begin
-                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[1].to_i > 23
-                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[2].to_i > 59
-                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[3].to_i > 59
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
               rescue Exception
-                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
             else
-              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -36,17 +36,17 @@ module JSON
         when 'date'
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
-            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
             r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
             if (m = r.match(data))
               begin
                 Date.parse(data)
               rescue Exception
-                validation_error(error_message, fragments, current_schema, options[:record_errors])
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors])
                 return
               end
             else
-              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -55,14 +55,14 @@ module JSON
         when 'time'
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
-            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
             r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
             if (m = r.match(data))
-              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[1].to_i > 23
-              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[2].to_i > 59
-              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[3].to_i > 59
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
             else
-              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -71,14 +71,14 @@ module JSON
         when 'ip-address', 'ipv4'
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv4 address"
-            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
             r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
             if (m = r.match(data))
               1.upto(4) do |x|
-                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if m[x].to_i > 255
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if m[x].to_i > 255
               end
             else
-              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end
@@ -87,22 +87,22 @@ module JSON
         when 'ipv6'
           if data.is_a?(String)
             error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv6 address"
-            validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if !data.is_a?(String)
+            validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if !data.is_a?(String)
             r = Regexp.new('^[a-f0-9:]+$')
             if (m = r.match(data))
               # All characters are valid, now validate structure
               parts = data.split(":")
-              validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if parts.length > 8
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if parts.length > 8
               condensed_zeros = false
               parts.each do |part|
                 if part.length == 0
-                  validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if condensed_zeros
+                  validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if condensed_zeros
                   condensed_zeros = true
                 end
-                validation_error(error_message, fragments, current_schema, options[:record_errors]) and return if part.length > 4
+                validation_error(error_message, fragments, current_schema, self, options[:record_errors]) and return if part.length > 4
               end
             else
-              validation_error(error_message, fragments, current_schema, options[:record_errors])
+              validation_error(error_message, fragments, current_schema, self, options[:record_errors])
               return
             end
           end

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

@@ -6,7 +6,7 @@ module JSON
           s = data.to_s.split(".")[1]
           if s && s.length > current_schema.schema['maxDecimal']
             message = "The property '#{build_fragment(fragments)}' had more decimal places than the allowed #{current_schema.schema['maxDecimal']}"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           if (current_schema.schema['exclusiveMaximum'] ? data >= current_schema.schema['maximum'] : data > current_schema.schema['maximum'])
             message = "The property '#{build_fragment(fragments)}' did not have a maximum value of #{current_schema.schema['maximum']}, "
             message += current_schema.schema['exclusiveMaximum'] ? 'exclusively' : 'inclusively'
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           if (current_schema.schema['maximumCanEqual'] == false ? data >= current_schema.schema['maximum'] : data > current_schema.schema['maximum'])
             message = "The property '#{build_fragment(fragments)}' did not have a maximum value of #{current_schema.schema['maximum']}, "
             message += current_schema.schema['exclusiveMaximum'] ? 'exclusively' : 'inclusively'
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -4,7 +4,7 @@ module JSON
       def self.validate(current_schema, data, fragments, validator, options = {})
         if data.is_a?(Array) && (data.compact.size > current_schema.schema['maxItems'])
           message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
-          validation_error(message, fragments, current_schema, options[:record_errors])
+          validation_error(message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -5,7 +5,7 @@ module JSON
         if data.is_a?(String)
           if data.length > current_schema.schema['maxLength']
             message = "The property '#{build_fragment(fragments)}' was not of a maximum string length of #{current_schema.schema['maxLength']}"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           if (current_schema.schema['exclusiveMinimum'] ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
             message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
             message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           if (current_schema.schema['minimumCanEqual'] == false ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
             message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
             message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -4,7 +4,7 @@ module JSON
       def self.validate(current_schema, data, fragments, validator, options = {})
         if data.is_a?(Array) && (data.compact.size < current_schema.schema['minItems'])
           message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
-          validation_error(message, fragments, current_schema, options[:record_errors])
+          validation_error(message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -5,7 +5,7 @@ module JSON
         if data.is_a?(String)
           if data.length < current_schema.schema['minLength']
             message = "The property '#{build_fragment(fragments)}' was not of a minimum string length of #{current_schema.schema['minLength']}"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           r = Regexp.new(current_schema.schema['pattern'])
           if (r.match(data)).nil?
             message = "The property '#{build_fragment(fragments)}' did not match the regex '#{current_schema.schema['pattern']}'"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

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

@@ -6,7 +6,7 @@ module JSON
           current_schema.schema['properties'].each do |property,property_schema|
             if (property_schema['required'] && !data.has_key?(property))
               message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-              validation_error(message, fragments, current_schema, options[:record_errors])
+              validation_error(message, fragments, current_schema, self, options[:record_errors])
             end
           
             if data.has_key?(property)

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

@@ -6,7 +6,7 @@ module JSON
           current_schema.schema['properties'].each do |property,property_schema|
             if ((property_schema['optional'].nil? || property_schema['optional'] == false) && !data.has_key?(property))
               message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
-              validation_error(message, fragments, current_schema, options[:record_errors])
+              validation_error(message, fragments, current_schema, self, options[:record_errors])
             end
           
             if data.has_key?(property)

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

@@ -47,7 +47,7 @@ module JSON
           schema.validate(data, fragments, options)
         else
           message = "The referenced schema '#{temp_uri.to_s}' cannot be found"
-          validation_error(message, fragments, current_schema, options[:record_errors])
+          validation_error(message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -15,7 +15,10 @@ 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)
             case type
@@ -41,12 +44,24 @@ module JSON
           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.count
+            
             begin
               schema.validate(data,fragments,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.count - pre_validation_error_count
+            valid = false if diff > 0
+            while diff > 0
+              diff = diff - 1
+              union_errors.push(validation_errors.pop)
+            end
           end
 
           break if valid
@@ -57,13 +72,21 @@ module JSON
             message = "The property '#{build_fragment(fragments)}' matched one or more of the following types:"
             types.each {|type| message += type.is_a?(String) ? " #{type}," : " (schema)," }
             message.chop!
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         elsif !valid
-          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(message, fragments, current_schema, options[:record_errors])
+          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(message, fragments, current_schema, self, options[:record_errors])
+            validation_errors.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(message, fragments, current_schema, self, options[:record_errors])            
+          end
         end
       end
     end

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

@@ -7,7 +7,7 @@ module JSON
           dupes = d.uniq!
           if dupes
             message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
-            validation_error(message, fragments, current_schema, options[:record_errors])
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
           end
         end
       end

data/lib/json-schema/schema.rb

@@ -44,7 +44,9 @@ module JSON
       parts.join('/') + '/'
     end
 
-    
+    def to_s
+      @schema.to_json
+    end
   end
 end
 

data/lib/json-schema/validator.rb

@@ -9,14 +9,34 @@ module JSON
 
   class Schema
     class ValidationError < StandardError
-      attr_reader :fragments, :schema
+      attr_accessor :fragments, :schema, :failed_attribute, :sub_errors
 
-      def initialize(message, fragments, schema)
-        @fragments = fragments
+      def initialize(message, fragments, failed_attribute, schema)
+        @fragments = fragments.clone
         @schema = schema
+        @sub_errors = []
+        @failed_attribute = failed_attribute
         message = "#{message} in schema #{schema.uri}"
         super(message)
       end
+      
+      def to_string
+        if @sub_errors.empty?
+          message
+        else
+          full_message = message + "\n The schema specific errors were:\n"
+          @sub_errors.each{|e| full_message = full_message + " - " + e.to_string + "\n"}
+          full_message
+        end
+      end
+      
+      def to_hash
+        base = {:schema => @schema.uri, :fragment => ::JSON::Schema::Attribute.build_fragment(fragments), :message => message, :failed_attribute => @failed_attribute.to_s.split(":").last.split("Attribute").first}
+        if !@sub_errors.empty?
+          base[:errors] = @sub_errors.map{|e| e.to_hash}
+        end
+        base
+      end
     end
 
     class SchemaError < StandardError
@@ -33,14 +53,18 @@ module JSON
         "#/#{fragments.join('/')}"
       end
 
-      def self.validation_error(message, fragments, current_schema, record_errors)
-        error = ValidationError.new(message, fragments, current_schema)
+      def self.validation_error(message, fragments, current_schema, failed_attribute, record_errors)
+        error = ValidationError.new(message, fragments, failed_attribute, current_schema)
         if record_errors
-          ::JSON::Validator.validation_error(error.message)
+          ::JSON::Validator.validation_error(error)
         else
           raise error
         end
       end
+      
+      def self.validation_errors
+        ::JSON::Validator.validation_errors
+      end
     end
 
     class Validator
@@ -84,7 +108,8 @@ module JSON
       :list => false,
       :version => nil,
       :validate_schema => false,
-      :record_errors => false
+      :record_errors => false,
+      :errors_as_objects => false
     }
     @@validators = {}
     @@default_validator = nil
@@ -148,7 +173,11 @@ module JSON
         Validator.clear_errors
         @base_schema.validate(@data,[],@validation_options)
         Validator.clear_cache
-        @@errors
+        if @options[:errors_as_objects]
+          @@errors.map{|e| e.to_hash}
+        else
+          @@errors.map{|e| e.to_string}
+        end
       rescue JSON::Schema::ValidationError
         Validator.clear_cache
         raise $!
@@ -294,6 +323,10 @@ module JSON
       def validation_error(error)
         @@errors.push(error)
       end
+      
+      def validation_errors
+        @@errors
+      end
 
       def schemas
         @@schemas

data/test/test_extended_schema.rb

@@ -5,7 +5,7 @@ class BitwiseAndAttribute < JSON::Schema::Attribute
   def self.validate(current_schema, data, fragments, validator, options = {})
     if data.is_a?(Integer) && data & current_schema.schema['bitwise-and'].to_i == 0
       message = "The property '#{build_fragment(fragments)}' did not evaluate  to true when bitwise-AND'd with  #{current_schema.schema['bitwise-or']}"
-      raise JSON::Schema::ValidationError.new(message, fragments, current_schema)
+      raise JSON::Schema::ValidationError.new(message, fragments, self, current_schema)
     end
   end
 end

data/test/test_files.rb

@@ -8,36 +8,28 @@ class JSONSchemaTest < Test::Unit::TestCase
   #
   
   def test_schema_from_file
-    if JSON::Validator.json_backend != nil
-      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
+    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
-    if JSON::Validator.json_backend != nil
-      schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
-      assert(JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-      assert(!JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
-    end
+    schema = {"type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+    assert(JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
+    assert(!JSON::Validator.validate(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
   end
   
   def test_both_from_file
-    if JSON::Validator.json_backend != nil
-      assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-      assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
-    end
+    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
+    assert(!JSON::Validator.validate(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
-    if JSON::Validator.json_backend != nil
-      data = {"b" => {"a" => 5}}
-      assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_2.json"),data))
-  
-      data = {"b" => {"a" => "boo"}}
-      assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
-    end
+    data = {"b" => {"a" => 5}}
+    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_2.json"),data))
+
+    data = {"b" => {"a" => "boo"}}
+    assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
   end
 end

data/test/test_full_validation.rb

@@ -35,4 +35,114 @@ class JSONFullValidation < Test::Unit::TestCase
     errors = JSON::Validator.fully_validate(schema,data)
     assert(errors.length == 2)
   end
+  
+  def test_full_validation_with_union_types
+    data = {"b" => 5}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => ["null","integer"]
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => ["integer","null"]
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => "a string"}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.length == 1)
+   
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => [
+            {
+              "type" => "object",
+              "properties" => {
+                "c" => {"type" => "string"}
+              }
+            },
+            {
+              "type" => "object",
+              "properties" => {
+                "d" => {"type" => "integer"}
+              }
+            }
+          ]
+        }
+      }
+    }
+    
+    data = {"b" => {"c" => "taco"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => {"d" => 6}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => {"c" => 6, "d" => "OH GOD"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.length == 1)
+  end
+  
+  
+  def test_full_validation_with_object_errors
+    data = {"b" => {"a" => 5}}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert(errors.empty?)
+
+    data = {"c" => 5}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        },
+        "c" => {
+          "type" => "string"
+        }
+      }
+    }
+
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert(errors.length == 2)
+    assert(errors[0][:failed_attribute] == "Properties")
+    assert(errors[0][:fragment] == "#/")
+    assert(errors[1][:failed_attribute] == "Type")
+    assert(errors[1][:fragment] == "#/c")
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 3
-  version: 1.0.3
+  - 4
+  version: 1.0.4
 platform: ruby
 authors: 
 - Kenny Hoxworth