json-schema-openc-fork 0.0.1

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,74 @@
+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['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 = data.to_a.map { |(key, _)| key }.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
+
+    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/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/ref.rb

@@ -0,0 +1,74 @@
+require 'json-schema/attribute'
+require 'json-schema/errors/schema_error'
+
+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 = Addressable::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.join(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.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 = temp_uri.fragment.split("/")
+          fragment_path = ''
+          fragments.each do |fragment|
+            if fragment && fragment != ''
+              fragment = Addressable::URI.unescape(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,83 @@
+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
+
+      # Lookup Schema type of given class instance
+      def self.type_of_data(data)
+        type, _ = TYPE_CLASS_MAPPINGS.map { |k,v| [k,v] }.sort_by { |(_, v)|
+          -Array(v).map { |klass| klass.ancestors.size }.max
+        }.find { |(_, v)|
+          Array(v).any? { |klass| data.kind_of?(klass) }
+        }
+        type
+      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),
+          data.class,
+          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,16 @@
+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
+    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_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/validation_error.rb

@@ -0,0 +1,46 @@
+module JSON
+  class Schema
+    class ValidationError < StandardError
+      INDENT = "    "
+      attr_accessor :fragments, :schema, :failed_attribute, :sub_errors, :message
+
+      def initialize(message, fragments, failed_attribute, schema)
+        @fragments = fragments.clone
+        @schema = schema
+        @sub_errors = {}
+        @failed_attribute = failed_attribute
+        @message = message
+        super(message_with_schema)
+      end
+
+      def to_string(subschema_level = 0)
+        if @sub_errors.empty?
+          subschema_level == 0 ? message_with_schema : message
+        else
+          messages = ["#{message}. The schema specific errors were:\n"]
+          @sub_errors.each do |subschema, errors|
+            messages.push "- #{subschema}:"
+            messages.concat Array(errors).map { |e| "#{INDENT}- #{e.to_string(subschema_level + 1)}" }
+          end
+          messages.map { |m| (INDENT * subschema_level) + m }.join("\n")
+        end
+      end
+
+      def to_hash
+        base = {:schema => @schema.uri, :fragment => ::JSON::Schema::Attribute.build_fragment(fragments), :message => message_with_schema, :failed_attribute => @failed_attribute.to_s.split(":").last.split("Attribute").first}
+        if !@sub_errors.empty?
+          base[:errors] = @sub_errors.inject({}) do |hsh, (subschema, errors)|
+            subschema_sym = subschema.downcase.gsub(/\W+/, '_').to_sym
+            hsh[subschema_sym] = Array(errors).map{|e| e.to_hash}
+            hsh
+          end
+        end
+        base
+      end
+
+      def message_with_schema
+        "#{message} in schema #{schema.uri}"
+      end
+    end
+  end
+end