json-schema 2.4.1 → 2.5.0

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

@@ -0,0 +1,41 @@
+require 'json-schema/attributes/format'
+require 'ipaddr'
+require 'socket'
+
+module JSON
+  class Schema
+    class IPFormat < FormatAttribute
+      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'
+        end
+
+        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])
+        end
+      end
+
+      def self.ip_version
+        raise NotImplementedError
+      end
+    end
+
+    class IP4Format < IPFormat
+      def self.ip_version
+        4
+      end
+    end
+
+    class IP6Format < IPFormat
+      def self.ip_version
+        6
+      end
+    end
+  end
+end

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

@@ -1,16 +1,18 @@
 require 'json-schema/attribute'
-require 'uri'
+require 'addressable/uri'
 module JSON
   class Schema
     class UriFormat < FormatAttribute
       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 valid URI"
-          begin
-            URI.parse(URI.escape(data))
-          rescue URI::InvalidURIError
-            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
-          end
+        return unless data.is_a?(String)
+        error_message = "The property '#{build_fragment(fragments)}' must be a valid URI"
+        begin
+          # TODO
+          # Addressable only throws an exception on to_s for invalid URI strings, although it
+          # probably should throughout parse already - https://github.com/sporkmonger/addressable/issues/177
+          Addressable::URI.parse(data).to_s
+        rescue Addressable::URI::InvalidURIError
+          validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -4,22 +4,21 @@ module JSON
   class Schema
     class ItemsAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Array)
-           if current_schema.schema['items'].is_a?(Hash)
-             data.each_with_index do |item,i|
-               schema = JSON::Schema.new(current_schema.schema['items'],current_schema.uri,validator)
-               fragments << i.to_s
-               schema.validate(item,fragments, processor, options)
-               fragments.pop
-             end
-           elsif current_schema.schema['items'].is_a?(Array)
-             current_schema.schema['items'].each_with_index do |item_schema,i|
-               schema = JSON::Schema.new(item_schema,current_schema.uri,validator)
-               fragments << i.to_s
-               schema.validate(data[i],fragments, processor, options)
-               fragments.pop
-             end
-           end
+        return unless data.is_a?(Array)
+
+        items = current_schema.schema['items']
+        case items
+        when Hash
+          schema = JSON::Schema.new(items, current_schema.uri, validator)
+          data.each_with_index do |item, i|
+            schema.validate(item, fragments + [i.to_s], processor, options)
+          end
+
+        when Array
+          items.each_with_index do |item_schema, i|
+            schema = JSON::Schema.new(item_schema, current_schema.uri, validator)
+            schema.validate(data[i], fragments + [i.to_s], processor, options)
+          end
         end
       end
     end

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

@@ -0,0 +1,179 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class LimitAttribute < Attribute
+      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))
+
+        property    = build_fragment(fragments)
+        description = error_message(schema)
+        message = format("The property '%s' %s", property, description)
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+      end
+
+      def self.invalid?(schema, data)
+        exclusive = exclusive?(schema)
+        limit = limit(schema)
+
+        if limit_name.start_with?('max')
+          exclusive ? data >= limit : data > limit
+        else
+          exclusive ? data <= limit : data < limit
+        end
+      end
+
+      def self.limit(schema)
+        schema[limit_name]
+      end
+
+      def self.exclusive?(schema)
+        false
+      end
+
+      def self.value(data)
+        data
+      end
+
+      def self.acceptable_type
+        raise NotImplementedError
+      end
+
+      def self.error_message(schema)
+        raise NotImplementedError
+      end
+
+      def self.limit_name
+        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/maxdecimal.rb

@@ -4,12 +4,13 @@ module JSON
   class Schema
     class MaxDecimalAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Numeric)
-          s = data.to_s.split(".")[1]
-          if s && s.length > current_schema.schema['maxDecimal']
-            message = "The property '#{build_fragment(fragments)}' had more decimal places than the allowed #{current_schema.schema['maxDecimal']}"
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
+        return unless data.is_a?(Numeric)
+
+        max_decimal_places = current_schema.schema['maxDecimal']
+        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])
         end
       end
     end

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

@@ -1,17 +1,10 @@
-require 'json-schema/attribute'
+require 'json-schema/attributes/divisibleby'
 
 module JSON
   class Schema
-    class MultipleOfAttribute < Attribute
-      def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Numeric)
-          if current_schema.schema['multipleOf'] == 0 ||
-             current_schema.schema['multipleOf'] == 0.0 ||
-             (BigDecimal.new(data.to_s) % BigDecimal.new(current_schema.schema['multipleOf'].to_s)).to_f != 0
-             message = "The property '#{build_fragment(fragments)}' was not divisible by #{current_schema.schema['multipleOf']}"
-             validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
-        end
+    class MultipleOfAttribute < DivisibleByAttribute
+      def self.keyword
+        'multipleOf'
       end
     end
   end

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

@@ -4,10 +4,10 @@ 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)
         failed = true
         errors_copy = processor.validation_errors.clone
+
         begin
           schema.validate(data,fragments,processor,options)
           # If we're recording errors, we don't throw an exception. Instead, check the errors array length

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

@@ -5,25 +5,34 @@ module JSON
     class OneOfAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
         validation_errors = 0
-        current_schema.schema['oneOf'].each do |element|
+        one_of = current_schema.schema['oneOf']
+
+        original_data = data.is_a?(Hash) ? data.clone : data
+        success_data = nil
+
+        one_of.each do |element|
           schema = JSON::Schema.new(element,current_schema.uri,validator)
 
           begin
             # need to raise exceptions on error because
             # schema.validate doesn't reliably return true/false
             schema.validate(data,fragments,processor,options.merge(:record_errors => false))
+            success_data = data.is_a?(Hash) ? data.clone : data
           rescue ValidationError
             validation_errors += 1
           end
 
+          data = original_data
+        end
+
+        if validation_errors == one_of.length - 1
+          data = success_data
+          return
         end
 
-        case validation_errors
-        when current_schema.schema['oneOf'].length - 1 # correct, matched only one
-          message = nil
-        when current_schema.schema['oneOf'].length  # didn't match any
+        if validation_errors == one_of.length
           message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match any of the required schemas"
-        else # too many matches
+        else
           message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched more than one of the required schemas"
         end
 

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

@@ -4,12 +4,13 @@ module JSON
   class Schema
     class PatternAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(String)
-          r = Regexp.new(current_schema.schema['pattern'])
-          if (r.match(data)).nil?
-            message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match the regex '#{current_schema.schema['pattern']}'"
-            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-          end
+        return unless data.is_a?(String)
+
+        pattern = current_schema.schema['pattern']
+        regexp  = Regexp.new(pattern)
+        unless regexp.match(data)
+          message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match the regex '#{pattern}'"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
         end
       end
     end

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

@@ -4,19 +4,16 @@ module JSON
   class Schema
     class PatternPropertiesAttribute < Attribute
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash)
-          current_schema.schema['patternProperties'].each do |property,property_schema|
-            r = Regexp.new(property)
+        return unless data.is_a?(Hash)
 
-            # Check each key in the data hash to see if it matches the regex
-            data.each do |key,value|
-              if r.match(key)
-                schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
-                fragments << key
-                schema.validate(data[key],fragments,processor,options)
-                fragments.pop
-              end
-            end
+        current_schema.schema['patternProperties'].each do |property, property_schema|
+          regexp = Regexp.new(property)
+
+          # 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
         end
       end

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

@@ -3,55 +3,71 @@ require 'json-schema/attribute'
 module JSON
   class Schema
     class PropertiesAttribute < Attribute
+      def self.required?(schema, options)
+        schema.fetch('required') { options[:strict] }
+      end
+
       def self.validate(current_schema, data, fragments, processor, validator, options = {})
-        if data.is_a?(Hash)
-          current_schema.schema['properties'].each do |property,property_schema|
-            if !data.has_key?(property.to_s) &&
-               property_schema['default'] &&
-               !property_schema['readonly'] &&
-               options[:insert_defaults]
-              default = property_schema['default']
-              data[property.to_s] = (default.is_a?(Hash) ? default.clone : default)
-            end
+        return unless data.is_a?(Hash)
 
-            if property_schema.fetch('required') { options[:strict] } && !data.has_key?(property.to_s)
-              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
+        schema = current_schema.schema
+        schema['properties'].each do |property, property_schema|
+          property = property.to_s
 
-            if data.has_key?(property.to_s)
-              schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
-              fragments << property.to_s
-              schema.validate(data[property.to_s],fragments,processor,options)
-              fragments.pop
-            end
+          if !data.key?(property) &&
+              options[:insert_defaults] &&
+              property_schema['default'] &&
+              !property_schema['readonly']
+            default = property_schema['default']
+            data[property] = default.is_a?(Hash) ? default.clone : default
+          end
+
+          if required?(property_schema, options) && !data.has_key?(property)
+            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
+
+          if data.has_key?(property)
+            expected_schema = JSON::Schema.new(property_schema, current_schema.uri, validator)
+            expected_schema.validate(data[property], fragments + [property], processor, options)
           end
+        end
+
+        # When strict is true, ensure no undefined properties exist in the data
+        return unless options[:strict] == true && !schema.key?('additionalProperties')
+
+        diff = data.select do |k, v|
+          k = k.to_s
 
-          # When strict is true, ensure no undefined properties exist in the data
-          if (options[:strict] == true && !current_schema.schema.has_key?('additionalProperties'))
-            diff = data.select do |k,v|
-              if current_schema.schema.has_key?('patternProperties')
-                match = false
-                current_schema.schema['patternProperties'].each do |property,property_schema|
-                  r = Regexp.new(property)
-                  if r.match(k)
-                    match = true
-                    break
-                  end
-                end
-
-                !current_schema.schema['properties'].has_key?(k.to_s) && !match
-              else
-                !current_schema.schema['properties'].has_key?(k.to_s)
+          if schema.has_key?('patternProperties')
+            match = false
+            schema['patternProperties'].each do |property, property_schema|
+              regexp = Regexp.new(property)
+              if regexp.match(k)
+                match = true
+                break
               end
             end
 
-            if diff.size > 0
-              message = "The property '#{build_fragment(fragments)}' contained undefined properties: '#{diff.keys.join(", ")}'"
-              validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-            end
+            !schema['properties'].has_key?(k) && !match
+          else
+            !schema['properties'].has_key?(k)
           end
         end
+
+        if diff.size > 0
+          properties = data.to_a.map { |(key, _)| key }.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