jsi 0.8.2 → 0.9.0

data/lib/jsi/base/node.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module JSI
-  # 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
     # instantiates and yields each property name (hash key) as a JSI described by any `propertyNames` schemas.
     #
@@ -11,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)
@@ -37,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.
@@ -53,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
@@ -64,19 +64,45 @@ module JSI
       end
     end
 
+    # 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
@@ -86,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
 
@@ -135,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)
@@ -148,8 +174,10 @@ 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
     # See {Base#jsi_array?}. Always true for ArrayNode.
     def jsi_array?
@@ -163,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
@@ -181,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
@@ -240,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.
@@ -299,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)
@@ -312,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!