json-schema-openc-fork 0.0.1

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

@@ -0,0 +1,36 @@
+require 'json-schema/attribute'
+
+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 Exception
+              validation_error(processor, error_message, fragments, current_schema, self, options[:record_errors])
+              return
+            end
+
+            begin
+              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
+            rescue Exception
+              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_v4.rb

@@ -0,0 +1,15 @@
+require 'json-schema/attribute'
+
+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/attribute'
+
+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,20 @@
+require 'json-schema/attribute'
+require 'addressable/uri'
+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
+          # 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
+  end
+end

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

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

@@ -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 #{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])
+        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_errors = 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_errors += 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_errors == one_of.length - 1
+          data = success_data
+          return
+        end
+
+        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
+          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]) if message
+        validation_errors(processor).last.sub_errors = errors if message
+      end
+    end
+  end
+end