json-schema-pvdgm 2.3.1

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

@@ -0,0 +1,37 @@
+module JSON
+  class Schema
+    class AllOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create an array to hold errors that are generated during validation
+        errors = []
+        valid = true
+
+        current_schema.schema['allOf'].each do |element|
+          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.push(validation_errors(processor).pop)
+          end
+        end
+
+        if !valid || !errors.empty?
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match all of the required schemas"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :all_of })
+          validation_errors(processor).last.sub_errors = errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module JSON
+  class Schema
+    class AnyOfAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        # Create an array to hold errors that are generated during validation
+        errors = []
+        valid = false
+
+        current_schema.schema['anyOf'].each do |element|
+          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.push(validation_errors(processor).pop)
+          end
+
+          break if valid
+        end
+
+        if !valid
+          message = "The property '#{build_fragment(fragments)}' of type #{data.class} did not match one or more of the required schemas"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :any_of })
+          validation_errors(processor).last.sub_errors = errors
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module JSON
+  class Schema
+    class DependenciesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['dependencies'].each do |property,dependency_value|
+            if data.has_key?(property.to_s) || data.has_key?(property.to_sym)
+              if dependency_value.is_a?(String)
+                if !data.has_key?(dependency_value.to_s) && !data.has_key?(dependency_value.to_sym)
+                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{dependency_value}'"
+                  validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :dependencies })
+                end
+              elsif dependency_value.is_a?(Array)
+                dependency_value.each do |value|
+                  if !data.has_key?(value.to_s) && !data.has_key?(value.to_sym)
+                    message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                    validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :dependencies })
+                  end
+                end
+              else
+                schema = JSON::Schema.new(dependency_value,current_schema.uri,validator)
+                schema.validate(data, fragments, processor, options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module JSON
+  class Schema
+    class DependenciesV4Attribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Hash)
+          current_schema.schema['dependencies'].each do |property,dependency_value|
+            if (data.has_key?(property.to_s) || data.has_key?(property.to_sym)) && dependency_value.is_a?(Array)
+              dependency_value.each do |value|
+                if !data.has_key?(value.to_s) && !data.has_key?(value.to_sym)
+                  message = "The property '#{build_fragment(fragments)}' has a property '#{property}' that depends on a missing property '#{value}'"
+                  validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :dependencies })
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module JSON
+  class Schema
+    class DisallowAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if validator.attributes['type']
+          validator.attributes['type'].validate(current_schema, data, fragments, processor, validator, {:disallow => true}.merge(options))
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+module JSON
+  class Schema
+    class EnumAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if !current_schema.schema['enum'].include?(data)
+          message = "The property '#{build_fragment(fragments)}' value #{data.inspect} did not match one of the following values:"
+          current_schema.schema['enum'].each {|val|
+            if val.is_a?(NilClass)
+              message += " null,"
+            elsif val.is_a?(Array)
+              message += " (array),"
+            elsif val.is_a?(Hash)
+              message += " (object),"
+            else
+              message += " #{val.to_s},"
+            end
+          }
+          message.chop!
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :enum })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+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], { property: last_fragment_as_symbol(fragments), failure: :extends })
+          else
+            message = "The property '#{build_fragment(fragments)}' was not a valid schema"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :extends })
+          end
+        end
+      end
+
+      def self.get_extended_uri_and_schema(s, current_schema, validator)
+        uri,schema = nil,nil
+
+        s = {'$ref' => s} if s.is_a?(String)
+
+        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,123 @@
+require 'uri'
+
+module JSON
+  class Schema
+    class FormatAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        case current_schema.schema['format']
+
+        # Timestamp in restricted ISO-8601 YYYY-MM-DDThh:mm:ssZ with optional decimal fraction of the second
+        when 'date-time'
+          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"
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\dT(\d\d):(\d\d):(\d\d)([\.,]\d+)?(Z|[+-](\d\d)(:?\d\d)?)?$')
+            if (m = r.match(data))
+              parts = data.split("T")
+              begin
+                Date.parse(parts[0])
+              rescue Exception
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+                return
+              end
+              begin
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[1].to_i > 23
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[2].to_i > 59
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[3].to_i > 59
+              rescue Exception
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+                return
+              end
+            else
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+              return
+            end
+          end
+        # Date in the format of YYYY-MM-DD
+        when 'date'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a date in the format of YYYY-MM-DD"
+            r = Regexp.new('^\d\d\d\d-\d\d-\d\d$')
+            if (m = r.match(data))
+              begin
+                Date.parse(data)
+              rescue Exception
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+                return
+              end
+            else
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+              return
+            end
+          end
+
+        # Time in the format of HH:MM:SS
+        when 'time'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a time in the format of hh:mm:ss"
+            r = Regexp.new('^(\d\d):(\d\d):(\d\d)$')
+            if (m = r.match(data))
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[1].to_i > 23
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[2].to_i > 59
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[3].to_i > 59
+            else
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+              return
+            end
+          end
+
+        # IPv4 in dotted-quad format
+        when 'ip-address', 'ipv4'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv4 address"
+            r = Regexp.new('^(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}\.(\d+){1,3}$')
+            if (m = r.match(data))
+              1.upto(4) do |x|
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if m[x].to_i > 255
+              end
+            else
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+              return
+            end
+          end
+
+        # IPv6 in standard format (including abbreviations)
+        when 'ipv6'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid IPv6 address"
+            r = Regexp.new('^[a-f0-9:]+$')
+            if (m = r.match(data))
+              # All characters are valid, now validate structure
+              parts = data.split(":")
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if parts.length > 8
+              condensed_zeros = false
+              parts.each do |part|
+                if part.length == 0
+                  validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if condensed_zeros
+                  condensed_zeros = true
+                end
+                validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format }) and return if part.length > 4
+              end
+            else
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+              return
+            end
+          end
+
+        when 'uri'
+          if data.is_a?(String)
+            error_message = "The property '#{build_fragment(fragments)}' must be a valid URI"
+            begin
+              URI.parse(data)
+            rescue URI::InvalidURIError
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :format })
+            end
+          end
+
+        when 'hostname'
+
+        when 'email'
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+module JSON
+  class Schema
+    class MaxItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        if data.is_a?(Array) && (data.compact.size > current_schema.schema['maxItems'])
+          message = "The property '#{build_fragment(fragments)}' had more items than the allowed #{current_schema.schema['maxItems']}"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors], { property: last_fragment_as_symbol(fragments), failure: :max_items })
+        end
+      end
+    end
+  end
+end