json-schema-ouidou 2.9.0

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

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

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

@@ -0,0 +1,11 @@
+require 'json-schema/attributes/divisibleby'
+
+module JSON
+  class Schema
+    class MultipleOfAttribute < DivisibleByAttribute
+      def self.keyword
+        'multipleOf'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'json-schema/attribute'
+
+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
+          if options[:record_errors] && errors_copy.length != processor.validation_errors.length
+            processor.validation_errors.replace(errors_copy)
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} matched the disallowed schema"
+            failed = false
+          end
+        rescue ValidationError
+          # Yay, we failed validation.
+        end
+
+        unless failed
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class OneOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        errors = Hash.new { |hsh, k| hsh[k] = [] }
+
+        validation_error_count = 0
+        one_of = current_schema.schema['oneOf']
+
+        original_data = data.is_a?(Hash) ? data.clone : data
+        success_data = nil
+
+        valid = false
+
+        one_of.each_with_index do |element, schema_index|
+          schema = JSON::Schema.new(element,current_schema.uri,validator)
+          pre_validation_error_count = validation_errors(processor).count
+          begin
+            schema.validate(data,fragments,processor,options)
+            success_data = data.is_a?(Hash) ? data.clone : data
+            valid = true
+          rescue ValidationError
+            valid = false
+          end
+
+          diff = validation_errors(processor).count - pre_validation_error_count
+          valid = false if diff > 0
+          validation_error_count += 1 if !valid
+          while diff > 0
+            diff = diff - 1
+            errors["oneOf ##{schema_index}"].push(validation_errors(processor).pop)
+          end
+          data = original_data
+        end
+
+
+
+        if validation_error_count == one_of.length - 1
+          data = success_data
+          return
+        end
+
+        if validation_error_count == one_of.length
+          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match any of the required schemas"
+        else
+          message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} matched more than one of the required schemas"
+        end
+
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors]) if message
+        validation_errors(processor).last.sub_errors = errors if message
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,66 @@
+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 = {})
+        return unless data.is_a?(Hash)
+
+        schema = current_schema.schema
+        schema['properties'].each do |property, property_schema|
+          property = property.to_s
+
+          if !data.key?(property) &&
+              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
+
+          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
+
+          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
+
+            !schema['properties'].has_key?(k) && !match
+          else
+            !schema['properties'].has_key?(k)
+          end
+        end
+
+        if diff.size > 0
+          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
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class PropertiesOptionalAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Hash)
+
+        schema = current_schema.schema
+        schema['properties'].each do |property, property_schema|
+          property = property.to_s
+
+          if !property_schema['optional'] && !data.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
+      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[:strict] == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'json-schema/attribute'
+require 'json-schema/errors/schema_error'
+require 'json-schema/util/uri'
+
+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)
+
+        if schema
+          schema.validate(data, fragments, processor, options)
+        elsif uri
+          message = "The referenced 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
+
+      def self.get_referenced_uri_and_schema(s, current_schema, validator)
+        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] + "#"
+
+        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("/")
+          fragment_path = ''
+          fragments.each do |fragment|
+            if fragment && fragment != ''
+              fragment = fragment.gsub('~0', '~').gsub('~1', '/')
+              if target_schema.is_a?(Array)
+                target_schema = target_schema[fragment.to_i]
+              else
+                target_schema = target_schema[fragment]
+              end
+              fragment_path = fragment_path + "/#{fragment}"
+              if target_schema.nil?
+                raise SchemaError.new("The fragment '#{fragment_path}' does not exist on schema #{ref_schema.uri.to_s}")
+              end
+            end
+          end
+
+          # We have the schema finally, build it and validate!
+          uri = temp_uri
+          schema = JSON::Schema.new(target_schema,temp_uri,validator)
+        end
+
+        [uri,schema]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class RequiredAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Hash)
+
+        schema = current_schema.schema
+        defined_properties = schema['properties']
+
+        schema['required'].each do |property, property_schema|
+          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"]
+
+          if !prop_defaults
+            message = "The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class TypeAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        union = true
+        if options[:disallow]
+          types = current_schema.schema['disallow']
+        else
+          types = current_schema.schema['type']
+        end
+
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        end
+        valid = false
+
+        # Create a hash to hold errors that are generated during union validation
+        union_errors = Hash.new { |hsh, k| hsh[k] = [] }
+
+        types.each_with_index do |type, type_index|
+          if type.is_a?(String)
+            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)
+
+            # 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))
+              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
+              union_errors["type ##{type_index}"].push(validation_errors(processor).pop)
+            end
+          end
+
+          break if valid
+        end
+
+        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
+          if union
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match one or more of the following types: #{list_types(types)}"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+            validation_errors(processor).last.sub_errors = union_errors
+          else
+            message = "The property '#{build_fragment(fragments)}' of type #{type_of_data(data)} did not match the following type: #{list_types(types)}"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+
+      def self.list_types(types)
+        types.map { |type| type.is_a?(String) ? type : '(schema)' }.join(', ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class TypeV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        union = true
+        types = current_schema.schema['type']
+        if !types.is_a?(Array)
+          types = [types]
+          union = false
+        end
+
+        return if types.any? { |type| data_valid_for_type?(data, type) }
+
+        types = types.map { |type| type.is_a?(String) ? type : '(schema)' }.join(', ')
+        message = format(
+          "The property '%s' of type %s did not match %s: %s",
+          build_fragment(fragments),
+          type_of_data(data),
+          union ? 'one or more of the following types' : 'the following type',
+          types
+        )
+
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class UniqueItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Array)
+
+        if data.clone.uniq!
+          message = "The property '#{build_fragment(fragments)}' contained duplicated array values"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+
+      def self.validate_on_false?
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module JSON
+  class Schema
+    class CustomFormatError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module JSON
+  class Schema
+    class JsonLoadError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module JSON
+  class Schema
+    class JsonParseError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module JSON
+  class Schema
+    class SchemaError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'json/common'
+
+module JSON
+  class Schema
+    class SchemaParseError < JSON::ParserError
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module JSON
+  class Schema
+    class UriError < StandardError
+    end
+  end
+end