json_schemer 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddb07f2bbccb28d21477a4514b460b385363ff5a3c7d1b981c538408228ae796
-  data.tar.gz: 374a24a40fd3c6714a24be1ef248a79143cb36121d60996017ac4cd2858b5dbb
+  metadata.gz: 8dc3f244ec43815a4207b9be2112cc76afee3cd37b96a3e1eb0fd9b189f8ad72
+  data.tar.gz: 3dcede7d0418d30e98fe75054000657bf03201a1fbf8231810506a2a91de1bbb
 SHA512:
-  metadata.gz: 0e34958d512ef4093d360a9596cd15ec51a90ea30d4b346453379c2d749496b83be9d237e34c332d225302a6fecf5fc156785d3aae4fe2be95f47fa00ee1e1e4
-  data.tar.gz: fa555c0ed341eae0bcd861c4be770eca06e8aa136dfcb4b4d4bad83661b9042dcfdc5dcc76ed5c59b40946cd2930323710153740ef315f32587105f252caa88b
+  metadata.gz: 1ea22d403dd91c7c555d7fe949a25840255a1ed55af658aad703b965b79e063fe2ae5a1d82b3b3ac7a6a56cc32b5720ec0639d734235e934ccaef04f87a11146
+  data.tar.gz: 243e04ef109d923d9de753856943f2269548485de36f476e9d527be132c1f737abcd1ee6e74c6b3263bb95d9b03fcfc0a6f8a11c4249d538baab0d469c97652d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    json_schemer (0.1.5)
+    json_schemer (0.1.6)
       ecma-re-validator (~> 0.1.2)
       hana (~> 1.3.3)
       uri_template (~> 0.7.0)
@@ -27,4 +27,4 @@ DEPENDENCIES
   rake (~> 10.0)
 
 BUNDLED WITH
-   1.16.2
+   1.16.4

data/README.md

@@ -46,6 +46,16 @@ schemer.valid?({ 'abc' => 10 })
 
 schemer.validate({ 'abc' => 10 }).to_a
 # => [{"data"=>10, "schema"=>{"type"=>"integer", "minimum"=>11}, "pointer"=>"#/abc", "type"=>"minimum"}]
+
+# schema files
+
+schema = Pathname.new('/path/to/schema.json')
+schemer = JSONSchemer.schema(schema)
+
+# schema json string
+
+schema = '{ "type": "integer" }'
+schemer = JSONSchemer.schema(schema)
 ```
 
 ## Options

data/lib/json_schemer.rb

@@ -2,6 +2,7 @@
 
 require 'json_schemer/version'
 require 'json_schemer/format'
+require 'json_schemer/cached_ref_resolver'
 require 'json_schemer/schema/base'
 require 'json_schemer/schema/draft4'
 require 'json_schemer/schema/draft6'
@@ -10,6 +11,8 @@ require 'json_schemer/schema/draft7'
 module JSONSchemer
   class UnsupportedMetaSchema < StandardError; end
   class UnknownRef < StandardError; end
+  class InvalidFileURI < StandardError; end
+  class InvalidSymbolKey < StandardError; end
 
   DRAFT_CLASS_BY_META_SCHEMA = {
     'http://json-schema.org/draft-04/schema#' => Schema::Draft4,
@@ -19,9 +22,36 @@ module JSONSchemer
 
   DEFAULT_META_SCHEMA = 'http://json-schema.org/draft-07/schema#'
 
-  def self.schema(schema, **options)
-    meta_schema = schema.is_a?(Hash) && schema.key?('$schema') ? schema['$schema'] : DEFAULT_META_SCHEMA
-    draft_class = DRAFT_CLASS_BY_META_SCHEMA[meta_schema] || raise(UnsupportedMetaSchema, meta_schema)
-    draft_class.new(schema, **options)
+  FILE_URI_REF_RESOLVER = proc do |uri|
+    raise InvalidFileURI, 'must use `file` scheme' unless uri.scheme == 'file'
+    raise InvalidFileURI, 'cannot have a host (use `file:///`)' if uri.host
+    JSON.parse(File.read(uri.path))
+  end
+
+  class << self
+    def schema(schema, **options)
+      case schema
+      when String
+        schema = JSON.parse(schema)
+      when Pathname
+        uri = URI.parse("file://#{schema.realpath}")
+        if options.key?(:ref_resolver)
+          schema = FILE_URI_REF_RESOLVER.call(uri)
+        else
+          ref_resolver = CachedRefResolver.new(&FILE_URI_REF_RESOLVER)
+          schema = ref_resolver.call(uri)
+          options[:ref_resolver] = ref_resolver
+        end
+        schema[draft_class(schema)::ID_KEYWORD] ||= uri.to_s
+      end
+      draft_class(schema).new(schema, **options)
+    end
+
+  private
+
+    def draft_class(schema)
+      meta_schema = schema.is_a?(Hash) && schema.key?('$schema') ? schema['$schema'] : DEFAULT_META_SCHEMA
+      DRAFT_CLASS_BY_META_SCHEMA[meta_schema] || raise(UnsupportedMetaSchema, meta_schema)
+    end
   end
 end

data/lib/json_schemer/cached_ref_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module JSONSchemer
+  class CachedRefResolver
+    def initialize(&ref_resolver)
+      @ref_resolver = ref_resolver
+      @cache = {}
+    end
+
+    def call(uri)
+      @cache[uri] = @ref_resolver.call(uri) unless @cache.key?(uri)
+      @cache[uri]
+    end
+  end
+end

data/lib/json_schemer/schema/base.rb

@@ -12,6 +12,18 @@ module JSONSchemer
     class Base
       include Format
 
+      Instance = Struct.new(:data, :data_pointer, :schema, :schema_pointer, :parent_uri) do
+        def merge(
+          data: self.data,
+          data_pointer: self.data_pointer,
+          schema: self.schema,
+          schema_pointer: self.schema_pointer,
+          parent_uri: self.parent_uri
+        )
+          self.class.new(data, data_pointer, schema, schema_pointer, parent_uri)
+        end
+      end
+
       ID_KEYWORD = '$id'
       DEFAULT_REF_RESOLVER = proc { |uri| raise UnknownRef, uri.to_s }.freeze
       NET_HTTP_REF_RESOLVER = proc { |uri| JSON.parse(Net::HTTP.get(uri)) }.freeze
@@ -24,23 +36,36 @@ module JSONSchemer
         keywords: nil,
         ref_resolver: DEFAULT_REF_RESOLVER
       )
+        raise InvalidSymbolKey, 'schemas must use string keys' if schema.is_a?(Hash) && schema.first.first.is_a?(Symbol)
         @root = schema
         @format = format
         @formats = formats
         @keywords = keywords
-        @ref_resolver = ref_resolver == 'net/http' ? NET_HTTP_REF_RESOLVER : ref_resolver
+        @ref_resolver = ref_resolver == 'net/http' ? CachedRefResolver.new(&NET_HTTP_REF_RESOLVER) : ref_resolver
       end
 
-      def valid?(data, schema = root, pointer = '', parent_uri = nil)
-        validate(data, schema, pointer, parent_uri).none?
+      def valid?(data)
+        valid_instance?(Instance.new(data, '', root, '', nil))
       end
 
-      def validate(data, schema = root, pointer = '', parent_uri = nil)
-        return enum_for(:validate, data, schema, pointer, parent_uri) unless block_given?
+      def validate(data)
+        validate_instance(Instance.new(data, '', root, '', nil))
+      end
+
+    protected
+
+      def valid_instance?(instance)
+        validate_instance(instance).none?
+      end
+
+      def validate_instance(instance)
+        return enum_for(:validate_instance, instance) unless block_given?
+
+        schema = instance.schema
 
         return if schema == true
         if schema == false
-          yield error(data, schema, pointer, 'schema')
+          yield error(instance, 'schema')
           return
         end
 
@@ -59,60 +84,60 @@ module JSONSchemer
         ref = schema['$ref']
         id = schema[id_keyword]
 
-        parent_uri = join_uri(parent_uri, id)
+        instance.parent_uri = join_uri(instance.parent_uri, id)
 
         if ref
-          validate_ref(data, schema, pointer, parent_uri, ref, &Proc.new)
+          validate_ref(instance, ref, &Proc.new)
           return
         end
 
         if format? && custom_format?(format)
-          validate_custom_format(data, schema, pointer, formats.fetch(format), &Proc.new)
+          validate_custom_format(instance, formats.fetch(format), &Proc.new)
         end
 
         if keywords
           keywords.each do |keyword, callable|
             if schema.key?(keyword)
-              result = callable.call(data, schema, pointer)
+              result = callable.call(data, schema, instance.pointer)
               if result.is_a?(Array)
                 result.each { |error| yield error }
               elsif !result
-                yield error(data, schema, pointer, keyword)
+                yield error(instance, keyword)
               end
             end
           end
         end
 
-        yield error(data, schema, pointer, 'enum') if enum && !enum.include?(data)
-        yield error(data, schema, pointer, 'const') if schema.key?('const') && schema['const'] != data
+        data = instance.data
+
+        yield error(instance, 'enum') if enum && !enum.include?(data)
+        yield error(instance, 'const') if schema.key?('const') && schema['const'] != data
 
-        yield error(data, schema, pointer, 'allOf') if all_of && !all_of.all? { |subschema| valid?(data, subschema, pointer, parent_uri) }
-        yield error(data, schema, pointer, 'anyOf') if any_of && !any_of.any? { |subschema| valid?(data, subschema, pointer, parent_uri) }
-        yield error(data, schema, pointer, 'oneOf') if one_of && !one_of.one? { |subschema| valid?(data, subschema, pointer, parent_uri) }
-        yield error(data, schema, pointer, 'not') if !not_schema.nil? && valid?(data, not_schema, pointer, parent_uri)
+        yield error(instance, 'allOf') if all_of && !all_of.all? { |subschema| valid_instance?(instance.merge(schema: subschema)) }
+        yield error(instance, 'anyOf') if any_of && !any_of.any? { |subschema| valid_instance?(instance.merge(schema: subschema)) }
+        yield error(instance, 'oneOf') if one_of && !one_of.one? { |subschema| valid_instance?(instance.merge(schema: subschema)) }
+        yield error(instance, 'not') if !not_schema.nil? && valid_instance?(instance.merge(schema: not_schema))
 
-        if if_schema && valid?(data, if_schema, pointer, parent_uri)
-          yield error(data, schema, pointer, 'then') if !then_schema.nil? && !valid?(data, then_schema, pointer, parent_uri)
+        if if_schema && valid_instance?(instance.merge(schema: if_schema))
+          yield error(instance, 'then') if !then_schema.nil? && !valid_instance?(instance.merge(schema: then_schema))
         elsif if_schema
-          yield error(data, schema, pointer, 'else') if !else_schema.nil? && !valid?(data, else_schema, pointer, parent_uri)
+          yield error(instance, 'else') if !else_schema.nil? && !valid_instance?(instance.merge(schema: else_schema))
         end
 
         case type
         when nil
-          validate_class(data, schema, pointer, parent_uri, &Proc.new)
+          validate_class(instance, &Proc.new)
         when String
-          validate_type(data, schema, pointer, parent_uri, type, &Proc.new)
+          validate_type(instance, type, &Proc.new)
         when Array
-          if valid_type = type.find { |subtype| valid?(data, { 'type' => subtype }, pointer, parent_uri) }
-            validate_type(data, schema, pointer, parent_uri, valid_type, &Proc.new)
+          if valid_type = type.find { |subtype| valid_instance?(instance.merge(schema: { 'type' => subtype })) }
+            validate_type(instance, valid_type, &Proc.new)
           else
-            yield error(data, schema, pointer, 'type')
+            yield error(instance, 'type')
           end
         end
       end
 
-    protected
-
       def ids
         @ids ||= resolve_ids(root)
       end
@@ -147,125 +172,157 @@ module JSONSchemer
         )
       end
 
-      def error(data, schema, pointer, type)
+      def error(instance, type)
         {
-          'data' => data,
-          'schema' => schema,
-          'pointer' => pointer,
+          'data' => instance.data,
+          'data_pointer' => instance.data_pointer,
+          'schema' => instance.schema,
+          'schema_pointer' => instance.schema_pointer,
+          'root_schema' => root,
           'type' => type,
         }
       end
 
-      def validate_class(data, schema, pointer, parent_uri)
-        case data
+      def validate_class(instance)
+        case instance.data
         when Integer
-          validate_integer(data, schema, pointer, &Proc.new)
+          validate_integer(instance, &Proc.new)
         when Numeric
-          validate_number(data, schema, pointer, &Proc.new)
+          validate_number(instance, &Proc.new)
         when String
-          validate_string(data, schema, pointer, &Proc.new)
+          validate_string(instance, &Proc.new)
         when Array
-          validate_array(data, schema, pointer, parent_uri, &Proc.new)
+          validate_array(instance, &Proc.new)
         when Hash
-          validate_object(data, schema, pointer, parent_uri, &Proc.new)
+          validate_object(instance, &Proc.new)
         end
       end
 
-      def validate_type(data, schema, pointer, parent_uri, type)
+      def validate_type(instance, type)
         case type
         when 'null'
-          yield error(data, schema, pointer, 'null') unless data.nil?
+          yield error(instance, 'null') unless instance.data.nil?
         when 'boolean'
-          yield error(data, schema, pointer, 'boolean') unless BOOLEANS.include?(data)
+          yield error(instance, 'boolean') unless BOOLEANS.include?(instance.data)
         when 'number'
-          validate_number(data, schema, pointer, &Proc.new)
+          validate_number(instance, &Proc.new)
         when 'integer'
-          validate_integer(data, schema, pointer, &Proc.new)
+          validate_integer(instance, &Proc.new)
         when 'string'
-          validate_string(data, schema, pointer, &Proc.new)
+          validate_string(instance, &Proc.new)
         when 'array'
-          validate_array(data, schema, pointer, parent_uri, &Proc.new)
+          validate_array(instance, &Proc.new)
         when 'object'
-          validate_object(data, schema, pointer, parent_uri, &Proc.new)
+          validate_object(instance, &Proc.new)
         end
       end
 
-      def validate_ref(data, schema, pointer, parent_uri, ref)
-        ref_uri = join_uri(parent_uri, ref)
+      def validate_ref(instance, ref)
+        ref_uri = join_uri(instance.parent_uri, ref)
 
         if valid_json_pointer?(ref_uri.fragment)
-          ref_pointer = Hana::Pointer.new(URI.unescape(ref_uri.fragment || ''))
+          ref_pointer = Hana::Pointer.new(URI.unescape(ref_uri.fragment))
           if ref.start_with?('#')
-            validate(data, ref_pointer.eval(root), pointer, pointer_uri(root, ref_pointer), &Proc.new)
+            subinstance = instance.merge(
+              schema: ref_pointer.eval(root),
+              schema_pointer: ref_uri.fragment,
+              parent_uri: pointer_uri(root, ref_pointer)
+            )
+            validate_instance(subinstance, &Proc.new)
           else
             ref_root = ref_resolver.call(ref_uri)
             ref_object = child(ref_root)
-            ref_object.validate(data, ref_pointer.eval(ref_root), pointer, pointer_uri(ref_root, ref_pointer), &Proc.new)
+            subinstance = instance.merge(
+              schema: ref_pointer.eval(ref_root),
+              schema_pointer: ref_uri.fragment,
+              parent_uri: pointer_uri(ref_root, ref_pointer)
+            )
+            ref_object.validate_instance(subinstance, &Proc.new)
           end
-        elsif ids.key?(ref_uri.to_s)
-          validate(data, ids.fetch(ref_uri.to_s), pointer, ref_uri, &Proc.new)
+        elsif id = ids[ref_uri.to_s]
+          subinstance = instance.merge(
+            schema: id.fetch(:schema),
+            schema_pointer: id.fetch(:pointer),
+            parent_uri: ref_uri
+          )
+          validate_instance(subinstance, &Proc.new)
         else
           ref_root = ref_resolver.call(ref_uri)
           ref_object = child(ref_root)
-          ref_object.validate(data, ref_object.ids.fetch(ref_uri.to_s, ref_root), pointer, ref_uri, &Proc.new)
+          id = ref_object.ids[ref_uri.to_s] || { schema: ref_root, pointer: '' }
+          subinstance = instance.merge(
+            schema: id.fetch(:schema),
+            schema_pointer: id.fetch(:pointer),
+            parent_uri: ref_uri
+          )
+          ref_object.validate_instance(subinstance, &Proc.new)
         end
       end
 
-      def validate_custom_format(data, schema, pointer, custom_format)
-        yield error(data, schema, pointer, 'format') if custom_format != false && !custom_format.call(data, schema)
+      def validate_custom_format(instance, custom_format)
+        yield error(instance, 'format') if custom_format != false && !custom_format.call(instance.data, instance.schema)
       end
 
-      def validate_exclusive_maximum(data, schema, pointer, exclusive_maximum, maximum)
-        yield error(data, schema, pointer, 'exclusiveMaximum') if data >= exclusive_maximum
+      def validate_exclusive_maximum(instance, exclusive_maximum, maximum)
+        yield error(instance, 'exclusiveMaximum') if instance.data >= exclusive_maximum
       end
 
-      def validate_exclusive_minimum(data, schema, pointer, exclusive_minimum, minimum)
-        yield error(data, schema, pointer, 'exclusiveMinimum') if data <= exclusive_minimum
+      def validate_exclusive_minimum(instance, exclusive_minimum, minimum)
+        yield error(instance, 'exclusiveMinimum') if instance.data <= exclusive_minimum
       end
 
-      def validate_numeric(data, schema, pointer)
+      def validate_numeric(instance)
+        schema = instance.schema
+        data = instance.data
+
         multiple_of = schema['multipleOf']
         maximum = schema['maximum']
         exclusive_maximum = schema['exclusiveMaximum']
         minimum = schema['minimum']
         exclusive_minimum = schema['exclusiveMinimum']
 
-        yield error(data, schema, pointer, 'maximum') if maximum && data > maximum
-        yield error(data, schema, pointer, 'minimum') if minimum && data < minimum
+        yield error(instance, 'maximum') if maximum && data > maximum
+        yield error(instance, 'minimum') if minimum && data < minimum
 
-        validate_exclusive_maximum(data, schema, pointer, exclusive_maximum, maximum, &Proc.new) if exclusive_maximum
-        validate_exclusive_minimum(data, schema, pointer, exclusive_minimum, minimum, &Proc.new) if exclusive_minimum
+        validate_exclusive_maximum(instance, exclusive_maximum, maximum, &Proc.new) if exclusive_maximum
+        validate_exclusive_minimum(instance, exclusive_minimum, minimum, &Proc.new) if exclusive_minimum
 
         if multiple_of
           quotient = data / multiple_of.to_f
-          yield error(data, schema, pointer, 'multipleOf') unless quotient.floor == quotient
+          yield error(instance, 'multipleOf') unless quotient.floor == quotient
         end
       end
 
-      def validate_number(data, schema, pointer)
-        unless data.is_a?(Numeric)
-          yield error(data, schema, pointer, 'number')
+      def validate_number(instance)
+        unless instance.data.is_a?(Numeric)
+          yield error(instance, 'number')
           return
         end
 
-        validate_numeric(data, schema, pointer, &Proc.new)
+        validate_numeric(instance, &Proc.new)
       end
 
-      def validate_integer(data, schema, pointer)
+      def validate_integer(instance)
+        data = instance.data
+
         if !data.is_a?(Numeric) || (!data.is_a?(Integer) && data.floor != data)
-          yield error(data, schema, pointer, 'integer')
+          yield error(instance, 'integer')
           return
         end
 
-        validate_numeric(data, schema, pointer, &Proc.new)
+        validate_numeric(instance, &Proc.new)
       end
 
-      def validate_string(data, schema, pointer)
+      def validate_string(instance)
+        data = instance.data
+
         unless data.is_a?(String)
-          yield error(data, schema, pointer, 'string')
+          yield error(instance, 'string')
           return
         end
 
+        schema = instance.schema
+
         max_length = schema['maxLength']
         min_length = schema['minLength']
         pattern = schema['pattern']
@@ -273,10 +330,10 @@ module JSONSchemer
         content_encoding = schema['contentEncoding']
         content_media_type = schema['contentMediaType']
 
-        yield error(data, schema, pointer, 'maxLength') if max_length && data.size > max_length
-        yield error(data, schema, pointer, 'minLength') if min_length && data.size < min_length
-        yield error(data, schema, pointer, 'pattern') if pattern && Regexp.new(pattern) !~ data
-        yield error(data, schema, pointer, 'format') if format? && spec_format?(format) && !valid_spec_format?(data, format)
+        yield error(instance, 'maxLength') if max_length && data.size > max_length
+        yield error(instance, 'minLength') if min_length && data.size < min_length
+        yield error(instance, 'pattern') if pattern && Regexp.new(pattern) !~ data
+        yield error(instance, 'format') if format? && spec_format?(format) && !valid_spec_format?(data, format)
 
         if content_encoding || content_media_type
           decoded_data = data
@@ -288,13 +345,13 @@ module JSONSchemer
             else # '7bit', '8bit', 'binary', 'quoted-printable'
               raise NotImplementedError
             end
-            yield error(data, schema, pointer, 'contentEncoding') unless decoded_data
+            yield error(instance, 'contentEncoding') unless decoded_data
           end
 
           if content_media_type && decoded_data
             case content_media_type.downcase
             when 'application/json'
-              yield error(data, schema, pointer, 'contentMediaType') unless valid_json?(decoded_data)
+              yield error(instance, 'contentMediaType') unless valid_json?(decoded_data)
             else
               raise NotImplementedError
             end
@@ -302,12 +359,16 @@ module JSONSchemer
         end
       end
 
-      def validate_array(data, schema, pointer, parent_uri, &block)
+      def validate_array(instance, &block)
+        data = instance.data
+
         unless data.is_a?(Array)
-          yield error(data, schema, pointer, 'array')
+          yield error(instance, 'array')
           return
         end
 
+        schema = instance.schema
+
         items = schema['items']
         additional_items = schema['additionalItems']
         max_items = schema['maxItems']
@@ -315,34 +376,56 @@ module JSONSchemer
         unique_items = schema['uniqueItems']
         contains = schema['contains']
 
-        yield error(data, schema, pointer, 'maxItems') if max_items && data.size > max_items
-        yield error(data, schema, pointer, 'minItems') if min_items && data.size < min_items
-        yield error(data, schema, pointer, 'uniqueItems') if unique_items && data.size != data.uniq.size
-        yield error(data, schema, pointer, 'contains') if !contains.nil? && data.all? { |item| !valid?(item, contains, pointer, parent_uri) }
+        yield error(instance, 'maxItems') if max_items && data.size > max_items
+        yield error(instance, 'minItems') if min_items && data.size < min_items
+        yield error(instance, 'uniqueItems') if unique_items && data.size != data.uniq.size
+        yield error(instance, 'contains') if !contains.nil? && data.all? { |item| !valid_instance?(instance.merge(data: item, schema: contains)) }
 
         if items.is_a?(Array)
           data.each_with_index do |item, index|
             if index < items.size
-              validate(item, items[index], "#{pointer}/#{index}", parent_uri, &block)
+              subinstance = instance.merge(
+                data: item,
+                data_pointer: "#{instance.data_pointer}/#{index}",
+                schema: items[index],
+                schema_pointer: "#{instance.schema_pointer}/items/#{index}"
+              )
+              validate_instance(subinstance, &block)
             elsif !additional_items.nil?
-              validate(item, additional_items, "#{pointer}/#{index}", parent_uri, &block)
+              subinstance = instance.merge(
+                data: item,
+                data_pointer: "#{instance.data_pointer}/#{index}",
+                schema: additional_items,
+                schema_pointer: "#{instance.schema_pointer}/additionalItems"
+              )
+              validate_instance(subinstance, &block)
             else
               break
             end
           end
         elsif !items.nil?
           data.each_with_index do |item, index|
-            validate(item, items, "#{pointer}/#{index}", parent_uri, &block)
+            subinstance = instance.merge(
+              data: item,
+              data_pointer: "#{instance.data_pointer}/#{index}",
+              schema: items,
+              schema_pointer: "#{instance.schema_pointer}/items"
+            )
+            validate_instance(subinstance, &block)
           end
         end
       end
 
-      def validate_object(data, schema, pointer, parent_uri, &block)
+      def validate_object(instance, &block)
+        data = instance.data
+
         unless data.is_a?(Hash)
-          yield error(data, schema, pointer, 'object')
+          yield error(instance, 'object')
           return
         end
 
+        schema = instance.schema
+
         max_properties = schema['maxProperties']
         min_properties = schema['minProperties']
         required = schema['required']
@@ -356,32 +439,52 @@ module JSONSchemer
           dependencies.each do |key, value|
             next unless data.key?(key)
             subschema = value.is_a?(Array) ? { 'required' => value } : value
-            validate(data, subschema, pointer, parent_uri, &block)
+            subinstance = instance.merge(schema: subschema, schema_pointer: "#{instance.schema_pointer}/dependencies/#{key}")
+            validate_instance(subinstance, &block)
           end
         end
 
-        yield error(data, schema, pointer, 'maxProperties') if max_properties && data.size > max_properties
-        yield error(data, schema, pointer, 'minProperties') if min_properties && data.size < min_properties
-        yield error(data, schema, pointer, 'required') if required && required.any? { |key| !data.key?(key) }
+        yield error(instance, 'maxProperties') if max_properties && data.size > max_properties
+        yield error(instance, 'minProperties') if min_properties && data.size < min_properties
+        yield error(instance, 'required') if required && required.any? { |key| !data.key?(key) }
 
         regex_pattern_properties = nil
         data.each do |key, value|
-          validate(key, property_names, pointer, parent_uri, &block) unless property_names.nil?
+          unless property_names.nil?
+            subinstance = instance.merge(
+              data: key,
+              schema: property_names,
+              schema_pointer: "#{instance.schema_pointer}/propertyNames"
+            )
+            validate_instance(subinstance, &block)
+          end
 
           matched_key = false
 
           if properties && properties.key?(key)
-            validate(value, properties[key], "#{pointer}/#{key}", parent_uri, &block)
+            subinstance = instance.merge(
+              data: value,
+              data_pointer: "#{instance.data_pointer}/#{key}",
+              schema: properties[key],
+              schema_pointer: "#{instance.schema_pointer}/properties/#{key}"
+            )
+            validate_instance(subinstance, &block)
             matched_key = true
           end
 
           if pattern_properties
             regex_pattern_properties ||= pattern_properties.map do |pattern, property_schema|
-              [Regexp.new(pattern), property_schema]
+              [pattern, Regexp.new(pattern), property_schema]
             end
-            regex_pattern_properties.each do |regex, property_schema|
+            regex_pattern_properties.each do |pattern, regex, property_schema|
               if regex =~ key
-                validate(value, property_schema, "#{pointer}/#{key}", parent_uri, &block)
+                subinstance = instance.merge(
+                  data: value,
+                  data_pointer: "#{instance.data_pointer}/#{key}",
+                  schema: property_schema,
+                  schema_pointer: "#{instance.schema_pointer}/patternProperties/#{pattern}"
+                )
+                validate_instance(subinstance, &block)
                 matched_key = true
               end
             end
@@ -389,7 +492,15 @@ module JSONSchemer
 
           next if matched_key
 
-          validate(value, additional_properties, "#{pointer}/#{key}", parent_uri, &block) unless additional_properties.nil?
+          unless additional_properties.nil?
+            subinstance = instance.merge(
+              data: value,
+              data_pointer: "#{instance.data_pointer}/#{key}",
+              schema: additional_properties,
+              schema_pointer: "#{instance.schema_pointer}/additionalProperties"
+            )
+            validate_instance(subinstance, &block)
+          end
         end
       end
 
@@ -425,15 +536,20 @@ module JSONSchemer
         uri_parts ? URI.join(*uri_parts) : nil
       end
 
-      def resolve_ids(schema, ids = {}, parent_uri = nil)
+      def resolve_ids(schema, ids = {}, parent_uri = nil, pointer = '')
         if schema.is_a?(Array)
-          schema.each { |subschema| resolve_ids(subschema, ids, parent_uri) }
+          schema.each_with_index { |subschema, index| resolve_ids(subschema, ids, parent_uri, "#{pointer}/#{index}") }
         elsif schema.is_a?(Hash)
           id = schema[id_keyword]
           uri = join_uri(parent_uri, id)
-          ids[uri.to_s] = schema unless uri == parent_uri
+          unless uri == parent_uri
+            ids[uri.to_s] = {
+              schema: schema,
+              pointer: pointer
+            }
+          end
           if definitions = schema['definitions']
-            definitions.each_value { |subschema| resolve_ids(subschema, ids, uri) }
+            definitions.each { |key, subschema| resolve_ids(subschema, ids, uri, "#{pointer}/definitions/#{key}") }
           end
         end
         ids

data/lib/json_schemer/schema/draft4.rb

@@ -24,21 +24,21 @@ module JSONSchemer
         SUPPORTED_FORMATS.include?(format)
       end
 
-      def validate_exclusive_maximum(data, schema, pointer, exclusive_maximum, maximum)
-        yield error(data, schema, pointer, 'exclusiveMaximum') if exclusive_maximum && data >= maximum
+      def validate_exclusive_maximum(instance, exclusive_maximum, maximum)
+        yield error(instance, 'exclusiveMaximum') if exclusive_maximum && instance.data >= maximum
       end
 
-      def validate_exclusive_minimum(data, schema, pointer, exclusive_minimum, minimum)
-        yield error(data, schema, pointer, 'exclusiveMinimum') if exclusive_minimum && data <= minimum
+      def validate_exclusive_minimum(instance, exclusive_minimum, minimum)
+        yield error(instance, 'exclusiveMinimum') if exclusive_minimum && instance.data <= minimum
       end
 
-      def validate_integer(data, schema, pointer)
-        if !data.is_a?(Integer)
-          yield error(data, schema, pointer, 'integer')
+      def validate_integer(instance)
+        if !instance.data.is_a?(Integer)
+          yield error(instance, 'integer')
           return
         end
 
-        validate_numeric(data, schema, pointer, &Proc.new)
+        validate_numeric(instance, &Proc.new)
       end
     end
   end

data/lib/json_schemer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONSchemer
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schemer
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - David Harsha
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-23 00:00:00.000000000 Z
+date: 2018-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - bin/setup
 - json_schemer.gemspec
 - lib/json_schemer.rb
+- lib/json_schemer/cached_ref_resolver.rb
 - lib/json_schemer/format.rb
 - lib/json_schemer/schema/base.rb
 - lib/json_schemer/schema/draft4.rb
@@ -139,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: JSON Schema validator. Supports drafts 4, 6, and 7.