jsi 0.6.0 → 0.7.0

data/lib/jsi/metaschema_node.rb

@@ -25,27 +25,31 @@ module JSI
 
     # @param jsi_document the document containing the metaschema
     # @param jsi_ptr [JSI::Ptr] ptr to this MetaschemaNode in jsi_document
-    # @param metaschema_instance_modules [Enumerable<Module>] modules which implement the functionality of the
-    #   schema, to be applied to every schema which is an instance of the metaschema. this must include
-    #   JSI::Schema directly or indirectly. these are the {Schema#jsi_schema_instance_modules} of the
-    #   metaschema.
+    # @param schema_implementation_modules [Enumerable<Module>] modules which implement the functionality
+    #   of the schema. these are included on the {Schema#jsi_schema_module} of the metaschema.
+    #   they extend any schema described by the metaschema, including those in the document containing
+    #   the metaschema, and the metaschema itself.
+    #   see {Schema#describes_schema!} param `schema_implementation_modules`.
     # @param metaschema_root_ptr [JSI::Ptr] ptr to the root of the metaschema in the jsi_document
     # @param root_schema_ptr [JSI::Ptr] ptr to the schema describing the root of the jsi_document
     def initialize(
         jsi_document,
         jsi_ptr: Ptr[],
-        metaschema_instance_modules: ,
+        schema_implementation_modules: ,
         metaschema_root_ptr: Ptr[],
         root_schema_ptr: Ptr[],
-        jsi_schema_base_uri: nil
+        jsi_schema_base_uri: nil,
+        jsi_root_node: nil
     )
       jsi_initialize_memos
 
       self.jsi_document = jsi_document
       self.jsi_ptr = jsi_ptr
-      @metaschema_instance_modules = Util.ensure_module_set(metaschema_instance_modules)
+      @schema_implementation_modules = Util.ensure_module_set(schema_implementation_modules)
       @metaschema_root_ptr = metaschema_root_ptr
       @root_schema_ptr = root_schema_ptr
+      raise(Bug, 'jsi_root_node') if jsi_ptr.root? ^ !jsi_root_node
+      @jsi_root_node = jsi_ptr.root? ? self : jsi_root_node
 
       if jsi_ptr.root? && jsi_schema_base_uri
         raise(NotImplementedError, "unsupported jsi_schema_base_uri on metaschema document root")
@@ -55,57 +59,58 @@ module JSI
       jsi_node_content = self.jsi_node_content
 
       if jsi_node_content.respond_to?(:to_hash)
-        extend PathedHashNode
+        extend HashNode
       end
       if jsi_node_content.respond_to?(:to_ary)
-        extend PathedArrayNode
+        extend ArrayNode
       end
 
       instance_for_schemas = jsi_document
-      bootstrap_schema_class = JSI::SchemaClasses.bootstrap_schema_class(metaschema_instance_modules)
+      bootstrap_schema_class = JSI::SchemaClasses.bootstrap_schema_class(schema_implementation_modules)
       root_bootstrap_schema = bootstrap_schema_class.new(
         jsi_document,
         jsi_ptr: root_schema_ptr,
         jsi_schema_base_uri: nil, # supplying jsi_schema_base_uri on root bootstrap schema is not supported
       )
       our_bootstrap_schemas = jsi_ptr.tokens.inject(SchemaSet[root_bootstrap_schema]) do |bootstrap_schemas, tok|
-        child_instance_for_schemas = instance_for_schemas[tok]
-        bootstrap_schemas_for_instance = SchemaSet.build do |schemas|
-          bootstrap_schemas.each do |bootstrap_schema|
-            bootstrap_schema.each_child_applicator_schema(tok, instance_for_schemas) do |child_app_schema|
-              child_app_schema.each_inplace_applicator_schema(child_instance_for_schemas) do |child_inpl_app_schema|
-                schemas << child_inpl_app_schema
-              end
-            end
-          end
-        end
-        instance_for_schemas = child_instance_for_schemas
-        bootstrap_schemas_for_instance
+        child_indicated_schemas = bootstrap_schemas.child_applicator_schemas(tok, instance_for_schemas)
+        child_schemas = child_indicated_schemas.inplace_applicator_schemas(instance_for_schemas[tok])
+        instance_for_schemas = instance_for_schemas[tok]
+        child_schemas
       end
 
       our_bootstrap_schemas.each do |bootstrap_schema|
         if bootstrap_schema.jsi_ptr == metaschema_root_ptr
-          metaschema_instance_modules.each do |metaschema_instance_module|
-            extend metaschema_instance_module
+          # this is described by the metaschema, i.e. this is a schema
+          schema_implementation_modules.each do |schema_implementation_module|
+            extend schema_implementation_module
           end
         end
         if bootstrap_schema.jsi_ptr == jsi_ptr
+          # this is the metaschema (it is described by itself)
           extend Metaschema
-          self.jsi_schema_instance_modules = metaschema_instance_modules
         end
       end
 
       @jsi_schemas = SchemaSet.new(our_bootstrap_schemas) do |bootstrap_schema|
         if bootstrap_schema.jsi_ptr == jsi_ptr
           self
+        elsif bootstrap_schema.jsi_ptr.root?
+          @jsi_root_node
         else
           new_node(
             jsi_ptr: bootstrap_schema.jsi_ptr,
             jsi_schema_base_uri: bootstrap_schema.jsi_schema_base_uri,
+            jsi_root_node: @jsi_root_node,
           )
         end
       end
 
+      # note: jsi_schemas must already be set for jsi_schema_module to be used/extended
+      if is_a?(Metaschema)
+        describes_schema!(schema_implementation_modules)
+      end
+
       @jsi_schemas.each do |schema|
         extend schema.jsi_schema_module
       end
@@ -114,19 +119,19 @@ module JSI
       begin # draft 4 boolean schema workaround
         # in draft 4, boolean schemas are not described in the root, but on anyOf schemas on
         # properties/additionalProperties and properties/additionalItems.
-        # since these describe schemas, their jsi_schema_instance_modules are the metaschema_instance_modules.
+        # these still describe schemas, despite not being described by the metaschema.
         addtlPropsanyOf = metaschema_root_ptr["properties"]["additionalProperties"]["anyOf"]
         addtlItemsanyOf = metaschema_root_ptr["properties"]["additionalItems"]["anyOf"]
 
         if !jsi_ptr.root? && [addtlPropsanyOf, addtlItemsanyOf].include?(jsi_ptr.parent)
-          self.jsi_schema_instance_modules = metaschema_instance_modules
+          describes_schema!(schema_implementation_modules)
         end
       end
     end
 
     # Set of modules to apply to schemas which are instances of (described by) the metaschema
     # @return [Set<Module>]
-    attr_reader :metaschema_instance_modules
+    attr_reader :schema_implementation_modules
 
     # ptr to the root of the metaschema in the jsi_document
     # @return [JSI::Ptr]
@@ -140,25 +145,6 @@ module JSI
     # @return [JSI::SchemaSet]
     attr_reader :jsi_schemas
 
-    # document root MetaschemaNode
-    # @return [MetaschemaNode]
-    def jsi_root_node
-      if jsi_ptr.root?
-        self
-      else
-        new_node(
-          jsi_ptr: Ptr[],
-          jsi_schema_base_uri: nil,
-        )
-      end
-    end
-
-    # parent MetaschemaNode
-    # @return [MetaschemaNode]
-    def jsi_parent_node
-      jsi_ptr.parent.evaluate(jsi_root_node)
-    end
-
     # subscripts to return a child value identified by the given token.
     #
     # @param token (see JSI::Base#[])
@@ -177,7 +163,7 @@ module JSI
 
       begin
         if token_in_range
-          value_node = jsi_subinstance_memos[token]
+          value_node = jsi_subinstance_memos[token: token]
 
           jsi_subinstance_as_jsi(value, value_node.jsi_schemas, as_jsi) do
             value_node
@@ -194,7 +180,15 @@ module JSI
     #   in a (nondestructively) modified copy of this.
     # @return [MetaschemaNode] modified copy of self
     def jsi_modified_copy(&block)
-      MetaschemaNode.new(jsi_ptr.modified_document_copy(jsi_document, &block), **our_initialize_params)
+      if jsi_ptr.root?
+        modified_document = jsi_ptr.modified_document_copy(jsi_document, &block)
+        MetaschemaNode.new(modified_document, **our_initialize_params)
+      else
+        modified_jsi_root_node = jsi_root_node.jsi_modified_copy do |root|
+          jsi_ptr.modified_document_copy(root, &block)
+        end
+        modified_jsi_root_node.jsi_descendent_node(jsi_ptr)
+      end
     end
 
     # @private
@@ -219,25 +213,28 @@ module JSI
 
     private
 
+    # note: does not include jsi_root_node
     def our_initialize_params
       {
         jsi_ptr: jsi_ptr,
-        metaschema_instance_modules: metaschema_instance_modules,
+        schema_implementation_modules: schema_implementation_modules,
         metaschema_root_ptr: metaschema_root_ptr,
         root_schema_ptr: root_schema_ptr,
         jsi_schema_base_uri: jsi_schema_base_uri,
       }
     end
 
+    # note: not for root node
     def new_node(params)
       MetaschemaNode.new(jsi_document, **our_initialize_params.merge(params))
     end
 
     def jsi_subinstance_memos
-      jsi_memomap(:subinstance) do |token|
+      jsi_memomap(:subinstance) do |token: |
         new_node(
           jsi_ptr: jsi_ptr[token],
           jsi_schema_base_uri: jsi_resource_ancestor_uri,
+          jsi_root_node: jsi_root_node,
         )
       end
     end

data/lib/jsi/ptr.rb

@@ -31,7 +31,7 @@ module JSI
       #
       #     JSI::Ptr[]
       #
-      # instantes a root pointer.
+      # instantiates a root pointer.
       #
       #     JSI::Ptr['a', 'b']
       #     JSI::Ptr['a']['b']
@@ -99,9 +99,6 @@ module JSI
 
       attr_reader :tokens
 
-      # @private @deprecated
-      alias_method :reference_tokens, :tokens
-
       # takes a root json document and evaluates this pointer through the document, returning the value
       # pointed to by this pointer.
       #
@@ -109,9 +106,9 @@ module JSI
       # @param a arguments are passed to each invocation of `#[]`
       # @return [Object] the content of the document pointed to by this pointer
       # @raise [JSI::Ptr::ResolutionError] the document does not contain the path this pointer references
-      def evaluate(document, *a)
+      def evaluate(document, *a, **kw)
         res = tokens.inject(document) do |value, token|
-          _, child = node_subscript_token_child(value, token, *a)
+          _, child = node_subscript_token_child(value, token, *a, **kw)
           child
         end
         res
@@ -151,28 +148,30 @@ module JSI
       def parent
         if root?
           raise(Ptr::Error, "cannot access parent of root pointer: #{pretty_inspect.chomp}")
-        else
-          Ptr.new(tokens[0...-1])
         end
+        Ptr.new(tokens[0...-1])
       end
 
       # whether this pointer contains the other_ptr - that is, whether this pointer is an ancestor
-      # of `other_ptr`, a child pointer. `contains?` is inclusive; a pointer does contain itself.
+      # of `other_ptr`, a descendent pointer. `contains?` is inclusive; a pointer does contain itself.
       # @return [Boolean]
       def contains?(other_ptr)
-        self.tokens == other_ptr.tokens[0...self.tokens.size]
+        tokens == other_ptr.tokens[0...tokens.size]
       end
 
       # part of this pointer relative to the given ancestor_ptr
       # @return [JSI::Ptr]
       # @raise [JSI::Ptr::Error] if the given ancestor_ptr is not an ancestor of this pointer
-      def ptr_relative_to(ancestor_ptr)
+      def relative_to(ancestor_ptr)
         unless ancestor_ptr.contains?(self)
           raise(Error, "ancestor_ptr #{ancestor_ptr.inspect} is not ancestor of #{inspect}")
         end
         Ptr.new(tokens[ancestor_ptr.tokens.size..-1])
       end
 
+      # @deprecated after v0.6
+      alias_method :ptr_relative_to, :relative_to
+
       # a pointer with the tokens of this one plus the given `ptr`'s.
       # @param ptr [JSI::Ptr, #to_ary]
       # @return [JSI::Ptr]
@@ -182,9 +181,9 @@ module JSI
         elsif ptr.respond_to?(:to_ary)
           ptr_tokens = ptr
         else
-          raise(TypeError, "ptr must be a JSI::Ptr or Array of tokens; got: #{ptr.inspect}")
+          raise(TypeError, "ptr must be a #{Ptr} or Array of tokens; got: #{ptr.inspect}")
         end
-        Ptr.new(self.tokens + ptr_tokens)
+        Ptr.new(tokens + ptr_tokens)
       end
 
       # a pointer consisting of the first `n` of our tokens
@@ -225,7 +224,7 @@ module JSI
         # or hash in the path above the node we point to. this node's content is modified by the
         # caller, and that is recursively merged up to the document root.
         if empty?
-          Typelike.modified_copy(document, &block)
+          Util.modified_copy(document, &block)
         else
           car = tokens[0]
           cdr = Ptr.new(tokens[1..-1])
@@ -260,7 +259,7 @@ module JSI
 
       private
 
-      def node_subscript_token_child(value, token, *a)
+      def node_subscript_token_child(value, token, *a, **kw)
         if value.respond_to?(:to_ary)
           if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
             token = token.to_i
@@ -276,13 +275,25 @@ module JSI
             raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid index of #{value.inspect}")
           end
 
-          child = (value.respond_to?(:[]) ? value : value.to_ary)[token, *a]
+          ary = (value.respond_to?(:[]) ? value : value.to_ary)
+          if kw.empty?
+            # TODO remove eventually (keyword argument compatibility)
+            child = ary[token, *a]
+          else
+            child = ary[token, *a, **kw]
+          end
         elsif value.respond_to?(:to_hash)
           unless (value.respond_to?(:key?) ? value : value.to_hash).key?(token)
             raise(ResolutionError, "Invalid resolution: #{token.inspect} is not a valid key of #{value.inspect}")
           end
 
-          child = (value.respond_to?(:[]) ? value : value.to_hash)[token, *a]
+          hsh = (value.respond_to?(:[]) ? value : value.to_hash)
+          if kw.empty?
+            # TODO remove eventually (keyword argument compatibility)
+            child = hsh[token, *a]
+          else
+            child = hsh[token, *a, **kw]
+          end
         else
           raise(ResolutionError, "Invalid resolution: #{token.inspect} cannot be resolved in #{value.inspect}")
         end

data/lib/jsi/schema/application/child_application/contains.rb

@@ -4,11 +4,20 @@ module JSI
   module Schema::Application::ChildApplication::Contains
     # @private
     def internal_applicate_contains(idx, instance, &block)
-      if schema_content.key?('contains')
+      if keyword?('contains')
         contains_schema = subschema(['contains'])
 
-        if contains_schema.instance_valid?(instance[idx])
+        child_idx_valid = Hash.new { |h, i| h[i] = contains_schema.instance_valid?(instance[i]) }
+
+        if child_idx_valid[idx]
           yield contains_schema
+        else
+          instance_valid = instance.each_index.any? { |i| child_idx_valid[i] }
+
+          unless instance_valid
+            # invalid application: if contains_schema does not validate against any child, it applies to every child
+            yield contains_schema
+          end
         end
       end
     end

data/lib/jsi/schema/application/child_application/items.rb

@@ -4,13 +4,13 @@ module JSI
   module Schema::Application::ChildApplication::Items
     # @private
     def internal_applicate_items(idx, &block)
-      if schema_content['items'].respond_to?(:to_ary)
+      if keyword?('items') && schema_content['items'].respond_to?(:to_ary)
         if schema_content['items'].each_index.to_a.include?(idx)
           yield subschema(['items', idx])
-        elsif schema_content.key?('additionalItems')
+        elsif keyword?('additionalItems')
           yield subschema(['additionalItems'])
         end
-      elsif schema_content.key?('items')
+      elsif keyword?('items')
         yield subschema(['items'])
       end
     end

data/lib/jsi/schema/application/child_application/properties.rb

@@ -5,11 +5,11 @@ module JSI
     # @private
     def internal_applicate_properties(property_name, &block)
       apply_additional = true
-      if schema_content.key?('properties') && schema_content['properties'].respond_to?(:to_hash) && schema_content['properties'].key?(property_name)
+      if keyword?('properties') && schema_content['properties'].respond_to?(:to_hash) && schema_content['properties'].key?(property_name)
         apply_additional = false
         yield subschema(['properties', property_name])
       end
-      if schema_content['patternProperties'].respond_to?(:to_hash)
+      if keyword?('patternProperties') && schema_content['patternProperties'].respond_to?(:to_hash)
         schema_content['patternProperties'].each_key do |pattern|
           if pattern.respond_to?(:to_str) && property_name.to_s =~ Regexp.new(pattern) # TODO map pattern to ruby syntax
             apply_additional = false
@@ -17,7 +17,7 @@ module JSI
           end
         end
       end
-      if apply_additional && schema_content.key?('additionalProperties')
+      if apply_additional && keyword?('additionalProperties')
         yield subschema(['additionalProperties'])
       end
     end

data/lib/jsi/schema/application/child_application.rb

@@ -30,9 +30,7 @@ module JSI
     def each_child_applicator_schema(token, instance, &block)
       return to_enum(__method__, token, instance) unless block
 
-      if schema_content.respond_to?(:to_hash)
-        internal_child_applicate_keywords(token, instance, &block)
-      end
+      internal_child_applicate_keywords(token, instance, &block)
 
       nil
     end

data/lib/jsi/schema/application/inplace_application/dependencies.rb

@@ -4,7 +4,7 @@ module JSI
   module Schema::Application::InplaceApplication::Dependencies
     # @private
     def internal_applicate_dependencies(instance, visited_refs, &block)
-      if schema_content.key?('dependencies')
+      if keyword?('dependencies')
         value = schema_content['dependencies']
         # This keyword's value MUST be an object. Each property specifies a dependency.  Each dependency
         # value MUST be an array or a valid JSON Schema.

data/lib/jsi/schema/application/inplace_application/ifthenelse.rb

@@ -4,13 +4,13 @@ module JSI
   module Schema::Application::InplaceApplication::IfThenElse
     # @private
     def internal_applicate_ifthenelse(instance, visited_refs, &block)
-      if schema_content.key?('if')
+      if keyword?('if')
         if subschema(['if']).instance_valid?(instance)
-          if schema_content.key?('then')
+          if keyword?('then')
             subschema(['then']).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
           end
         else
-          if schema_content.key?('else')
+          if keyword?('else')
             subschema(['else']).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
           end
         end

data/lib/jsi/schema/application/inplace_application/ref.rb

@@ -4,7 +4,7 @@ module JSI
   module Schema::Application::InplaceApplication::Ref
     # @private
     def internal_applicate_ref(instance, visited_refs, throw_done: false, &block)
-      if schema_content['$ref'].respond_to?(:to_str)
+      if keyword?('$ref') && schema_content['$ref'].respond_to?(:to_str)
         ref = jsi_memoize(:ref) { Schema::Ref.new(schema_content['$ref'], self) }
         unless visited_refs.include?(ref)
           ref.deref_schema.each_inplace_applicator_schema(instance, visited_refs: visited_refs + [ref], &block)

data/lib/jsi/schema/application/inplace_application/someof.rb

@@ -4,24 +4,39 @@ module JSI
   module Schema::Application::InplaceApplication::SomeOf
     # @private
     def internal_applicate_someOf(instance, visited_refs, &block)
-      if schema_content['allOf'].respond_to?(:to_ary)
+      if keyword?('allOf') && schema_content['allOf'].respond_to?(:to_ary)
         schema_content['allOf'].each_index do |i|
           subschema(['allOf', i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
         end
       end
-      if schema_content['anyOf'].respond_to?(:to_ary)
-        schema_content['anyOf'].each_index do |i|
-          if subschema(['anyOf', i]).instance_valid?(instance)
-            subschema(['anyOf', i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
-          end
+      if keyword?('anyOf') && schema_content['anyOf'].respond_to?(:to_ary)
+        anyOf = schema_content['anyOf'].each_index.map { |i| subschema(['anyOf', i]) }
+        validOf = anyOf.select { |schema| schema.instance_valid?(instance) }
+        if !validOf.empty?
+          applicators = validOf
+        else
+          # invalid application: if none of the anyOf were valid, we apply them all
+          applicators = anyOf
+        end
+
+        applicators.each do |applicator|
+          applicator.each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
         end
       end
-      if schema_content['oneOf'].respond_to?(:to_ary)
-        one_i = schema_content['oneOf'].each_index.detect do |i|
-          subschema(['oneOf', i]).instance_valid?(instance)
+      if keyword?('oneOf') && schema_content['oneOf'].respond_to?(:to_ary)
+        oneOf_idxs = schema_content['oneOf'].each_index
+        subschema_idx_valid = Hash.new { |h, i| h[i] = subschema(['oneOf', i]).instance_valid?(instance) }
+        # count up to 2 `oneOf` subschemas which `instance` validates against
+        nvalid = oneOf_idxs.inject(0) { |n, i| n > 1 ? n : subschema_idx_valid[i] ? n + 1 : n }
+        if nvalid == 1
+          applicator_idxs = oneOf_idxs.select { |i| subschema_idx_valid[i] }
+        else
+          # invalid application: if none or multiple of the oneOf were valid, we apply them all
+          applicator_idxs = oneOf_idxs
         end
-        if one_i
-          subschema(['oneOf', one_i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
+
+        applicator_idxs.each do |i|
+          subschema(['oneOf', i]).each_inplace_applicator_schema(instance, visited_refs: visited_refs, &block)
         end
       end
     end

data/lib/jsi/schema/application/inplace_application.rb

@@ -32,12 +32,7 @@ module JSI
       return to_enum(__method__, instance, visited_refs: visited_refs) unless block
 
       catch(:jsi_application_done) do
-        if schema_content.respond_to?(:to_hash)
-          internal_inplace_applicate_keywords(instance, visited_refs, &block)
-        else
-          # self is the only applicator schema if there are no keywords
-          yield self
-        end
+        internal_inplace_applicate_keywords(instance, visited_refs, &block)
       end
 
       nil

data/lib/jsi/schema/ref.rb

@@ -53,7 +53,6 @@ module JSI
         resolve_fragment_ptr = ref_schema.method(:resource_root_subschema)
       else
         # find the schema_resource_root from the non-fragment URI. we will resolve any fragment, either pointer or anchor, from there.
-        schema_resource_root = nil
 
         if ref_uri_nofrag.absolute?
           ref_abs_uri = ref_uri_nofrag
@@ -84,7 +83,7 @@ module JSI
         else
           # Note: Schema#resource_root_subschema will reinstantiate nonschemas as schemas.
           # not implemented for remote refs when the schema_resource_root is not a schema.
-          resolve_fragment_ptr = -> (ptr) { ptr.evaluate(schema_resource_root) }
+          resolve_fragment_ptr = -> (ptr) { schema_resource_root.jsi_descendent_node(ptr) }
         end
       end
 
@@ -140,6 +139,8 @@ module JSI
       %Q(\#<#{self.class.name} #{ref}>)
     end
 
+    alias_method :to_s, :inspect
+
     # pretty-prints a representation of self to the given printer
     # @return [void]
     def pretty_print(q)

data/lib/jsi/schema/schema_ancestor_node.rb

@@ -7,16 +7,16 @@ module JSI
     # the base URI used to resolve the ids of schemas at or below this JSI.
     # this is always an absolute URI (with no fragment).
     # this may be the absolute schema URI of a parent schema or the URI from which the document was retrieved.
-    # @private
+    # @api private
     # @return [Addressable::URI, nil]
     attr_reader :jsi_schema_base_uri
 
     # resources which are ancestors of this JSI in the document. this does not include self.
-    # @private
+    # @api private
     # @return [Array<JSI::Schema>]
     def jsi_schema_resource_ancestors
       return @jsi_schema_resource_ancestors if instance_variable_defined?(:@jsi_schema_resource_ancestors)
-      [].freeze
+      Util::EMPTY_ARY
     end
 
     # the URI of the resource containing this node.
@@ -25,18 +25,14 @@ module JSI
     # or nil if not contained by a resource with a URI.
     # @return [Addressable::URI, nil]
     def jsi_resource_ancestor_uri
-      if is_a?(Schema) && schema_absolute_uri
-        schema_absolute_uri
-      else
-        jsi_schema_base_uri
-      end
+      (is_a?(Schema) && schema_absolute_uri) || jsi_schema_base_uri
     end
 
     # a schema at or below this node with the given anchor.
     #
     # @return [JSI::Schema, nil]
     def jsi_anchor_subschema(anchor)
-      subschemas = jsi_anchor_subschemas_map[anchor]
+      subschemas = jsi_anchor_subschemas_map[anchor: anchor]
       if subschemas.size == 1
         subschemas.first
       else
@@ -48,7 +44,7 @@ module JSI
     #
     # @return [Array<JSI::Schema>]
     def jsi_anchor_subschemas(anchor)
-      jsi_anchor_subschemas_map[anchor]
+      jsi_anchor_subschemas_map[anchor: anchor]
     end
 
     private
@@ -58,9 +54,7 @@ module JSI
     end
 
     def jsi_ptr=(jsi_ptr)
-      unless jsi_ptr.is_a?(Ptr)
-        raise(TypeError, "jsi_ptr must be a JSI::Ptr; got: #{jsi_ptr.inspect}")
-      end
+      raise(Bug, "jsi_ptr not #{Ptr}: #{jsi_ptr.inspect}") unless jsi_ptr.is_a?(Ptr)
       @jsi_ptr = jsi_ptr
     end
 
@@ -83,7 +77,7 @@ module JSI
         unless jsi_schema_resource_ancestors.respond_to?(:to_ary)
           raise(TypeError, "jsi_schema_resource_ancestors must be an array; got: #{jsi_schema_resource_ancestors.inspect}")
         end
-        jsi_schema_resource_ancestors.each { |a| Schema.ensure_schema(a)  }
+        jsi_schema_resource_ancestors.each { |a| Schema.ensure_schema(a) }
         # sanity check the ancestors are in order
         last_anc_ptr = nil
         jsi_schema_resource_ancestors.each do |anc|
@@ -104,13 +98,13 @@ module JSI
 
         @jsi_schema_resource_ancestors = jsi_schema_resource_ancestors.to_ary.freeze
       else
-        @jsi_schema_resource_ancestors = [].freeze
+        @jsi_schema_resource_ancestors = Util::EMPTY_ARY
       end
     end
 
     def jsi_anchor_subschemas_map
-      jsi_memomap(__method__) do |anchor|
-        jsi_each_child_node.select do |node|
+      jsi_memomap(__method__) do |anchor: |
+        jsi_each_descendent_node.select do |node|
           node.is_a?(Schema) && node.respond_to?(:anchor) && node.anchor == anchor
         end.freeze
       end

data/lib/jsi/schema/validation/array.rb

@@ -4,7 +4,7 @@ module JSI
   module Schema::Validation::ArrayLength
     # @private
     def internal_validate_maxItems(result_builder)
-      if schema_content.key?('maxItems')
+      if keyword?('maxItems')
         value = schema_content['maxItems']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0
@@ -24,7 +24,7 @@ module JSI
 
     # @private
     def internal_validate_minItems(result_builder)
-      if schema_content.key?('minItems')
+      if keyword?('minItems')
         value = schema_content['minItems']
         # The value of this keyword MUST be a non-negative integer.
         if internal_integer?(value) && value >= 0
@@ -45,7 +45,7 @@ module JSI
   module Schema::Validation::UniqueItems
     # @private
     def internal_validate_uniqueItems(result_builder)
-      if schema_content.key?('uniqueItems')
+      if keyword?('uniqueItems')
         value = schema_content['uniqueItems']
         # The value of this keyword MUST be a boolean.
         if value == false