json-schema-openc-fork 0.0.1

data/lib/json-schema.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+if Gem::Specification::find_all_by_name('multi_json').any?
+  require 'multi_json'
+
+  # Force MultiJson to load an engine before we define the JSON constant here; otherwise,
+  # it looks for things that are under the JSON namespace that aren't there (since we have defined it here)
+  MultiJson.respond_to?(:adapter) ? MultiJson.adapter : MultiJson.engine
+end
+
+require 'json-schema/util/array_set'
+require 'json-schema/util/uri'
+require 'json-schema/schema'
+require 'json-schema/schema/reader'
+require 'json-schema/validator'
+
+Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/*.rb")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), "json-schema/attributes/formats/*.rb")].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__), "json-schema/validators/*.rb")].sort!.each {|file| require file }

data/lib/json-schema/attribute.rb

@@ -0,0 +1,43 @@
+require 'json-schema/errors/validation_error'
+
+module JSON
+  class Schema
+    class Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+      end
+
+      def self.build_fragment(fragments)
+        "#/#{fragments.join('/')}"
+      end
+
+      def self.validation_error(processor, message, fragments, current_schema, failed_attribute, record_errors)
+        error = ValidationError.new(message, fragments, failed_attribute, current_schema)
+        if record_errors
+          processor.validation_error(error)
+        else
+          raise error
+        end
+      end
+
+      def self.validation_errors(validator)
+        validator.validation_errors
+      end
+
+      TYPE_CLASS_MAPPINGS = {
+        "string" => String,
+        "number" => Numeric,
+        "integer" => Integer,
+        "boolean" => [TrueClass, FalseClass],
+        "object" => Hash,
+        "array" => Array,
+        "null" => NilClass,
+        "any" => Object
+      }
+
+      def self.data_valid_for_type?(data, type)
+        valid_classes = TYPE_CLASS_MAPPINGS.fetch(type) { return true }
+        Array(valid_classes).any? { |c| data.is_a?(c) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'json-schema/attribute'
+
+module JSON
+  class Schema
+    class AdditionalItemsAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        return unless data.is_a?(Array)
+
+        schema = current_schema.schema
+        return unless schema['items'].is_a?(Array)
+
+        case schema['additionalItems']
+        when false
+          if schema['items'].length != data.length
+            message = "The property '#{build_fragment(fragments)}' contains additional array elements outside of the schema when none are allowed"
+            validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+          end
+        when Hash
+          additional_items_schema = JSON::Schema.new(schema['additionalItems'], current_schema.uri, validator)
+          data.each_with_index do |item, i|
+            next if i < schema['items'].length
+            additional_items_schema.validate(item, fragments + [i.to_s], processor, options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'json-schema/attribute'
+require 'json-schema/attributes/extends'
+
+module JSON
+  class Schema
+    class AdditionalPropertiesAttribute < Attribute
+      def self.validate(current_schema, data, fragments, processor, validator, options = {})
+        schema = current_schema.schema
+        return unless data.is_a?(Hash) && (schema['type'].nil? || schema['type'] == 'object')
+
+        extra_properties = remove_valid_properties(data.keys, current_schema, validator)
+
+        addprop = schema['additionalProperties']
+        if addprop.is_a?(Hash)
+          matching_properties = extra_properties # & addprop.keys
+          matching_properties.each do |key|
+            additional_property_schema = JSON::Schema.new(addprop[key] || addprop, current_schema.uri, validator)
+            additional_property_schema.validate(data[key], fragments + [key], processor, options)
+          end
+          extra_properties -= matching_properties
+        end
+
+        if extra_properties.any? && (addprop == false || (addprop.is_a?(Hash) && !addprop.empty?))
+          message = "The property '#{build_fragment(fragments)}' contains additional properties #{extra_properties.inspect} outside of the schema when none are allowed"
+          validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+        end
+      end
+
+      def self.remove_valid_properties(extra_properties, current_schema, validator)
+        schema = current_schema.schema
+
+        if schema['properties']
+          extra_properties = extra_properties - schema['properties'].keys
+        end
+
+        if schema['patternProperties']
+          schema['patternProperties'].each_key do |key|
+            regexp = Regexp.new(key)
+            extra_properties.reject! { |prop| regexp.match(prop) }
+          end
+        end
+
+        if extended_schemas = schema['extends']
+          extended_schemas = [extended_schemas] unless extended_schemas.is_a?(Array)
+          extended_schemas.each do |schema_value|
+            _, extended_schema = JSON::Schema::ExtendsAttribute.get_extended_uri_and_schema(schema_value, current_schema, validator)
+            if extended_schema
+              extra_properties = remove_valid_properties(extra_properties, extended_schema, validator)
+            end
+          end
+        end
+
+        extra_properties
+      end
+
+    end
+  end
+end

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 #{data.class} 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 #{data.class} 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,44 @@
+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
+
+    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.new(data.to_s) % BigDecimal.new(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,50 @@
+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
+
+        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,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/attribute'
+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,24 @@
+require 'json-schema/attribute'
+
+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 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