json-schema-pvdgm 2.3.1

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

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+    class MaxLengthAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(String)
+          if data.length > current_schema.schema['maxLength']
+            message = "The property '#{build_fragment(fragments)}' was not of a maximum string length of #{current_schema.schema['maxLength']}"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :max_length })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MaxPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash) && (data.size > current_schema.schema['maxProperties'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of properties #{current_schema.schema['maxProperties']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :max_properties })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MinimumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Numeric)
+          if (current_schema.schema['exclusiveMinimum'] ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
+            message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
+            message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :minimum })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module JSON
+  class Schema
+    class MinimumInclusiveAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Numeric)
+          if (current_schema.schema['minimumCanEqual'] == false ? data <= current_schema.schema['minimum'] : data < current_schema.schema['minimum'])
+            message = "The property '#{build_fragment(fragments)}' did not have a minimum value of #{current_schema.schema['minimum']}, "
+            message += current_schema.schema['exclusiveMinimum'] ? 'exclusively' : 'inclusively'
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :minimum_inclusive })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MinItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Array) && (data.compact.size < current_schema.schema['minItems'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of items #{current_schema.schema['minItems']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :min_items })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module JSON
+  class Schema
+    class MinLengthAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(String)
+          if data.length < current_schema.schema['minLength']
+            message = "The property '#{build_fragment(fragments)}' was not of a minimum string length of #{current_schema.schema['minLength']}"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :min_length })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MinPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash) && (data.size < current_schema.schema['minProperties'])
+          message = "The property '#{build_fragment(fragments)}' did not contain a minimum number of properties #{current_schema.schema['minProperties']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :min_properties })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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], { property: last_fragment_as_symbol(fragments), failure: :multiple_of })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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 #{data.class} matched the disallowed schema"
+            failed = false
+          end
+        rescue
+          # Yay, we failed validation.
+        end
+
+        unless failed
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :not })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module JSON
+  class Schema
+    class OneOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        validation_errors = 0
+        current_schema.schema['oneOf'].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))
+          rescue ValidationError
+            validation_errors += 1
+          end
+
+        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
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match any of the required schemas"
+        else # too many matches
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} matched more than one of the required schemas"
+        end
+
+        validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :one_of }) if message
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+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], { property: last_fragment_as_symbol(fragments), failure: :pattern })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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)
+
+            # 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module JSON
+  class Schema
+    class PropertiesAttribute < Attribute
+      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) &&
+               !data.has_key?(property.to_sym) &&
+               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
+
+
+            if (property_schema['required'] || options[:strict] == true) && !data.has_key?(property.to_s) && !data.has_key?(property.to_sym)
+              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], { property: property.to_sym, failure: :properties })
+            end
+
+            if data.has_key?(property.to_s) || data.has_key?(property.to_sym)
+              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
+          end
+
+          # 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) && !current_schema.schema['properties'].has_key?(k.to_sym) && !match
+              else
+                !current_schema.schema['properties'].has_key?(k.to_s) && !current_schema.schema['properties'].has_key?(k.to_sym)
+              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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module JSON
+  class Schema
+    class PropertiesOptionalAttribute < Attribute
+      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 ((property_schema['optional'].nil? || property_schema['optional'] == false) && !data.has_key?(property.to_s) && !data.has_key?(property.to_sym))
+              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], { property: property.to_sym, failure: :properties_optional })
+            end
+
+            if data.has_key?(property.to_s) || data.has_key?(property.to_sym)
+              schema = JSON::Schema.new(property_schema,current_schema.uri,validator)
+              fragments << property
+              schema.validate(data[property],fragments,processor,options)
+              fragments.pop
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module JSON
+  class Schema
+    class PropertiesV4Attribute < Attribute
+      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) &&
+               !data.has_key?(property.to_sym) &&
+               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
+
+            if (options[:strict] == true && !data.has_key?(property.to_s) && !data.has_key?(property.to_sym))
+              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], { property: property.to_sym, failure: :properties })
+            end
+
+            if data.has_key?(property.to_s) || data.has_key?(property.to_sym)
+              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
+          end
+        end
+
+        # 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) && !current_schema.schema['properties'].has_key?(k.to_sym) && !match
+            else
+              !current_schema.schema['properties'].has_key?(k.to_s) && !current_schema.schema['properties'].has_key?(k.to_sym)
+            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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+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 = URI.parse(s['$ref'])
+        if temp_uri.relative?
+          temp_uri = current_schema.uri.clone
+          # Check for absolute path
+          path = s['$ref'].split("#")[0]
+          if path.nil? || path == ''
+            temp_uri.path = current_schema.uri.path
+          elsif path[0,1] == "/"
+            temp_uri.path = Pathname.new(path).cleanpath.to_s
+          else
+            temp_uri = current_schema.uri.merge(path)
+          end
+          temp_uri.fragment = s['$ref'].split("#")[1]
+        end
+        temp_uri.fragment = "" if temp_uri.fragment.nil?
+
+        # Grab the parent schema from the schema list
+        schema_key = temp_uri.to_s.split("#")[0] + "#"
+
+        ref_schema = JSON::Validator.schemas[schema_key]
+
+        if ref_schema
+          # Perform fragment resolution to retrieve the appropriate level for the schema
+          target_schema = ref_schema.schema
+          fragments = temp_uri.fragment.split("/")
+          fragment_path = ''
+          fragments.each do |fragment|
+            if fragment && fragment != ''
+              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,23 @@
+module JSON
+  class Schema
+    class RequiredAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['required'].each do |property,property_schema|
+            if !data.has_key?(property.to_s) && !data.has_key?(property.to_sym)
+              prop_defaults = options[:insert_defaults] &&
+                              current_schema.schema['properties'] &&
+                              current_schema.schema['properties'][property] &&
+                              !current_schema.schema['properties'][property]["default"].nil? &&
+                              !current_schema.schema['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], { property: property.to_sym, failure: :required })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end