json-schema 2.8.0 → 5.1.1

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

@@ -48,132 +48,5 @@ module JSON
         raise NotImplementedError
       end
     end
-
-    class MinLengthAttribute < LimitAttribute
-      def self.acceptable_type
-        String
-      end
-
-      def self.limit_name
-        'minLength'
-      end
-
-      def self.error_message(schema)
-        "was not of a minimum string length of #{limit(schema)}"
-      end
-
-      def self.value(data)
-        data.length
-      end
-    end
-
-    class MaxLengthAttribute < MinLengthAttribute
-      def self.limit_name
-        'maxLength'
-      end
-
-      def self.error_message(schema)
-        "was not of a maximum string length of #{limit(schema)}"
-      end
-    end
-
-    class MinItemsAttribute < LimitAttribute
-      def self.acceptable_type
-        Array
-      end
-
-      def self.value(data)
-        data.length
-      end
-
-      def self.limit_name
-        'minItems'
-      end
-
-      def self.error_message(schema)
-        "did not contain a minimum number of items #{limit(schema)}"
-      end
-    end
-
-    class MaxItemsAttribute < MinItemsAttribute
-      def self.limit_name
-        'maxItems'
-      end
-
-      def self.error_message(schema)
-        "had more items than the allowed #{limit(schema)}"
-      end
-    end
-
-    class MinPropertiesAttribute < LimitAttribute
-      def self.acceptable_type
-        Hash
-      end
-
-      def self.value(data)
-        data.size
-      end
-
-      def self.limit_name
-        'minProperties'
-      end
-
-      def self.error_message(schema)
-        "did not contain a minimum number of properties #{limit(schema)}"
-      end
-    end
-
-    class MaxPropertiesAttribute < MinPropertiesAttribute
-      def self.limit_name
-        'maxProperties'
-      end
-
-      def self.error_message(schema)
-        "had more properties than the allowed #{limit(schema)}"
-      end
-    end
-
-    class NumericLimitAttribute < LimitAttribute
-      def self.acceptable_type
-        Numeric
-      end
-
-      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)
-      end
-    end
-
-    class MaximumAttribute < NumericLimitAttribute
-      def self.limit_name
-        'maximum'
-      end
-
-      def self.exclusive?(schema)
-        schema['exclusiveMaximum']
-      end
-    end
-
-    class MaximumInclusiveAttribute < MaximumAttribute
-      def self.exclusive?(schema)
-        schema['maximumCanEqual'] == false
-      end
-    end
-
-    class MinimumAttribute < NumericLimitAttribute
-      def self.limit_name
-        'minimum'
-      end
-
-      def self.exclusive?(schema)
-        schema['exclusiveMinimum']
-      end
-    end
-
-    class MinimumInclusiveAttribute < MinimumAttribute
-      def self.exclusive?(schema)
-        schema['minimumCanEqual'] == false
-      end
-    end
   end
 end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limit'
+
+module JSON
+  class Schema
+    class ItemsLimitAttribute < LimitAttribute
+      def self.acceptable_type
+        Array
+      end
+
+      def self.value(data)
+        data.length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limit'
+
+module JSON
+  class Schema
+    class LengthLimitAttribute < LimitAttribute
+      def self.acceptable_type
+        String
+      end
+
+      def self.value(data)
+        data.length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/items'
+
+module JSON
+  class Schema
+    class MaxItemsAttribute < ItemsLimitAttribute
+      def self.limit_name
+        'maxItems'
+      end
+
+      def self.error_message(schema)
+        "had more items than the allowed #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/length'
+
+module JSON
+  class Schema
+    class MaxLengthAttribute < LengthLimitAttribute
+      def self.limit_name
+        'maxLength'
+      end
+
+      def self.error_message(schema)
+        "was not of a maximum string length of #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/properties'
+
+module JSON
+  class Schema
+    class MaxPropertiesAttribute < PropertiesLimitAttribute
+      def self.limit_name
+        'maxProperties'
+      end
+
+      def self.error_message(schema)
+        "had more properties than the allowed #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/numeric'
+
+module JSON
+  class Schema
+    class MaximumAttribute < NumericLimitAttribute
+      def self.limit_name
+        'maximum'
+      end
+
+      def self.exclusive?(schema)
+        schema['exclusiveMaximum']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'json-schema/attributes/limits/maximum'
+
+module JSON
+  class Schema
+    class MaximumInclusiveAttribute < MaximumAttribute
+      def self.exclusive?(schema)
+        schema['maximumCanEqual'] == false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/items'
+
+module JSON
+  class Schema
+    class MinItemsAttribute < ItemsLimitAttribute
+      def self.limit_name
+        'minItems'
+      end
+
+      def self.error_message(schema)
+        "did not contain a minimum number of items #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/length'
+
+module JSON
+  class Schema
+    class MinLengthAttribute < LengthLimitAttribute
+      def self.limit_name
+        'minLength'
+      end
+
+      def self.error_message(schema)
+        "was not of a minimum string length of #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/properties'
+
+module JSON
+  class Schema
+    class MinPropertiesAttribute < PropertiesLimitAttribute
+      def self.limit_name
+        'minProperties'
+      end
+
+      def self.error_message(schema)
+        "did not contain a minimum number of properties #{limit(schema)}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limits/numeric'
+
+module JSON
+  class Schema
+    class MinimumAttribute < NumericLimitAttribute
+      def self.limit_name
+        'minimum'
+      end
+
+      def self.exclusive?(schema)
+        schema['exclusiveMinimum']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'json-schema/attributes/limits/minimum'
+
+module JSON
+  class Schema
+    class MinimumInclusiveAttribute < MinimumAttribute
+      def self.exclusive?(schema)
+        schema['minimumCanEqual'] == false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'json-schema/attributes/limit'
+
+module JSON
+  class Schema
+    class NumericLimitAttribute < LimitAttribute
+      def self.acceptable_type
+        Numeric
+      end
+
+      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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/limit'
+
+module JSON
+  class Schema
+    class PropertiesLimitAttribute < LimitAttribute
+      def self.acceptable_type
+        Hash
+      end
+
+      def self.value(data)
+        data.size
+      end
+    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

@@ -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,20 +55,12 @@ 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])
         end
       end
     end
-
-    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
-      end
-    end
   end
 end

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

@@ -0,0 +1,13 @@
+require 'json-schema/attributes/properties'
+
+module JSON
+  class Schema
+    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[:allPropertiesRequired] == true
+      end
+    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,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}"
               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

@@ -9,13 +9,14 @@ module JSON
         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
             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)
@@ -20,19 +20,18 @@ module JSON
           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}
+        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