json-schema 2.8.1 → 6.1.0

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
@@ -27,26 +27,24 @@ module JSON
 
           diff = validation_errors(processor).count - pre_validation_error_count
           valid = false if diff > 0
-          validation_error_count += 1 if !valid
+          validation_error_count += 1 unless valid
           while diff > 0
-            diff = diff - 1
+            diff -= 1
             errors["oneOf ##{schema_index}"].push(validation_errors(processor).pop)
           end
           data = original_data
         end
 
-
-
         if validation_error_count == one_of.length - 1
           data = success_data
           return
         end
 
-        if validation_error_count == one_of.length
-          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match any of the required schemas"
-        else
-          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} matched more than one of the required schemas"
-        end
+        message = if validation_error_count == one_of.length
+                    "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match any of the required schemas"
+                  else
+                    "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} matched more than one of the required schemas"
+                  end
 
         validation_error(processor, message, fragments, current_schema, self, options[:record_errors]) if message
         validation_errors(processor).last.sub_errors = errors if message

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

@@ -3,7 +3,7 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class PatternAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         return unless data.is_a?(String)
 
         pattern = current_schema.schema['pattern']

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

@@ -10,8 +10,9 @@ module JSON
           regexp = Regexp.new(property)
 
           # Check each key in the data hash to see if it matches the regex
-          data.each do |key, value|
+          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,15 +33,15 @@ 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|
+        diff = data.select do |k, _v|
           k = k.to_s
 
           if schema.has_key?('patternProperties')
             match = false
-            schema['patternProperties'].each do |property, property_schema|
+            schema['patternProperties'].each do |property, _property_schema|
               regexp = Regexp.new(property)
               if regexp.match(k)
                 match = true
@@ -55,10 +55,10 @@ 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])
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], diff.keys)
         end
       end
     end

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

@@ -5,8 +5,8 @@ module JSON
     class PropertiesV4Attribute < PropertiesAttribute
       # 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
+      def self.required?(_schema, options)
+        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,12 +6,12 @@ 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)
         elsif uri
-          message = "The referenced schema '#{uri.to_s}' cannot be found"
+          message = "The referenced schema '#{uri}' cannot be found"
           validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         else
           message = "The property '#{build_fragment(fragments)}' was not a valid schema"
@@ -20,41 +20,42 @@ module JSON
       end
 
       def self.get_referenced_uri_and_schema(s, current_schema, validator)
-        uri,schema = nil,nil
+        uri = nil
+        schema = 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 != ''
-              fragment = fragment.gsub('~0', '~').gsub('~1', '/')
-              if target_schema.is_a?(Array)
-                target_schema = target_schema[fragment.to_i]
-              else
-                target_schema = target_schema[fragment]
-              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}")
-              end
+            next unless fragment && fragment != ''
+
+            fragment = fragment.gsub('~0', '~').gsub('~1', '/')
+            target_schema = if target_schema.is_a?(Array)
+                              target_schema[fragment.to_i]
+                            else
+                              target_schema[fragment]
+                            end
+            fragment_path += "/#{fragment}"
+            if target_schema.nil?
+              raise SchemaError, "The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri}"
             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

@@ -3,21 +3,22 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class RequiredAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         return unless data.is_a?(Hash)
 
         schema = current_schema.schema
         defined_properties = schema['properties']
 
-        schema['required'].each do |property, property_schema|
+        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
+          unless 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

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

@@ -5,13 +5,13 @@ 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
-          types = current_schema.schema['type']
-        end
+        types = if options[:disallow]
+                  current_schema.schema['disallow']
+                else
+                  current_schema.schema['type']
+                end
 
-        if !types.is_a?(Array)
+        unless types.is_a?(Array)
           types = [types]
           union = false
         end
@@ -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
@@ -41,7 +41,7 @@ module JSON
             diff = validation_errors(processor).count - pre_validation_error_count
             valid = false if diff > 0
             while diff > 0
-              diff = diff - 1
+              diff -= 1
               union_errors["type ##{type_index}"].push(validation_errors(processor).pop)
             end
           end
@@ -50,7 +50,8 @@ module JSON
         end
 
         if options[:disallow]
-          return if !valid
+          return unless 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

@@ -3,10 +3,10 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class TypeV4Attribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         union = true
         types = current_schema.schema['type']
-        if !types.is_a?(Array)
+        unless types.is_a?(Array)
           types = [types]
           union = false
         end
@@ -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/attributes/uniqueitems.rb

@@ -3,7 +3,7 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class UniqueItemsAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         return unless data.is_a?(Array)
 
         if data.clone.uniq!

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

@@ -1,38 +1,38 @@
 module JSON
   class Schema
     class ValidationError < StandardError
-      INDENT = "    "
-      attr_accessor :fragments, :schema, :failed_attribute, :sub_errors, :message
+      INDENT = '    '
+      attr_accessor :fragments, :schema, :failed_attribute, :sub_errors, :message, :properties
 
-      def initialize(message, fragments, failed_attribute, schema)
+      def initialize(message, fragments, failed_attribute, schema, properties = [])
         @fragments = fragments.clone
         @schema = schema
         @sub_errors = {}
         @failed_attribute = failed_attribute
         @message = message
+        @properties = properties
         super(message_with_schema)
       end
 
       def to_string(subschema_level = 0)
         if @sub_errors.empty?
-          subschema_level == 0 ? message_with_schema : message
+          (subschema_level == 0) ? message_with_schema : message
         else
           messages = ["#{message}. The schema specific errors were:\n"]
           @sub_errors.each do |subschema, errors|
             messages.push "- #{subschema}:"
-            messages.concat Array(errors).map { |e| "#{INDENT}- #{e.to_string(subschema_level + 1)}" }
+            messages.concat(Array(errors).map { |e| "#{INDENT}- #{e.to_string(subschema_level + 1)}" })
           end
           messages.map { |m| (INDENT * subschema_level) + m }.join("\n")
         end
       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}
-        if !@sub_errors.empty?
-          base[:errors] = @sub_errors.inject({}) do |hsh, (subschema, errors)|
+        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 }
+        unless @sub_errors.empty?
+          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

@@ -20,7 +20,7 @@ module JSON
       private
 
       def type_string
-        type == :uri ? 'URI' : type.to_s
+        (type == :uri) ? 'URI' : type.to_s
       end
     end
 
@@ -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
@@ -118,7 +120,7 @@ module JSON
 
       def read_uri(uri)
         if accept_uri?(uri)
-          open(uri.to_s).read
+          URI.open(uri.to_s).read
         else
           raise JSON::Schema::ReadRefused.new(uri.to_s, :uri)
         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
@@ -29,7 +29,7 @@ module JSON
       end
 
       def metaschema
-        resources = File.expand_path('../../../../resources', __FILE__)
+        resources = File.expand_path('../../../resources', __dir__)
         File.join(resources, @metaschema_name)
       end
     end

data/lib/json-schema/schema.rb

@@ -2,15 +2,14 @@ require 'pathname'
 
 module JSON
   class Schema
-
     attr_accessor :schema, :uri, :validator
 
-    def initialize(schema,uri,parent_validator=nil)
+    def initialize(schema, uri, parent_validator = nil)
       @schema = schema
       @uri = uri
 
       # If there is an ID on this schema, use it to generate the URI
-      if @schema['id'] && @schema['id'].kind_of?(String)
+      if @schema['id'].is_a?(String)
         temp_uri = JSON::Util::URI.parse(@schema['id'])
         if temp_uri.relative?
           temp_uri = uri.join(temp_uri)
@@ -20,13 +19,13 @@ module JSON
       @uri = JSON::Util::URI.strip_fragment(@uri)
 
       # If there is a $schema on this schema, use it to determine which validator to use
-      if @schema['$schema']
-        @validator = JSON::Validator.validator_for_uri(@schema['$schema'])
-      elsif parent_validator
-        @validator = parent_validator
-      else
-        @validator = JSON::Validator.default_validator
-      end
+      @validator = if @schema['$schema']
+                     JSON::Validator.validator_for_uri(@schema['$schema'])
+                   elsif parent_validator
+                     parent_validator
+                   else
+                     JSON::Validator.default_validator
+                   end
     end
 
     def validate(data, fragments, processor, options = {})
@@ -35,13 +34,13 @@ module JSON
 
     def self.stringify(schema)
       case schema
-      when Hash then
-        Hash[schema.map { |key, value| [key.to_s, stringify(schema[key])] }]
-      when Array then
+      when Hash
+        schema.map { |key, _value| [key.to_s, stringify(schema[key])] }.to_h
+      when Array
         schema.map do |schema_item|
           stringify(schema_item)
         end
-      when Symbol then
+      when Symbol
         schema.to_s
       else
         schema

data/lib/json-schema/util/array_set.rb

@@ -1,13 +1,11 @@
-require 'set'
-
 # This is a hack that I don't want to ever use anywhere else or repeat EVER, but we need enums to be
 # an Array to pass schema validation. But we also want fast lookup!
 
 class ArraySet < Array
   def include?(obj)
-    if !defined? @values
+    unless defined? @values
       @values = Set.new
-      self.each { |x| @values << convert_to_float_if_numeric(x) }
+      each { |x| @values << convert_to_float_if_numeric(x) }
     end
     @values.include?(convert_to_float_if_numeric(obj))
   end