json-schema 2.8.1 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3361b9ea49eb9e208babcec94973eb5efd0d371c2a2cbab16cca9e6555b11b77
-  data.tar.gz: 82f4c4d50b75db5d379555c76ca2606580c14d74a0ec5088504cfb5f5025e1ed
+  metadata.gz: e9686db47d231f89e17854471084e1dfe27b365df2e5be5e04a98ef27d05cbcf
+  data.tar.gz: 5f6e77d40b284308ed64d630e292d57797c0c156bdc8ebaafa12acc3ffcfba7f
 SHA512:
-  metadata.gz: 5040893a974d35c4e9833076d8db0073215fdc6330535a4ae7c7d3eef3bdfd902e3642ed5bd9729735b65d8821e30db2b563411d4fd6cf0187c6efe2a4179669
-  data.tar.gz: 9161d768e8829faafefeabf7723c462019831393d4c696ccbc9b7f7be9f5affcc988cf93a2ce1709ea1b6cddd70230fa44815cd4a3e965b7c15ea65b2b0c3de2
+  metadata.gz: bdb9e93be56be04160b301dd200684b20495ffd3326d12dd2ca2014eb6f3bfc667f61ba1a3f61bdb5f39cab20a0edbf509a7efd84cb52ac728219b88c1ad4b61
+  data.tar.gz: b62696183483862807c53bcc9ccbf831206800dda4e26f03de0da0f12f556e36a6e01083c853100348f7f9f96c13607d1e7600af41436ceb01eb4ca4966b56a3

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.md)
+[![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
@@ -69,7 +80,7 @@ that the `$schema` attribute takes precedence over the `:version` option during
 parsing and validation.
 
 For further information on json schema itself refer to <a
-href="http://spacetelescope.github.io/understanding-json-schema/">Understanding
+href="https://json-schema.org/understanding-json-schema">Understanding
 JSON Schema</a>.
 
 Basic Usage
@@ -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 under 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,15 +3,14 @@ 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('/')}"
       end
 
-      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors)
-        error = ValidationError.new(message, fragments, failed_attribute, current_schema)
+      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors, properties = [])
+        error = ValidationError.new(message, fragments, failed_attribute, current_schema, properties)
         if record_errors
           processor.validation_error(error)
         else
@@ -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

@@ -30,14 +30,12 @@ module JSON
         schema = current_schema.schema
 
         if schema['properties']
-          extra_properties = extra_properties - schema['properties'].keys
+          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,29 +7,56 @@ 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
+            # Cannot raise if noAdditionalProperties is true, we need to
+            # evaluate each sub schema within the allOf, before raising.
+            if options[:noAdditionalProperties] == true
+              schema.validate(data, fragments, processor, options.merge(record_errors: true))
+            else
+              schema.validate(data, fragments, processor, options)
+            end
+          rescue ValidationError => e
             valid = false
+            message = e.message
           end
 
           diff = validation_errors(processor).count - pre_validation_error_count
+
           while diff > 0
-            diff = diff - 1
+            diff -= 1
             errors["allOf ##{schema_index}"].push(validation_errors(processor).pop)
           end
         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"
+        # Find any properties that are missing across all subschemas.
+        common_missing_properties = {}
+        if options[:noAdditionalProperties] == true && !errors.empty?
+          all_property_errors = errors.values.flatten.map(&:properties)
+          common_missing_properties = (all_property_errors.first || []).to_set
+
+          all_property_errors[1..].each do |curr_property_errors|
+            common_missing_properties &= curr_property_errors.to_set
+          end
+        end
+
+        # PropertiesV4Attribute represents errors that would indicate an
+        # additional property was detected. If we filter these out, we should
+        # be left with errors that are not dependent on any other sub schema.
+        non_missing_property_errors = errors.values.flatten.reject do |error|
+          error.failed_attribute == JSON::Schema::PropertiesV4Attribute
+        end
+
+        if !valid || !non_missing_property_errors.empty? || !common_missing_properties.empty?
+          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
@@ -27,7 +27,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
             errors["anyOf ##{schema_index}"].push(validation_errors(processor).pop)
           end
 
@@ -36,7 +36,7 @@ module JSON
           data = original_data
         end
 
-        if !valid
+        unless valid
           message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match one or more of the required schemas"
           validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
           validation_errors(processor).last.sub_errors = errors

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

@@ -7,7 +7,7 @@ module JSON
         'divisibleBy'
       end
 
-      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?(Numeric)
 
         factor = current_schema.schema[keyword]

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

@@ -3,18 +3,18 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class EnumAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         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

@@ -6,13 +6,13 @@ module JSON
     class ExtendsAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         schemas = current_schema.schema['extends']
-        schemas = [schemas] if !schemas.is_a?(Array)
+        schemas = [schemas] unless 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
-            message = "The extended schema '#{uri.to_s}' cannot be found"
+            message = "The extended 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"
@@ -22,15 +22,17 @@ module JSON
       end
 
       def self.get_extended_uri_and_schema(s, current_schema, validator)
-        uri,schema = nil,nil
+        uri = nil
+        schema = 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 = ref_uri
+                schema = ref_schema
               else
                 s = s.dup
                 s.delete '$ref'
@@ -38,10 +40,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/custom.rb

@@ -8,13 +8,11 @@ module JSON
         @validation_proc = validation_proc
       end
 
-      def validate(current_schema, data, fragments, processor, validator, options = {})
-        begin
-          @validation_proc.call data
-        rescue JSON::Schema::CustomFormatError => e
-          message = "The property '#{self.class.build_fragment(fragments)}' #{e.message}"
-          self.class.validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-        end
+      def validate(current_schema, data, fragments, processor, _validator, options = {})
+        @validation_proc.call data
+      rescue JSON::Schema::CustomFormatError => e
+        message = "The property '#{self.class.build_fragment(fragments)}' #{e.message}"
+        self.class.validation_error(processor, message, fragments, current_schema, self.class, options[:record_errors])
       end
     end
   end

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

@@ -5,7 +5,7 @@ module JSON
     class DateFormat < FormatAttribute
       REGEXP = /\A\d{4}-\d{2}-\d{2}\z/
 
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
           if REGEXP.match(data)
@@ -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

@@ -3,19 +3,20 @@ require 'json-schema/attributes/format'
 module JSON
   class Schema
     class DateTimeFormat < FormatAttribute
-      REGEXP = /\A\d{4}-\d{2}-\d{2}T(\d{2}):(\d{2}):(\d{2})([\.,]\d+)?(Z|[+-](\d{2})(:?\d{2})?)?\z/
+      REGEXP = /\A\d{4}-\d{2}-\d{2}T(\d{2}):(\d{2}):(\d{2})([.,]\d+)?(Z|[+-](\d{2})(:?\d{2})?)?\z/
 
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ with optional decimal fraction of the second
         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

@@ -3,8 +3,9 @@ require 'json-schema/attributes/format'
 module JSON
   class Schema
     class DateTimeV4Format < FormatAttribute
-      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)
+
         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

@@ -5,16 +5,16 @@ require 'socket'
 module JSON
   class Schema
     class IPFormat < FormatAttribute
-      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)
 
         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
+        family = (ip_version == 6) ? Socket::AF_INET6 : Socket::AF_INET
         unless ip && ip.family == family
           error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv#{ip_version} address"
           validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])

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

@@ -5,7 +5,7 @@ module JSON
     class TimeFormat < FormatAttribute
       REGEXP = /\A(\d{2}):(\d{2}):(\d{2})\z/
 
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         if data.is_a?(String)
           error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
           if (m = REGEXP.match(data))

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

@@ -4,8 +4,9 @@ require 'json-schema/errors/uri_error'
 module JSON
   class Schema
     class UriFormat < FormatAttribute
-      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)
+
         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/limit.rb

@@ -3,7 +3,7 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class LimitAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      def self.validate(current_schema, data, fragments, processor, _validator, options = {})
         schema = current_schema.schema
         return unless data.is_a?(acceptable_type) && invalid?(schema, value(data))
 
@@ -28,7 +28,7 @@ module JSON
         schema[limit_name]
       end
 
-      def self.exclusive?(schema)
+      def self.exclusive?(_schema)
         false
       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

@@ -3,11 +3,11 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class MaxDecimalAttribute < 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?(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])