json-schema 2.8.1 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3361b9ea49eb9e208babcec94973eb5efd0d371c2a2cbab16cca9e6555b11b77
-  data.tar.gz: 82f4c4d50b75db5d379555c76ca2606580c14d74a0ec5088504cfb5f5025e1ed
+  metadata.gz: 6b6a5072f20570ae4262df13648a1b637b5db2c02cf881c2728277ea5a203f6d
+  data.tar.gz: 4b92633224b1338d58918e7a2d2f5d3e117fee03409455d6f47ea51c8bef7b18
 SHA512:
-  metadata.gz: 5040893a974d35c4e9833076d8db0073215fdc6330535a4ae7c7d3eef3bdfd902e3642ed5bd9729735b65d8821e30db2b563411d4fd6cf0187c6efe2a4179669
-  data.tar.gz: 9161d768e8829faafefeabf7723c462019831393d4c696ccbc9b7f7be9f5affcc988cf93a2ce1709ea1b6cddd70230fa44815cd4a3e965b7c15ea65b2b0c3de2
+  metadata.gz: 9b5301a03a3fb7d3a43c275858df22d41cface2a465ff2fcfda28c9528f491e6a8f302fbbf52232de68e31d6a32540b9ad8a392fab82ec2b2113980e83119b72
+  data.tar.gz: 16f57a870e6b75280f5376d57785ad94500cbfd50bc3ea9ba01df486d0938c36907114780bacfc4860359e73d7adf87ce5c73205ef52ebea1f829b64d7630906

data/README.md

@@ -1,13 +1,16 @@
-[![Gem Version](https://badge.fury.io/rb/json-schema.svg)](https://badge.fury.io/rb/json-schema)
-[![Travis](https://travis-ci.org/ruby-json-schema/json-schema.svg?branch=master)](https://travis-ci.org/ruby-json-schema/json-schema)
-[![Code Climate](https://codeclimate.com/github/ruby-json-schema/json-schema/badges/gpa.svg)](https://codeclimate.com/github/ruby-json-schema/json-schema)
+# Ruby JSON Schema Validator
 
-Ruby JSON Schema Validator
-==========================
+[![License](https://img.shields.io/github/license/voxpupuli/json-schema.svg)](https://github.com/voxpupuli/json-schema/blob/master/LICENSE)
+[![Test](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/test.yml)
+[![Release](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml/badge.svg)](https://github.com/voxpupuli/json-schema/actions/workflows/release.yml)
+[![RubyGem Version](https://img.shields.io/gem/v/json-schema.svg)](https://rubygems.org/gems/json-schema)
+[![RubyGem Downloads](https://img.shields.io/gem/dt/json-schema.svg)](https://rubygems.org/gems/json-schema)
+[![Donated by Iain Beeston](https://img.shields.io/badge/donated%20by-Iain%20Beeston-fb7047.svg)](#transfer-notice)
 
 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
@@ -17,7 +20,7 @@ Additional Resources
 --------------------
 
 - [Google Groups](https://groups.google.com/forum/#!forum/ruby-json-schema)
-- #ruby-json-schema on chat.freenode.net
+- #voxpupuli on irc.libera.chat
 
 Version 2.0.0 Upgrade Notes
 ---------------------------
@@ -27,6 +30,14 @@ 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.
 
+Version 3.0.0 Upgrade Notes
+---------------------------
+
+All individual changes are documented in the CHANGELOG.md. The biggest change
+is that the new version only supports Ruby 2.5 and newer. Take a look into the
+gemspec file to see the currently supported Ruby version and also
+`.github/workflows/test.yml` to see the Ruby versions we test on.
+
 Installation
 ------------
 
@@ -39,8 +50,8 @@ gem install json-schema
 From the git repo:
 
 ```sh
-$ gem build json-schema.gemspec
-$ gem install json-schema-2.5.2.gem
+gem build json-schema.gemspec
+gem install json-schema-*.gem
 ```
 
 Validation
@@ -166,7 +177,7 @@ JSON::Validator.validate(schema, [{"a" => 1}, {"a" => 2}, {"a" => 3}])
 JSON::Validator.fully_validate(schema, { "a" => "taco" }, :errors_as_objects => true)
 
 #
-# with the `:strict` option, all properties are condisidered to have `"required": true` and all objects `"additionalProperties": false`
+# with the `:strict` option, all properties are considered to have `"required": true` and all objects `"additionalProperties": false`
 #
 
 # => true
@@ -230,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)
 #
@@ -472,3 +496,23 @@ value is of the correct datatype (e.g., an instance value is validated to be an
 integer or a float in the case of 'utc-millisec').
 
 Additionally, JSON::Validator does not handle any json hyperschema attributes.
+
+# Transfer Notice
+
+This plugin was originally authored by [Iain Beeston](https://github.com/iainbeeston).
+The maintainer preferred that [Vox Pupuli](https://voxpupuli.org/) take ownership of the module for future improvement and maintenance.
+Existing pull requests and issues were transferred, please fork and continue to contribute [here](https://github.com/voxpupuli/json-schema).
+
+# License
+
+This gem is licensed unter the [MIT license](LICENSE.md).
+
+## Release information
+
+To make a new release, please do:
+* update the version in VERSION.yml
+* Install gems with `bundle install --with release --path .vendor`
+* generate the changelog with `bundle exec rake changelog`
+* Check if the new version matches the closed issues/PRs in the changelog
+* Create a PR with it
+* After it got merged, push a tag. GitHub actions will do the actual release to rubygems and GitHub Packages

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/const.rb

@@ -0,0 +1,15 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class ConstAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        const_value = current_schema.schema['const']
+        unless const_value == data
+          message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match constant '#{const_value}'"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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/ip.rb

@@ -11,7 +11,7 @@ module JSON
         begin
           ip = IPAddr.new(data)
         rescue ArgumentError => e
-          raise e unless e.message == 'invalid address'
+          raise e unless e.message.start_with?('invalid address')
         end
 
         family = ip_version == 6 ? Socket::AF_INET6 : Socket::AF_INET

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}'"