json-schema 3.0.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab17ffc9133c3115ad9bb2f4b37338ee71d1994bf62849e7557b7e41a9d1d8e9
-  data.tar.gz: 3c44c431d8997fa255613bd6235fdd82b3c7c15ecc9e1077a1d41ff33b31c69b
+  metadata.gz: 6b6a5072f20570ae4262df13648a1b637b5db2c02cf881c2728277ea5a203f6d
+  data.tar.gz: 4b92633224b1338d58918e7a2d2f5d3e117fee03409455d6f47ea51c8bef7b18
 SHA512:
-  metadata.gz: 999689f22f02b64395c78b537ee86f6f0390e9cb2dc57e14293d310999bf11b5633b2fe16f1ca4c773bedb90e002452617f3df6926ff955deb84cca5446381ce
-  data.tar.gz: 71f12207a56541aab4ba1157d74e988295aff34e181daeb8937ed1e8bdc7a81025baaad536a0634da49527d63c71d341d433832cb56672b60f7fd920dcecda1a
+  metadata.gz: 9b5301a03a3fb7d3a43c275858df22d41cface2a465ff2fcfda28c9528f491e6a8f302fbbf52232de68e31d6a32540b9ad8a392fab82ec2b2113980e83119b72
+  data.tar.gz: 16f57a870e6b75280f5376d57785ad94500cbfd50bc3ea9ba01df486d0938c36907114780bacfc4860359e73d7adf87ce5c73205ef52ebea1f829b64d7630906

data/README.md

@@ -9,7 +9,8 @@
 
 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
+6](https://tools.ietf.org/html/draft-wright-json-schema-01). Legacy support for
+[JSON Schema Draft 4](http://tools.ietf.org/html/draft-zyp-json-schema-04),
 [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
@@ -240,6 +241,19 @@ JSON::Validator.validate(schema, { "a" => 1 }, :parse_data => false)
 # => false
 JSON::Validator.validate(schema, '{ "a": 1 }', :parse_data => false)
 
+#
+# with the `:parse_integer` option set to false, the integer value given as string will not be parsed.
+#
+
+# => true
+JSON::Validator.validate({type: "integer"}, "23")
+# => false
+JSON::Validator.validate({type: "integer"}, "23", parse_integer: false)
+# => true
+JSON::Validator.validate({type: "string"}, "123", parse_integer: false)
+# => false
+JSON::Validator.validate({type: "string"}, "123")
+
 #
 # with the `:json` option, the json must be an unparsed json text (not a hash, a uri or a file path)
 #

data/lib/json-schema/attribute.rb

@@ -3,8 +3,7 @@ require 'json-schema/errors/validation_error'
 module JSON
   class Schema
     class Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
-      end
+      def self.validate(current_schema, data, fragments, processor, validator, options = {}); end
 
       def self.build_fragment(fragments)
         "#/#{fragments.join('/')}"
@@ -24,14 +23,14 @@ module JSON
       end
 
       TYPE_CLASS_MAPPINGS = {
-        "string" => String,
-        "number" => Numeric,
-        "integer" => Integer,
-        "boolean" => [TrueClass, FalseClass],
-        "object" => Hash,
-        "array" => Array,
-        "null" => NilClass,
-        "any" => Object
+        '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)
@@ -41,11 +40,11 @@ module JSON
 
       # Lookup Schema type of given class instance
       def self.type_of_data(data)
-        type, _ = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |(_, v)|
+        type, = TYPE_CLASS_MAPPINGS.map { |k, v| [k, v] }.sort_by do |(_, v)|
           -Array(v).map { |klass| klass.ancestors.size }.max
-        }.find { |(_, v)|
-          Array(v).any? { |klass| data.kind_of?(klass) }
-        }
+        end.find do |(_, v)|
+          Array(v).any? { |klass| data.is_a?(klass) }
+        end
         type
       end
     end

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

@@ -19,6 +19,7 @@ module JSON
           additional_items_schema = JSON::Schema.new(schema['additionalItems'], current_schema.uri, validator)
           data.each_with_index do |item, i|
             next if i < schema['items'].length
+
             additional_items_schema.validate(item, fragments + [i.to_s], processor, options)
           end
         end

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

@@ -33,11 +33,9 @@ module JSON
           extra_properties = extra_properties - schema['properties'].keys
         end
 
-        if schema['patternProperties']
-          schema['patternProperties'].each_key do |key|
-            regexp = Regexp.new(key)
-            extra_properties.reject! { |prop| regexp.match(prop) }
-          end
+        schema['patternProperties']&.each_key do |key|
+          regexp = Regexp.new(key)
+          extra_properties.reject! { |prop| regexp.match(prop) }
         end
 
         if extended_schemas = schema['extends']
@@ -52,7 +50,6 @@ module JSON
 
         extra_properties
       end
-
     end
   end
 end

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

@@ -7,18 +7,20 @@ module JSON
         # Create an hash to hold errors that are generated during validation
         errors = Hash.new { |hsh, k| hsh[k] = [] }
         valid = true
+        message = nil
 
         current_schema.schema['allOf'].each_with_index do |element, schema_index|
-          schema = JSON::Schema.new(element,current_schema.uri,validator)
+          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
+            schema.validate(data, fragments, processor, options)
+          rescue ValidationError => e
             valid = false
+            message = e.message
           end
 
           diff = validation_errors(processor).count - pre_validation_error_count
@@ -29,7 +31,7 @@ module JSON
         end
 
         if !valid || !errors.empty?
-          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match all of the required schemas"
+          message ||= "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} 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

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

@@ -11,14 +11,14 @@ module JSON
         original_data = data.is_a?(Hash) ? data.clone : data
 
         current_schema.schema['anyOf'].each_with_index do |element, schema_index|
-          schema = JSON::Schema.new(element,current_schema.uri,validator)
+          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)
+            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

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

@@ -26,6 +26,7 @@ module JSON
 
       def self.validate_dependency(schema, data, property, value, fragments, processor, attribute, options)
         return if data.key?(value.to_s)
+
         message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
         validation_error(processor, message, fragments, schema, attribute, options[:record_errors])
       end

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

@@ -5,7 +5,8 @@ module JSON
     class DisallowAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         return unless type = validator.attributes['type']
-        type.validate(current_schema, data, fragments, processor, validator, options.merge(:disallow => true))
+
+        type.validate(current_schema, data, fragments, processor, validator, options.merge(disallow: true))
       end
     end
   end

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

@@ -7,14 +7,14 @@ module JSON
         enum = current_schema.schema['enum']
         return if enum.include?(data)
 
-        values = enum.map { |val|
+        values = enum.map do |val|
           case val
           when nil   then 'null'
           when Array then 'array'
           when Hash  then 'object'
           else val.to_s
           end
-        }.join(', ')
+        end.join(', ')
 
         message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match one of the following values: #{values}"
         validation_error(processor, message, fragments, current_schema, self, options[:record_errors])

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

@@ -8,7 +8,7 @@ module JSON
         schemas = current_schema.schema['extends']
         schemas = [schemas] if !schemas.is_a?(Array)
         schemas.each do |s|
-          uri,schema = get_extended_uri_and_schema(s, current_schema, validator)
+          uri, schema = get_extended_uri_and_schema(s, current_schema, validator)
           if schema
             schema.validate(data, fragments, processor, options)
           elsif uri
@@ -22,15 +22,15 @@ module JSON
       end
 
       def self.get_extended_uri_and_schema(s, current_schema, validator)
-        uri,schema = nil,nil
+        uri, schema = nil, nil
 
         if s.is_a?(Hash)
           uri = current_schema.uri
           if s['$ref']
-            ref_uri,ref_schema = JSON::Schema::RefAttribute.get_referenced_uri_and_schema(s, current_schema, validator)
+            ref_uri, ref_schema = JSON::Schema::RefAttribute.get_referenced_uri_and_schema(s, current_schema, validator)
             if ref_schema
               if s.size == 1 # Check if anything else apart from $ref
-                uri,schema = ref_uri,ref_schema
+                uri, schema = ref_uri, ref_schema
               else
                 s = s.dup
                 s.delete '$ref'
@@ -38,10 +38,10 @@ module JSON
               end
             end
           end
-          schema ||= JSON::Schema.new(s,uri,validator)
+          schema ||= JSON::Schema.new(s, uri, validator)
         end
 
-        [uri,schema]
+        [uri, schema]
       end
     end
   end

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

@@ -5,9 +5,10 @@ module JSON
     class FormatAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         return unless data_valid_for_type?(data, current_schema.schema['type'])
+
         format = current_schema.schema['format'].to_s
         validator = validator.formats[format]
-        validator.validate(current_schema, data, fragments, processor, validator, options) unless validator.nil?
+        validator&.validate(current_schema, data, fragments, processor, validator, options)
       end
     end
   end

data/lib/json-schema/attributes/formats/date.rb

@@ -13,6 +13,7 @@ module JSON
               Date.parse(data)
             rescue ArgumentError => e
               raise e unless e.message == 'invalid date'
+
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
             end
           else

data/lib/json-schema/attributes/formats/date_time.rb

@@ -10,12 +10,13 @@ module JSON
         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 or YYYY-MM-DDThh:mm:ss.ssZ"
           if (m = REGEXP.match(data))
-            parts = data.split("T")
+            parts = data.split('T')
 
             begin
               Date.parse(parts[0])
             rescue ArgumentError => e
               raise e unless e.message == 'invalid date'
+
               validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
               return
             end

data/lib/json-schema/attributes/formats/date_time_v4.rb

@@ -5,6 +5,7 @@ module JSON
     class DateTimeV4Format < FormatAttribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         return unless data.is_a?(String)
+
         DateTime.rfc3339(data)
       rescue ArgumentError
         error_message = "The property '#{build_fragment(fragments)}' must be a valid RFC3339 date/time string"

data/lib/json-schema/attributes/formats/uri.rb

@@ -6,6 +6,7 @@ module JSON
     class UriFormat < FormatAttribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         return unless data.is_a?(String)
+
         error_message = "The property '#{build_fragment(fragments)}' must be a valid URI"
         begin
           JSON::Util::URI.parse(data)

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

@@ -17,6 +17,7 @@ module JSON
         when Array
           items.each_with_index do |item_schema, i|
             break if i >= data.length
+
             schema = JSON::Schema.new(item_schema, current_schema.uri, validator)
             schema.validate(data[i], fragments + [i.to_s], processor, options)
           end

data/lib/json-schema/attributes/limits/numeric.rb

@@ -9,7 +9,7 @@ module JSON
 
       def self.error_message(schema)
         exclusivity = exclusive?(schema) ? 'exclusively' : 'inclusively'
-        format("did not have a %s value of %s, %s", limit_name, limit(schema), exclusivity)
+        format('did not have a %s value of %s, %s', limit_name, limit(schema), exclusivity)
       end
     end
   end

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

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

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

@@ -4,12 +4,12 @@ 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)
+        schema = JSON::Schema.new(current_schema.schema['not'], current_schema.uri, validator)
         failed = true
         errors_copy = processor.validation_errors.clone
 
         begin
-          schema.validate(data,fragments,processor,options)
+          schema.validate(data, fragments, processor, options)
           # If we're recording errors, we don't throw an exception. Instead, check the errors array length
           if options[:record_errors] && errors_copy.length != processor.validation_errors.length
             processor.validation_errors.replace(errors_copy)

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

@@ -15,10 +15,10 @@ module JSON
         valid = false
 
         one_of.each_with_index do |element, schema_index|
-          schema = JSON::Schema.new(element,current_schema.uri,validator)
+          schema = JSON::Schema.new(element, current_schema.uri, validator)
           pre_validation_error_count = validation_errors(processor).count
           begin
-            schema.validate(data,fragments,processor,options)
+            schema.validate(data, fragments, processor, options)
             success_data = data.is_a?(Hash) ? data.clone : data
             valid = true
           rescue ValidationError
@@ -35,8 +35,6 @@ module JSON
           data = original_data
         end
 
-
-
         if validation_error_count == one_of.length - 1
           data = success_data
           return

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

@@ -12,6 +12,7 @@ module JSON
           # Check each key in the data hash to see if it matches the regex
           data.each do |key, value|
             next unless regexp.match(key)
+
             schema = JSON::Schema.new(property_schema, current_schema.uri, validator)
             schema.validate(data[key], fragments + [key], processor, options)
           end

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

@@ -4,7 +4,7 @@ module JSON
   class Schema
     class PropertiesAttribute < Attribute
       def self.required?(schema, options)
-        schema.fetch('required') { options[:strict] }
+        schema.fetch('required') { options[:allPropertiesRequired] }
       end
 
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
@@ -15,9 +15,9 @@ module JSON
           property = property.to_s
 
           if !data.key?(property) &&
-              options[:insert_defaults] &&
-              property_schema.has_key?('default') &&
-              !property_schema['readonly']
+             options[:insert_defaults] &&
+             property_schema.has_key?('default') &&
+             !property_schema['readonly']
             default = property_schema['default']
             data[property] = default.is_a?(Hash) ? default.clone : default
           end
@@ -33,8 +33,8 @@ module JSON
           end
         end
 
-        # When strict is true, ensure no undefined properties exist in the data
-        return unless options[:strict] == true && !schema.key?('additionalProperties')
+        # When noAdditionalProperties is true, ensure no undefined properties exist in the data
+        return unless options[:noAdditionalProperties] == true && !schema.key?('additionalProperties')
 
         diff = data.select do |k, v|
           k = k.to_s
@@ -55,7 +55,7 @@ module JSON
           end
         end
 
-        if diff.size > 0
+        unless diff.empty?
           properties = diff.keys.join(', ')
           message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{properties}'"
           validation_error(processor, message, fragments, current_schema, self, options[:record_errors])

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

@@ -6,7 +6,7 @@ module JSON
       # draft4 relies on its own RequiredAttribute validation at a higher level, rather than
       # as an attribute of individual properties.
       def self.required?(schema, options)
-        options[:strict] == true
+        options[:allPropertiesRequired] == true
       end
     end
   end

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

@@ -0,0 +1,23 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class PropertyNames < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Hash)
+
+        propnames = current_schema.schema['propertyNames']
+
+        if propnames.is_a?(Hash)
+          schema = JSON::Schema.new(propnames, current_schema.uri, validator)
+          data.each_key do |key|
+            schema.validate(key, fragments + [key], processor, options)
+          end
+        elsif propnames == false && data.any?
+          message = "The property '#{build_fragment(fragments)}' contains additional properties #{data.keys.inspect} outside of the schema when none are allowed"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module JSON
   class Schema
     class RefAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        uri,schema = get_referenced_uri_and_schema(current_schema.schema, current_schema, validator)
+        uri, schema = get_referenced_uri_and_schema(current_schema.schema, current_schema, validator)
 
         if schema
           schema.validate(data, fragments, processor, options)
@@ -20,19 +20,19 @@ module JSON
       end
 
       def self.get_referenced_uri_and_schema(s, current_schema, validator)
-        uri,schema = nil,nil
+        uri, schema = nil, nil
 
         temp_uri = JSON::Util::URI.normalize_ref(s['$ref'], current_schema.uri)
 
         # Grab the parent schema from the schema list
-        schema_key = temp_uri.to_s.split("#")[0] + "#"
+        schema_key = temp_uri.to_s.split('#')[0] + '#'
 
         ref_schema = JSON::Validator.schema_for_uri(schema_key)
 
         if ref_schema
           # Perform fragment resolution to retrieve the appropriate level for the schema
           target_schema = ref_schema.schema
-          fragments = JSON::Util::URI.parse(JSON::Util::URI.unescape_uri(temp_uri)).fragment.split("/")
+          fragments = JSON::Util::URI.parse(JSON::Util::URI.unescape_uri(temp_uri)).fragment.split('/')
           fragment_path = ''
           fragments.each do |fragment|
             if fragment && fragment != ''
@@ -44,17 +44,17 @@ module JSON
               end
               fragment_path = fragment_path + "/#{fragment}"
               if target_schema.nil?
-                raise SchemaError.new("The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri.to_s}")
+                raise SchemaError, "The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri.to_s}"
               end
             end
           end
 
           # We have the schema finally, build it and validate!
           uri = temp_uri
-          schema = JSON::Schema.new(target_schema,temp_uri,validator)
+          schema = JSON::Schema.new(target_schema, temp_uri, validator)
         end
 
-        [uri,schema]
+        [uri, schema]
       end
     end
   end

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

@@ -11,11 +11,12 @@ module JSON
 
         schema['required'].each do |property, property_schema|
           next if data.has_key?(property.to_s)
+
           prop_defaults = options[:insert_defaults] &&
                           defined_properties &&
                           defined_properties[property] &&
-                          !defined_properties[property]["default"].nil? &&
-                          !defined_properties[property]["readonly"]
+                          !defined_properties[property]['default'].nil? &&
+                          !defined_properties[property]['readonly']
 
           if !prop_defaults
             message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"

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

@@ -25,14 +25,14 @@ module JSON
             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)
+            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.merge(:disallow => false))
+              schema.validate(data, fragments, processor, options.merge(disallow: false))
               valid = true
             rescue ValidationError
               # We don't care that these schemas don't validate - we only care that one validated
@@ -51,6 +51,7 @@ module JSON
 
         if options[:disallow]
           return if !valid
+
           message = "The property '#{build_fragment(fragments)}' matched one or more of the following types: #{list_types(types)}"
           validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         elsif !valid

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

@@ -19,7 +19,7 @@ module JSON
           build_fragment(fragments),
           type_of_data(data),
           union ? 'one or more of the following types' : 'the following type',
-          types
+          types,
         )
 
         validation_error(processor, message, fragments, current_schema, self, options[:record_errors])

data/lib/json-schema/errors/validation_error.rb

@@ -1,7 +1,7 @@
 module JSON
   class Schema
     class ValidationError < StandardError
-      INDENT = "    "
+      INDENT = '    '
       attr_accessor :fragments, :schema, :failed_attribute, :sub_errors, :message
 
       def initialize(message, fragments, failed_attribute, schema)
@@ -27,12 +27,11 @@ module JSON
       end
 
       def to_hash
-        base = {:schema => @schema.uri, :fragment => ::JSON::Schema::Attribute.build_fragment(fragments), :message => message_with_schema, :failed_attribute => @failed_attribute.to_s.split(":").last.split("Attribute").first}
+        base = { schema: @schema.uri, fragment: ::JSON::Schema::Attribute.build_fragment(fragments), message: message_with_schema, failed_attribute: @failed_attribute.to_s.split(':').last.split('Attribute').first }
         if !@sub_errors.empty?
-          base[:errors] = @sub_errors.inject({}) do |hsh, (subschema, errors)|
+          base[:errors] = @sub_errors.each_with_object({}) do |(subschema, errors), hsh|
             subschema_sym = subschema.downcase.gsub(/\W+/, '_').to_sym
-            hsh[subschema_sym] = Array(errors).map{|e| e.to_hash}
-            hsh
+            hsh[subschema_sym] = Array(errors).map { |e| e.to_hash }
           end
         end
         base

data/lib/json-schema/schema/reader.rb

@@ -28,6 +28,7 @@ module JSON
     # a schema should not be read.
     class ReadRefused < ReadError
       private
+
       def error_message
         "Read of #{type_string} at #{location} refused"
       end
@@ -36,6 +37,7 @@ module JSON
     # Raised by {JSON::Schema::Reader} when an attempt to read a schema fails
     class ReadFailed < ReadError
       private
+
       def error_message
         "Read of #{type_string} at #{location} failed"
       end

data/lib/json-schema/schema/validator.rb

@@ -4,7 +4,7 @@ module JSON
       attr_accessor :attributes, :formats, :uri, :names
       attr_reader :default_formats
 
-      def initialize()
+      def initialize
         @attributes = {}
         @formats = {}
         @default_formats = {}
@@ -14,13 +14,13 @@ module JSON
       end
 
       def extend_schema_definition(schema_uri)
-        warn "[DEPRECATION NOTICE] The preferred way to extend a Validator is by subclassing, rather than #extend_schema_definition. This method will be removed in version >= 3."
+        warn '[DEPRECATION NOTICE] The preferred way to extend a Validator is by subclassing, rather than #extend_schema_definition. This method will be removed in version >= 3.'
         validator = JSON::Validator.validator_for_uri(schema_uri)
         @attributes.merge!(validator.attributes)
       end
 
       def validate(current_schema, data, fragments, processor, options = {})
-        current_schema.schema.each do |attr_name,attribute|
+        current_schema.schema.each do |attr_name, attribute|
           if @attributes.has_key?(attr_name.to_s)
             @attributes[attr_name.to_s].validate(current_schema, data, fragments, processor, self, options)
           end