json-schema-ouidou 2.9.0

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

@@ -0,0 +1,39 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class AllOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create an hash to hold errors that are generated during validation
+        errors = Hash.new { |hsh, k| hsh[k] = [] }
+        valid = true
+
+        current_schema.schema['allOf'].each_with_index do |element, schema_index|
+          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
+            valid = false
+          end
+
+          diff = validation_errors(processor).count - pre_validation_error_count
+          while diff > 0
+            diff = 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"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          validation_errors(processor).last.sub_errors = errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class AnyOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create a hash to hold errors that are generated during validation
+        errors = Hash.new { |hsh, k| hsh[k] = [] }
+        valid = false
+
+        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)
+
+          # 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)
+            valid = true
+          rescue ValidationError
+            # We don't care that these schemas don't validate - we only care that one validated
+          end
+
+          diff = validation_errors(processor).count - pre_validation_error_count
+          valid = false if diff > 0
+          while diff > 0
+            diff = diff - 1
+            errors["anyOf ##{schema_index}"].push(validation_errors(processor).pop)
+          end
+
+          break if valid
+
+          data = original_data
+        end
+
+        if !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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class DependenciesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Hash)
+
+        current_schema.schema['dependencies'].each do |property, dependency_value|
+          next unless data.has_key?(property.to_s)
+          next unless accept_value?(dependency_value)
+
+          case dependency_value
+          when String
+            validate_dependency(current_schema, data, property, dependency_value, fragments, processor, self, options)
+          when Array
+            dependency_value.each do |value|
+              validate_dependency(current_schema, data, property, value, fragments, processor, self, options)
+            end
+          else
+            schema = JSON::Schema.new(dependency_value, current_schema.uri, validator)
+            schema.validate(data, fragments, processor, options)
+          end
+        end
+      end
+
+      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
+
+      def self.accept_value?(value)
+        value.is_a?(String) || value.is_a?(Array) || value.is_a?(Hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'json-schema/attributes/dependencies'
+
+module JSON
+  class Schema
+    class DependenciesV4Attribute < DependenciesAttribute
+      def self.accept_value?(value)
+        value.is_a?(Array) || value.is_a?(Hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    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))
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class EnumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        enum = current_schema.schema['enum']
+        return if enum.include?(data)
+
+        values = enum.map { |val|
+          case val
+          when nil   then 'null'
+          when Array then 'array'
+          when Hash  then 'object'
+          else val.to_s
+          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])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'json-schema/attribute'
+require 'json-schema/attributes/ref'
+
+module JSON
+  class Schema
+    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.each do |s|
+          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"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          else
+            message = "The property '#{build_fragment(fragments)}' was not a valid schema"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+
+      def self.get_extended_uri_and_schema(s, current_schema, validator)
+        uri,schema = nil,nil
+
+        if s.is_a?(Hash)
+          uri = current_schema.uri
+          if s['$ref']
+            ref_uri,ref_schema = JSON::Schema::RefAttribute.get_referenced_uri_and_schema(s, current_schema, validator)
+            if ref_schema
+              if s.size == 1 # Check if anything else apart from $ref
+                uri,schema = ref_uri,ref_schema
+              else
+                s = s.dup
+                s.delete '$ref'
+                s = ref_schema.schema.merge(s)
+              end
+            end
+          end
+          schema ||= JSON::Schema.new(s,uri,validator)
+        end
+
+        [uri,schema]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    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?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'json-schema/attributes/format'
+require 'json-schema/errors/custom_format_error'
+
+module JSON
+  class Schema
+    class CustomFormat < FormatAttribute
+      def initialize(validation_proc)
+        @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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'json-schema/attributes/format'
+
+module JSON
+  class Schema
+    class DateFormat < FormatAttribute
+      REGEXP = /\A\d{4}-\d{2}-\d{2}\z/
+
+      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)
+            begin
+              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
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+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/
+
+      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")
+
+            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
+
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m.length < 4
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
+          else
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'json-schema/attributes/format'
+
+module JSON
+  class Schema
+    class DateTimeV4Format < FormatAttribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(String)
+        DateTime.rfc3339(data)
+      rescue ArgumentError
+        error_message = "The property '#{build_fragment(fragments)}' must be a valid RFC3339 date/time string"
+        validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'json-schema/attributes/format'
+
+module JSON
+  class Schema
+    class TimeFormat < FormatAttribute
+      REGEXP = /\A(\d{2}):(\d{2}):(\d{2})\z/
+
+      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))
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[1].to_i > 23
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[2].to_i > 59
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors]) and return if m[3].to_i > 59
+          else
+            validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'json-schema/attributes/format'
+require 'json-schema/errors/uri_error'
+
+module JSON
+  class Schema
+    class UriFormat < FormatAttribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(String)
+        error_message = "The property '#{build_fragment(fragments)}' must be a valid URI"
+        begin
+          JSON::Util::URI.parse(data)
+        rescue JSON::Schema::UriError
+          validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,52 @@
+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
+  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