jsi 0.6.0 → 0.7.0

data/lib/jsi/schema_set.rb

@@ -42,12 +42,21 @@ module JSI
     # @yieldreturn [JSI::Schema]
     # @raise [JSI::Schema::NotASchemaError]
     def initialize(enum, &block)
+      if enum.is_a?(Schema)
+        raise(ArgumentError, [
+          "#{SchemaSet} initialized with a #{Schema}",
+          "you probably meant to pass that to #{SchemaSet}[]",
+          "or to wrap that schema in a Set or Array for #{SchemaSet}.new",
+          "given: #{enum.pretty_inspect.chomp}",
+        ].join("\n"))
+      end
+
       super
 
       not_schemas = reject { |s| s.is_a?(Schema) }
       if !not_schemas.empty?
         raise(Schema::NotASchemaError, [
-          "JSI::SchemaSet initialized with non-schema objects:",
+          "#{SchemaSet} initialized with non-schema objects:",
           *not_schemas.map { |ns| ns.pretty_inspect.chomp },
         ].join("\n"))
       end
@@ -71,7 +80,10 @@ module JSI
     )
       applied_schemas = inplace_applicator_schemas(instance)
 
-      jsi = JSI::SchemaClasses.class_for_schemas(applied_schemas).new(instance,
+      jsi_class = JSI::SchemaClasses.class_for_schemas(applied_schemas,
+        includes: SchemaClasses.includes_for(instance),
+      )
+      jsi = jsi_class.new(instance,
         jsi_schema_base_uri: uri,
       )
 
@@ -102,6 +114,32 @@ module JSI
       nil
     end
 
+    # a set of child applicator subschemas of each schema in this set which apply to the child
+    # of the given instance on the given token.
+    # (see {Schema::Application::ChildApplication#child_applicator_schemas})
+    #
+    # @param instance (see Schema::Application::ChildApplication#child_applicator_schemas)
+    # @return [JSI::SchemaSet]
+    def child_applicator_schemas(token, instance)
+      SchemaSet.new(each_child_applicator_schema(token, instance))
+    end
+
+    # yields each child applicator schema which applies to the child of
+    # the given instance on the given token.
+    #
+    # @param (see Schema::Application::ChildApplication#child_applicator_schemas)
+    # @yield [JSI::Schema]
+    # @return [nil, Enumerator] an Enumerator if invoked without a block; otherwise nil
+    def each_child_applicator_schema(token, instance, &block)
+      return to_enum(__method__, token, instance) unless block
+
+      each do |schema|
+        schema.each_child_applicator_schema(token, instance, &block)
+      end
+
+      nil
+    end
+
     # validates the given instance against our schemas
     #
     # @param instance [Object] the instance to validate against our schemas
@@ -123,6 +161,8 @@ module JSI
       "#{self.class}[#{map(&:inspect).join(", ")}]"
     end
 
+    alias_method :to_s, :inspect
+
     def pretty_print(q)
       q.text self.class.to_s
       q.text '['

data/lib/jsi/simple_wrap.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 module JSI
-  SimpleWrap = JSI::JSONSchemaOrgDraft06.new_schema_module({
-    "additionalProperties": {"$ref": "#"},
-    "items": {"$ref": "#"}
-  })
+  simple_wrap_implementation = Module.new do
+    include Schema
+    include Schema::Application::ChildApplication
+    include Schema::Application::InplaceApplication
+    include Schema::Validation::Core
+
+    def internal_child_applicate_keywords(token, instance)
+      yield self
+    end
+
+    def internal_inplace_applicate_keywords(instance, visited_refs)
+      yield self
+    end
+
+    def internal_validate_keywords(result_builder)
+    end
+  end
+
+  simple_wrap_metaschema = MetaschemaNode.new(nil, schema_implementation_modules: [simple_wrap_implementation])
+  SimpleWrap = simple_wrap_metaschema.new_schema_module({})
 
   # SimpleWrap is a JSI schema module which recursively wraps nested structures
   module SimpleWrap
   end
+
+  SimpleWrap::Implementation = simple_wrap_implementation
+  SimpleWrap::METASCHEMA = simple_wrap_metaschema
 end

data/lib/jsi/util/{attr_struct.rb → private/attr_struct.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module JSI
-  module Util
+  module Util::Private
     # like a Struct, but stores all the attributes in one @attributes Hash, instead of individual instance
     # variables for each attribute.
     # this tends to be easier to work with and more flexible. keys which are symbols are converted to strings.
@@ -15,22 +15,18 @@ module JSI
       class << self
         # creates a AttrStruct subclass with the given attribute keys.
         # @param attribute_keys [Enumerable<String, Symbol>]
-        def [](*attribute_keys)
-          unless self == AttrStruct
-            # :nocov:
-            raise(NotImplementedError, "AttrStruct multiple inheritance not supported")
-            # :nocov:
-          end
-
+        def subclass(*attribute_keys)
           bad = attribute_keys.reject { |key| key.respond_to?(:to_str) || key.is_a?(Symbol) }
           unless bad.empty?
             raise ArgumentError, "attribute keys must be String or Symbol; got keys: #{bad.map(&:inspect).join(', ')}"
           end
-          attribute_keys = attribute_keys.map { |key| key.is_a?(Symbol) ? key.to_s : key }
+          attribute_keys = attribute_keys.map { |key| convert_key(key) }
+
+          all_attribute_keys = (self.attribute_keys + attribute_keys).freeze
+
+          Class.new(self).tap do |klass|
+            klass.define_singleton_method(:attribute_keys) { all_attribute_keys }
 
-          Class.new(AttrStruct).tap do |klass|
-            klass.define_singleton_method(:attribute_keys) { attribute_keys }
-            klass.send(:define_method, :attribute_keys) { attribute_keys }
             attribute_keys.each do |attribute_key|
               # reader
               klass.send(:define_method, attribute_key) do
@@ -44,28 +40,46 @@ module JSI
             end
           end
         end
+
+        alias_method :[], :subclass
+
+        # the attribute keys defined for this class
+        # @return [Set<String>]
+        def attribute_keys
+          # empty for AttrStruct itself; redefined on each subclass
+          Util::Private::EMPTY_SET
+        end
+
+        # returns a frozen string, given a string or symbol.
+        # returns anything else as-is for the caller to handle.
+        # @api private
+        def convert_key(key)
+          # TODO use Symbol#name when available on supported rubies
+          key.is_a?(Symbol) ? key.to_s.freeze : key.frozen? ? key : key.is_a?(String) ? key.dup.freeze : key
+        end
       end
 
       def initialize(attributes = {})
         unless attributes.respond_to?(:to_hash)
           raise(TypeError, "expected attributes to be a Hash; got: #{attributes.inspect}")
         end
-        attributes = attributes.map { |k, v| {k.is_a?(Symbol) ? k.to_s : k => v} }.inject({}, &:update)
-        bad = attributes.keys.reject { |k| self.attribute_keys.include?(k) }
+        @attributes = {}
+        attributes.to_hash.each do |k, v|
+          @attributes[self.class.convert_key(k)] = v
+        end
+        bad = @attributes.keys.reject { |k| attribute_keys.include?(k) }
         unless bad.empty?
           raise UndefinedAttributeKey, "undefined attribute keys: #{bad.map(&:inspect).join(', ')}"
         end
-        @attributes = attributes
       end
 
       def [](key)
-        key = key.to_s if key.is_a?(Symbol)
-        @attributes[key]
+        @attributes[key.is_a?(Symbol) ? key.to_s : key]
       end
 
       def []=(key, value)
-        key = key.to_s if key.is_a?(Symbol)
-        unless self.attribute_keys.include?(key)
+        key = self.class.convert_key(key)
+        unless attribute_keys.include?(key)
           raise UndefinedAttributeKey, "undefined attribute key: #{key.inspect}"
         end
         @attributes[key] = value
@@ -76,6 +90,8 @@ module JSI
         "\#<#{self.class.name}#{@attributes.empty? ? '' : ' '}#{@attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
       end
 
+      alias_method :to_s, :inspect
+
       # pretty-prints a representation of self to the given printer
       # @return [void]
       def pretty_print(q)
@@ -97,6 +113,11 @@ module JSI
         q.text '>'
       end
 
+      # (see AttrStruct.attribute_keys)
+      def attribute_keys
+        self.class.attribute_keys
+      end
+
       include FingerprintHash
       def jsi_fingerprint
         {class: self.class, attributes: @attributes}

data/lib/jsi/util/private.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module JSI
+  # JSI::Util::Private classes, modules, constants, and methods are internal, and will be added and removed without warning.
+  #
+  # @api private
+  module Util::Private
+    autoload :AttrStruct, 'jsi/util/private/attr_struct'
+
+    EMPTY_ARY = [].freeze
+
+    EMPTY_SET = Set[].freeze
+
+    # is a hash as the last argument passed to keyword params? (false in ruby 3; true before - generates
+    # a warning in 2.7 but no way to make 2.7 behave like 3 so the warning is useless)
+    #
+    # TODO remove eventually (keyword argument compatibility)
+    LAST_ARGUMENT_AS_KEYWORD_PARAMETERS = begin
+      if Object.const_defined?(:Warning)
+        warn = ::Warning.instance_method(:warn)
+        ::Warning.send(:remove_method, :warn)
+        ::Warning.send(:define_method, :warn) { |*, **| }
+      end
+
+      -> (k: ) { k }[{k: nil}]
+      true
+    rescue ArgumentError
+      false
+    ensure
+      if Object.const_defined?(:Warning)
+        ::Warning.send(:remove_method, :warn)
+        ::Warning.send(:define_method, :warn, warn)
+      end
+    end
+
+    # is the given name ok to use as a ruby method name?
+    def ok_ruby_method_name?(name)
+      # must be a string
+      return false unless name.respond_to?(:to_str)
+      # must not begin with a digit
+      return false if name =~ /\A[0-9]/
+      # must not contain characters special to ruby syntax
+      return false if name =~ /[\\\s\#;\.,\(\)\[\]\{\}'"`%\+\-\/\*\^\|&=<>\?:!@\$~]/
+
+      return true
+    end
+
+    # this is the Y-combinator, which allows anonymous recursive functions. for a simple example,
+    # to define a recursive function to return the length of an array:
+    #
+    #     length = ycomb do |len|
+    #       proc { |list| list == [] ? 0 : 1 + len.call(list[1..-1]) }
+    #     end
+    #
+    #     length.call([0])
+    #     # => 1
+    #
+    # see https://en.wikipedia.org/wiki/Fixed-point_combinator#Y_combinator
+    # and chapter 9 of the little schemer, available as the sample chapter at
+    # https://felleisen.org/matthias/BTLS-index.html
+    def ycomb
+      proc { |f| f.call(f) }.call(proc { |f| yield proc { |*x| f.call(f).call(*x) } })
+    end
+
+    def require_jmespath
+      return if instance_variable_defined?(:@jmespath_required)
+      begin
+        require 'jmespath'
+      rescue ::LoadError => e
+        # :nocov:
+        msg = [
+          "please install and/or add to your Gemfile the `jmespath` gem to use this. jmespath is not a dependency of JSI.",
+          "original error message:",
+          e.message,
+        ].join("\n")
+        raise(e.class, msg, e.backtrace)
+        # :nocov:
+      end
+      hashlike = JSI::SchemaSet[].new_jsi({'test' => 0})
+      unless JMESPath.search('test', hashlike) == 0
+        # :nocov:
+        raise(::LoadError, [
+          "the loaded version of jmespath cannot be used with JSI.",
+          "jmespath is compatible with JSI objects as of version 1.5.0",
+        ].join("\n"))
+        # :nocov:
+      end
+      @jmespath_required = true
+      nil
+    end
+
+    module FingerprintHash
+      # overrides BasicObject#==
+      def ==(other)
+        __id__ == other.__id__ || (other.respond_to?(:jsi_fingerprint) && other.jsi_fingerprint == jsi_fingerprint)
+      end
+
+      alias_method :eql?, :==
+
+      # overrides Kernel#hash
+      def hash
+        jsi_fingerprint.hash
+      end
+    end
+
+    class MemoMap
+      Result = AttrStruct[*%w(
+        value
+        inputs
+        inputs_hash
+      )]
+
+      class Result
+      end
+
+      def initialize(key_by: nil, &block)
+        @key_by = key_by
+        @block = block
+
+        # each result has its own mutex to update its memoized value thread-safely
+        @result_mutexes = {}
+        # another mutex to thread-safely initialize each result mutex
+        @result_mutexes_mutex = Mutex.new
+
+        @results = {}
+      end
+
+      def [](**inputs)
+        if @key_by
+          key = @key_by.call(**inputs)
+        else
+          key = inputs
+        end
+        result_mutex = @result_mutexes_mutex.synchronize do
+          @result_mutexes[key] ||= Mutex.new
+        end
+
+        result_mutex.synchronize do
+          inputs_hash = inputs.hash
+          if @results.key?(key) && inputs_hash == @results[key].inputs_hash && inputs == @results[key].inputs
+            @results[key].value
+          else
+            value = @block.call(**inputs)
+            @results[key] = Result.new(value: value, inputs: inputs, inputs_hash: inputs_hash)
+            value
+          end
+        end
+      end
+    end
+
+    module Memoize
+      def self.extended(object)
+        object.send(:jsi_initialize_memos)
+      end
+
+      private
+
+      def jsi_initialize_memos
+        @jsi_memomaps_mutex = Mutex.new
+        @jsi_memomaps = {}
+      end
+
+      # @return [Util::MemoMap]
+      def jsi_memomap(name, **options, &block)
+        raise(Bug, 'must jsi_initialize_memos') unless @jsi_memomaps
+        unless @jsi_memomaps.key?(name)
+          @jsi_memomaps_mutex.synchronize do
+            # note: this ||= appears redundant with `unless @jsi_memomaps.key?(name)`,
+            # but that check is not thread safe. this check is.
+            @jsi_memomaps[name] ||= Util::MemoMap.new(**options, &block)
+          end
+        end
+        @jsi_memomaps[name]
+      end
+
+      def jsi_memoize(name, **inputs, &block)
+        jsi_memomap(name, &block)[**inputs]
+      end
+    end
+
+    module Virtual
+      class InstantiationError < StandardError
+      end
+
+      # this virtual class is not intended to be instantiated except by its subclasses, which override #initialize
+      def initialize
+        # :nocov:
+        raise(InstantiationError, "cannot instantiate virtual class #{self.class}")
+        # :nocov:
+      end
+
+      # virtual_method is used to indicate that the method calling it must be implemented on the (non-virtual) subclass
+      def virtual_method
+        # :nocov:
+        raise(Bug, "class #{self.class} must implement #{caller_locations.first.label}")
+        # :nocov:
+      end
+    end
+
+    public
+
+    extend self
+  end
+end

data/lib/jsi/{typelike_modules.rb → util/typelike.rb}

@@ -1,72 +1,16 @@
 # frozen_string_literal: true
 
 module JSI
-  # a module relating to objects that act like Hash or Array instances
+  # @deprecated after v0.6
   module Typelike
-    # yields the content of the given param `object`. for objects which have a #jsi_modified_copy
-    # method of their own (JSI::Base, JSI::MetaschemaNode) that method is invoked with the given
-    # block. otherwise the given object itself is yielded.
-    #
-    # the given block must result in a modified copy of its block parameter
-    # (not destructively modifying the yielded content).
-    #
-    # @yield [Object] the content of the given object. the block should result
-    #   in a (nondestructively) modified copy of this.
-    # @return [object.class] modified copy of the given object
-    def self.modified_copy(object, &block)
-      if object.respond_to?(:jsi_modified_copy)
-        object.jsi_modified_copy(&block)
-      else
-        return yield(object)
-      end
-    end
-
-    # recursive method to express the given argument object in json-compatible
-    # types of Hash, Array, and basic types of String/boolean/numeric/nil. this
-    # will raise TypeError if an object is given that is not a type that seems
-    # to be expressable as json.
-    #
-    # similar effect could be achieved by requiring 'json/add/core' and using #as_json,
-    # but I don't much care for how it represents classes that are
-    # not naturally expressable in JSON, and prefer not to load its
-    # monkey-patching.
-    #
-    # @param object [Object] the object to be converted to jsonifiability
-    # @return [Array, Hash, String, Boolean, NilClass, Numeric] jsonifiable
-    #   expression of param object
-    # @raise [TypeError] when the object (or an object nested with a hash or
-    #   array of object) cannot be expressed as json
-    def self.as_json(object, *opt)
-      if object.is_a?(JSI::PathedNode)
-        as_json(object.jsi_node_content, *opt)
-      elsif object.respond_to?(:to_hash)
-        (object.respond_to?(:map) ? object : object.to_hash).map do |k, v|
-          unless k.is_a?(Symbol) || k.respond_to?(:to_str)
-            raise(TypeError, "json object (hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
-          end
-          {k.to_s => as_json(v, *opt)}
-        end.inject({}, &:update)
-      elsif object.respond_to?(:to_ary)
-        (object.respond_to?(:map) ? object : object.to_ary).map { |e| as_json(e, *opt) }
-      elsif [String, TrueClass, FalseClass, NilClass, Numeric].any? { |c| object.is_a?(c) }
-        object
-      elsif object.is_a?(Symbol)
-        object.to_s
-      elsif object.is_a?(Set)
-        as_json(object.to_a, *opt)
-      elsif object.respond_to?(:as_json)
-        as_json(object.as_json(*opt), *opt)
-      else
-        raise(TypeError, "cannot express object as json: #{object.pretty_inspect.chomp}")
-      end
-    end
+    extend Util
   end
 
   # a module of methods for objects which behave like Hash but are not Hash.
   #
   # this module is intended to be internal to JSI. no guarantees or API promises
   # are made for non-JSI classes including this module.
-  module Hashlike
+  module Util::Hashlike
     # safe methods which can be delegated to #to_hash (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
 
@@ -79,24 +23,41 @@ module JSI
     # select and reject will return a modified copy but need the yielded block variable value from #[]
     safe_kv_block_modified_copy_methods = %w(select reject)
     SAFE_METHODS = SAFE_KEY_ONLY_METHODS | SAFE_KEY_VALUE_METHODS
-    safe_to_hash_methods = SAFE_METHODS - safe_modified_copy_methods - safe_kv_block_modified_copy_methods
+    custom_methods = %w(merge) # defined below
+    safe_to_hash_methods = SAFE_METHODS -
+      safe_modified_copy_methods -
+      safe_kv_block_modified_copy_methods -
+      custom_methods
     safe_to_hash_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) { |*a, &b| to_hash.public_send(method_name, *a, &b) }
+      else
+        define_method(method_name) { |*a, **kw, &b| to_hash.public_send(method_name, *a, **kw, &b) }
+      end
     end
     safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        jsi_modified_copy do |object_to_modify|
-          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
-          responsive_object.public_send(method_name, *a, &b)
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) do |*a, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+            responsive_object.public_send(method_name, *a, &b)
+          end
+        end
+      else
+        define_method(method_name) do |*a, **kw, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
+            responsive_object.public_send(method_name, *a, **kw, &b)
+          end
         end
       end
     end
     safe_kv_block_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
+      define_method(method_name) do |**kw, &b|
         jsi_modified_copy do |object_to_modify|
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_hash
           responsive_object.public_send(method_name) do |k, _v|
-            b.call(k, self[k, *a])
+            b.call(k, self[k, **kw])
           end
         end
       end
@@ -112,7 +73,7 @@ module JSI
       unless other.respond_to?(:to_hash)
         raise(TypeError, "cannot update with argument that does not respond to #to_hash: #{other.pretty_inspect.chomp}")
       end
-      self_respondingto_key = self.respond_to?(:key?) ? self : to_hash
+      self_respondingto_key = respond_to?(:key?) ? self : to_hash
       other.to_hash.each_pair do |key, value|
         if block && self_respondingto_key.key?(key)
           value = yield(key, self[key], value)
@@ -138,8 +99,8 @@ module JSI
     # self's #jsi_object_group_text
     # @return [String]
     def inspect
-      object_group_str = (respond_to?(:jsi_object_group_text) ? self.jsi_object_group_text : [self.class]).join(' ')
-      "\#{<#{object_group_str}>#{self.map { |k, v| " #{k.inspect} => #{v.inspect}" }.join(',')}}"
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      "\#{<#{object_group_str}>#{map { |k, v| " #{k.inspect} => #{v.inspect}" }.join(',')}}"
     end
 
     alias_method :to_s, :inspect
@@ -147,7 +108,7 @@ module JSI
     # pretty-prints a representation of this hashlike to the given printer
     # @return [void]
     def pretty_print(q)
-      object_group_str = (respond_to?(:jsi_object_group_text) ? jsi_object_group_text : [self.class]).join(' ')
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
       q.text "\#{<#{object_group_str}>"
       q.group_sub {
         q.nest(2) {
@@ -170,7 +131,7 @@ module JSI
   #
   # this module is intended to be internal to JSI. no guarantees or API promises
   # are made for non-JSI classes including this module.
-  module Arraylike
+  module Util::Arraylike
     # safe methods which can be delegated to #to_ary (which the includer is assumed to have defined).
     # 'safe' means, in this context, nondestructive - methods which do not modify the receiver.
 
@@ -189,23 +150,36 @@ module JSI
     SAFE_METHODS = SAFE_INDEX_ONLY_METHODS | SAFE_INDEX_ELEMENT_METHODS
     safe_to_ary_methods = SAFE_METHODS - safe_modified_copy_methods - safe_el_block_methods
     safe_to_ary_methods.each do |method_name|
-      define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) { |*a, &b| to_ary.public_send(method_name, *a, &b) }
+      else
+        define_method(method_name) { |*a, **kw, &b| to_ary.public_send(method_name, *a, **kw, &b) }
+      end
     end
     safe_modified_copy_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
-        jsi_modified_copy do |object_to_modify|
-          responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
-          responsive_object.public_send(method_name, *a, &b)
+      if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
+        define_method(method_name) do |*a, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+            responsive_object.public_send(method_name, *a, &b)
+          end
+        end
+      else
+        define_method(method_name) do |*a, **kw, &b|
+          jsi_modified_copy do |object_to_modify|
+            responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
+            responsive_object.public_send(method_name, *a, **kw, &b)
+          end
         end
       end
     end
     safe_el_block_methods.each do |method_name|
-      define_method(method_name) do |*a, &b|
+      define_method(method_name) do |**kw, &b|
         jsi_modified_copy do |object_to_modify|
           i = 0
           responsive_object = object_to_modify.respond_to?(method_name) ? object_to_modify : object_to_modify.to_ary
           responsive_object.public_send(method_name) do |_e|
-            b.call(self[i, *a]).tap { i += 1 }
+            b.call(self[i, **kw]).tap { i += 1 }
           end
         end
       end
@@ -229,8 +203,8 @@ module JSI
     # self's #jsi_object_group_text
     # @return [String]
     def inspect
-      object_group_str = (respond_to?(:jsi_object_group_text) ? jsi_object_group_text : [self.class]).join(' ')
-      "\#[<#{object_group_str}>#{self.map { |e| ' ' + e.inspect }.join(',')}]"
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
+      "\#[<#{object_group_str}>#{map { |e| ' ' + e.inspect }.join(',')}]"
     end
 
     alias_method :to_s, :inspect
@@ -238,7 +212,7 @@ module JSI
     # pretty-prints a representation of this arraylike to the given printer
     # @return [void]
     def pretty_print(q)
-      object_group_str = (respond_to?(:jsi_object_group_text) ? jsi_object_group_text : [self.class]).join(' ')
+      object_group_str = (respond_to?(:jsi_object_group_text, true) ? jsi_object_group_text : [self.class]).join(' ')
       q.text "\#[<#{object_group_str}>"
       q.group_sub {
         q.nest(2) {