jsi-dev 0.0.8 → 0.0.9

data/lib/jsi/base/mutability.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module JSI
+  module Base::Mutable
+    include(Util::FingerprintHash)
+
+    def jsi_node_content
+      jsi_ptr.evaluate(jsi_document)
+    end
+
+    def jsi_mutable?
+      true
+    end
+
+    private
+
+    def jsi_mutability_initialize
+      @child_node_by_token_map = method(:jsi_child_node_by_token_compute)
+      @child_node_map = jsi_memomap(key_by: Base::BY_TOKEN, &method(:jsi_child_node_compute))
+    end
+
+    def jsi_memomap_class
+      Util::MemoMap::Mutable
+    end
+  end
+
+  module Base::Immutable
+    include(Util::FingerprintHash::Immutable)
+
+    attr_reader(:jsi_node_content)
+
+    def jsi_mutable?
+      false
+    end
+
+    private
+
+    def jsi_mutability_initialize
+      @child_node_by_token_map = jsi_memomap(&method(:jsi_child_node_by_token_compute))
+      @child_node_map = method(:jsi_child_node_compute)
+      @jsi_node_content = @jsi_ptr.evaluate(@jsi_document)
+    end
+
+    def jsi_memomap_class
+      Util::MemoMap::Immutable
+    end
+  end
+end

data/lib/jsi/base/node.rb

@@ -1,32 +1,11 @@
 # frozen_string_literal: true
 
 module JSI
-  module Base::Enumerable
-    include ::Enumerable
-
-    # an Array containing each item in this JSI.
-    #
-    # @param kw keyword arguments are passed to {Base#[]} - see its keyword params
-    # @return [Array]
-    def to_a(**kw)
-      # TODO remove eventually (keyword argument compatibility)
-      # discard when all supported ruby versions Enumerable#to_a delegate keywords to #each (3.0.1 breaks; 2.7.x warns)
-      # https://bugs.ruby-lang.org/issues/18289
-      ary = []
-      each(**kw) do |e|
-        ary << e
-      end
-      ary.freeze
-    end
-
-    alias_method :entries, :to_a
-  end
-
-  # module extending a {JSI::Base} object when its instance (its {Base#jsi_node_content})
-  # is a Hash (or responds to `#to_hash`)
+  # Included on {Base} subclasses for instances that are Hash or
+  # [#to_hash](https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html#label-Hash-Convertible+Objects).
+  #
+  # Dynamically defines most methods of Hash to make the JSI duck-type like a Hash.
   module Base::HashNode
-    include Base::Enumerable
-
     # instantiates and yields each property name (hash key) as a JSI described by any `propertyNames` schemas.
     #
     # @yield [JSI::Base]
@@ -34,12 +13,8 @@ module JSI
     def jsi_each_propertyName
       return to_enum(__method__) { jsi_node_content_hash_pubsend(:size) } unless block_given?
 
-      property_schemas = SchemaSet.build do |schemas|
-        jsi_schemas.each do |s|
-          if s.keyword?('propertyNames') && s['propertyNames'].is_a?(Schema)
-            schemas << s['propertyNames']
-          end
-        end
+      property_schemas = jsi_schemas.each_yield_set do |s, y|
+        s.dialect_invoke_each(:propertyNames, &y)
       end
       jsi_node_content_hash_pubsend(:each_key) do |key|
         yield property_schemas.new_jsi(key)
@@ -60,14 +35,14 @@ module JSI
       nil
     end
 
-    # See {Base#jsi_child_token_in_range?}
-    def jsi_child_token_in_range?(token)
+    # See {Base#jsi_child_token_present?}
+    def jsi_child_token_present?(token)
       jsi_node_content_hash_pubsend(:key?, token)
     end
 
     # See {Base#jsi_node_content_child}
     def jsi_node_content_child(token)
-      # I could check token_in_range? and return nil here (as ArrayNode does).
+      # I could check token_present? and return nil here (as ArrayNode does).
       # without that check, if the instance defines Hash#default or #default_proc, that result is returned.
       # the preferred mechanism for a JSI's default value should be its schema.
       # but there's no compelling reason not to support both, so I'll return what #[] returns.
@@ -76,6 +51,8 @@ module JSI
 
     # See {Base#[]}
     def [](token, as_jsi: jsi_child_as_jsi_default, use_default: jsi_child_use_default_default)
+      raise(BlockGivenError) if block_given?
+      token = token.jsi_node_content if token.is_a?(Schema::SchemaAncestorNode)
       if jsi_node_content_hash_pubsend(:key?, token)
         jsi_child(token, as_jsi: as_jsi)
       else
@@ -87,19 +64,45 @@ module JSI
       end
     end
 
-    # yields each hash key and value of this node.
+    # See [Hash#store](https://ruby-doc.org/current/Hash.html#method-i-store)
+    def store(key, value)
+      self[key] = value
+    end
+
+    # See {Base#jsi_as_child_default_as_jsi}. true for HashNode.
+    def jsi_as_child_default_as_jsi
+      true
+    end
+
+    # yields each Hash key (JSON object property name) and value of this node.
     #
     # each yielded key is a key of the instance hash, and each yielded value is the result of {Base#[]}.
     #
+    # @param key_as_jsi (see #each_key)
     # @param kw keyword arguments are passed to {Base#[]}
     # @yield [Object, Object] each key and value of this hash node
     # @return [self, Enumerator] an Enumerator if invoked without a block; otherwise self
-    def each(**kw, &block)
-      return to_enum(__method__, **kw) { jsi_node_content_hash_pubsend(:size) } unless block
+    def each(key_as_jsi: false, **kw, &block)
+      return to_enum(__method__, key_as_jsi: key_as_jsi, **kw) { jsi_node_content_hash_pubsend(:size) } unless block
       if block.arity > 1
-        jsi_node_content_hash_pubsend(:each_key) { |k| yield k, self[k, **kw] }
+        each_key(key_as_jsi: key_as_jsi) { |k| yield(k, self[k, **kw]) }
       else
-        jsi_node_content_hash_pubsend(:each_key) { |k| yield [k, self[k, **kw]] }
+        each_key(key_as_jsi: key_as_jsi) { |k| yield([k, self[k, **kw]]) }
+      end
+      self
+    end
+
+    alias_method(:each_pair, :each)
+
+    # Yields each key (property name)
+    # @param key_as_jsi [Boolean] Yield each key as a JSI instance, per {#jsi_each_propertyName}
+    # @yield [String, Base]
+    def each_key(key_as_jsi: false, &block)
+      return to_enum(__method__, key_as_jsi: key_as_jsi) { size } unless block
+      if key_as_jsi
+        jsi_each_propertyName(&block)
+      else
+        jsi_node_content_hash_pubsend(:each_key, &block)
       end
       self
     end
@@ -109,7 +112,7 @@ module JSI
     # @return [Hash]
     def to_hash(**kw)
       hash = {}
-      jsi_node_content_hash_pubsend(:each_key) { |k| hash[k] = self[k, **kw] }
+      each_key { |k| hash[k] = self[k, **kw] }
       hash.freeze
     end
 
@@ -121,7 +124,7 @@ module JSI
           k.is_a?(Symbol) ? k.to_s :
           k.respond_to?(:to_str) && (kstr = k.to_str).is_a?(String) ? kstr :
           raise(TypeError, "JSON object (Hash) cannot be keyed with: #{k.pretty_inspect.chomp}")
-        hash[ks] = jsi_child(k, as_jsi: true).as_json(**options)
+        hash[ks] = jsi_child_node(k).as_json(**options)
       end
       hash
     end
@@ -158,7 +161,7 @@ module JSI
     end
 
     # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
-    SAFE_KEY_ONLY_METHODS.each do |method_name|
+    SAFE_KEY_ONLY_METHODS.reject { |m| instance_method(m).owner == self }.each do |method_name|
       if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
         define_method(method_name) do |*a, &b|
           jsi_node_content_hash_pubsend(method_name, *a, &b)
@@ -171,11 +174,11 @@ module JSI
     end
   end
 
-  # module extending a {JSI::Base} object when its instance (its {Base#jsi_node_content})
-  # is an Array (or responds to `#to_ary`)
+  # Included on {Base} subclasses for instances that are Array or
+  # [#to_ary](https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html#label-Array-Convertible+Objects).
+  #
+  # Dynamically defines most methods of Array to make the JSI duck-type like an Array.
   module Base::ArrayNode
-    include Base::Enumerable
-
     # See {Base#jsi_array?}. Always true for ArrayNode.
     def jsi_array?
       true
@@ -188,16 +191,16 @@ module JSI
       nil
     end
 
-    # See {Base#jsi_child_token_in_range?}
-    def jsi_child_token_in_range?(token)
+    # See {Base#jsi_child_token_present?}
+    def jsi_child_token_present?(token)
       token.is_a?(Integer) && token >= 0 && token < jsi_node_content_ary_pubsend(:size)
     end
 
     # See {Base#jsi_node_content_child}
     def jsi_node_content_child(token)
-      # we check token_in_range? here (unlike HashNode) because we do not want to pass
+      # we check token_present? here (unlike HashNode) because we do not want to pass
       # negative indices, Ranges, or non-Integers to Array#[]
-      if jsi_child_token_in_range?(token)
+      if jsi_child_token_present?(token)
         jsi_node_content_ary_pubsend(:[], token)
       else
         nil
@@ -206,6 +209,8 @@ module JSI
 
     # See {Base#[]}
     def [](token, as_jsi: jsi_child_as_jsi_default, use_default: jsi_child_use_default_default)
+      raise(BlockGivenError) if block_given?
+      token = token.jsi_node_content if token.is_a?(Schema::SchemaAncestorNode)
       size = jsi_node_content_ary_pubsend(:size)
       if token.is_a?(Integer)
         if token < 0
@@ -265,6 +270,11 @@ module JSI
       end
     end
 
+    # See {Base#jsi_as_child_default_as_jsi}. true for ArrayNode.
+    def jsi_as_child_default_as_jsi
+      true
+    end
+
     # yields each array element of this node.
     #
     # each yielded element is the result of {Base#[]} for each index of the instance array.
@@ -288,7 +298,7 @@ module JSI
 
     # See {Base#as_json}
     def as_json(options = {})
-      each_index.map { |i| jsi_child(i, as_jsi: true).as_json(**options) }
+      each_index.map { |i| jsi_child_node(i).as_json(**options) }
     end
 
     include Util::Arraylike
@@ -324,7 +334,7 @@ module JSI
 
     # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
     # we override these methods from Arraylike
-    SAFE_INDEX_ONLY_METHODS.each do |method_name|
+    SAFE_INDEX_ONLY_METHODS.reject { |m| instance_method(m).owner == self }.each do |method_name|
       if Util::LAST_ARGUMENT_AS_KEYWORD_PARAMETERS
         define_method(method_name) do |*a, &b|
           jsi_node_content_ary_pubsend(method_name, *a, &b)
@@ -337,6 +347,10 @@ module JSI
     end
   end
 
+  # Included on {Base} subclasses for instances that are String or
+  # [#to_str](https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html#label-String-Convertible+Objects).
+  #
+  # Dynamically defines most methods of String to make the JSI duck-type like a String.
   module Base::StringNode
     delegate_methods = %w(% * + << =~ [] []=
       ascii_only? b byteindex byterindex bytes bytesize byteslice bytesplice capitalize capitalize!