rbtree-ruby 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d89cd253c189b3342f30e2a4df3a293561e2353af6592d86f25fcea5eeb76433
-  data.tar.gz: 9af04bff3851e7806fc637c2fc0ad583decf8e7c020edf841220a2b90fe8aaf4
+  metadata.gz: 18d0cdfd5f115b61096c266d9de0a482e263574aad1dfce425efaabd3dad67b7
+  data.tar.gz: 639a4f4f85c14cab4acf93f5b9b5280fb6225c96c575cac1a47b2b4f934dca8e
 SHA512:
-  metadata.gz: a9708ffb8b421f883953c68582c607b9333e671542e21c0f3e0927838d2bb68202142150c11dd11541ea79fa1fcafc6c3195456c38d4b0db6b3897272d205835
-  data.tar.gz: 601190e616b7b478cc6ceabe682e9d43ef169871753667fe61e326f65daceaa60441122a550f8458f1d4a7a794a032ac0add88f326956db903854ee96e34b613
+  metadata.gz: e40c1a174c7f2dd1c6df7f94e316070178457e0baa41322baa0f622157eb548245bfd334435488d3a49cfe8396e8d587ae80f886a17dadbf93cd9f03fcd701d7
+  data.tar.gz: 20f49f91135a98e4b46ccb4b0981dafab6bb35a9375bfb06024b7b42f5c71ad04b23613ad5a1f372ac6456d9edf03ef9698b68ca2228e0cf5cb85d6c2ae2b5f4

data/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.6] - 2026-01-28
+
+### Added
+
+> **Note:** All methods added in this release are **convenience methods** composed from existing public API primitives (`each`, `insert`, `delete`, `dup`, `merge!`, `safe: true`). They provide no speed advantage over manual composition — their value is purely in readability and API completeness.
+
+- **`dup` (Deep Copy)**: `RBTree` and `MultiRBTree` now support `dup` and `clone` via `initialize_copy`. Creates an independent deep copy of the tree — modifications to the copy do not affect the original and vice versa.
+- **`select`**: Returns a new tree containing only key-value pairs for which the block returns true. Returns an `Enumerator` if no block is given.
+- **`reject`**: Returns a new tree excluding key-value pairs for which the block returns true. Returns an `Enumerator` if no block is given.
+- **`delete_if`**: Deletes key-value pairs in place for which the block returns true. Returns self. In `MultiRBTree`, operates at individual value granularity (can remove specific values without deleting the entire key).
+- **`reject!`**: Same as `delete_if`, but returns `nil` if no changes were made.
+- **`keep_if`**: Keeps only key-value pairs for which the block returns true, deleting the rest in place. Returns self. In `MultiRBTree`, operates at individual value granularity.
+- **`invert`**: Returns a new tree with keys and values swapped. For `RBTree`, duplicate values result in the last key winning (same as `Hash#invert`). For `MultiRBTree`, all pairs are preserved.
+- **`merge`** (non-destructive): Returns a new tree with merged contents. Supports block for duplicate key resolution: `tree.merge(other) { |key, v1, v2| v1 }`.
+- **`merge!` block support**: `merge!` now accepts a block for duplicate key resolution, matching `Hash#merge!` behavior.
+
+### Optimized
+- **`MultiRBTree#delete_if` / `#keep_if`**: Replaced clear-and-rebuild approach with in-place value array filtering via internal `filter_values!`. Avoids O(n log n) tree reconstruction; now runs in O(n) by directly mutating each node's value array and removing only emptied nodes.
+
+### Fixed
+- **`MultiRBTree#clear`**: Fixed `@value_count` not being reset when `clear` was called, which caused `size` to return incorrect values after clearing and re-inserting.
+
 ## [0.3.5] - 2026-01-26
 
 ### Optimized
@@ -230,6 +252,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - ASCII diagrams for tree rotation operations
 - MIT License (Copyright © 2026 Masahito Suzuki)
 
+[0.4.0]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.4.0
 [0.3.5]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.5
 [0.3.4]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.4
 [0.3.3]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.3.3

data/README.ja.md

@@ -197,10 +197,58 @@ tree.to_a  # => [[1, "one"], [2, "two"]]
 # ハッシュへの変換
 tree.to_h  # => {1 => "one", 2 => "two"}
 
-# 他のツリー、ハッシュ、またはEnumerableの結合
+# 結合（破壊的）
 other = {3 => 'three'}
 tree.merge!(other)
 tree.size  # => 3
+
+# 結合（非破壊） — 新しいツリーを返す
+merged = tree.merge({4 => 'four'})
+
+# ブロックで重複キーの解決
+merged = tree.merge({1 => 'ONE'}) { |key, old_val, new_val| old_val }
+
+# キーと値を入れ替え
+tree = RBTree.new({1 => 'a', 2 => 'b', 3 => 'c'})
+tree.invert.to_a  # => [["a", 1], ["b", 2], ["c", 3]]
+```
+
+### フィルタリングとコピー
+
+> **注記:** `dup`、`select`、`reject`、`delete_if`、`reject!`、`keep_if`、`invert`、`merge` は既存のプリミティブを組み合わせた利便性メソッドです。手動で同等の処理を書いた場合と比べて速度上の利点はありません。可読性とAPI互換性のために提供されています。
+
+Rubyの慣習的なメソッドでツリーのコピーやフィルタリングが可能です:
+
+```ruby
+tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
+
+# ディープコピー — 元のツリーと独立
+copy = tree.dup
+copy.delete(1)
+tree.size  # => 4 (変更なし)
+
+# select / reject — 新しいツリーを返す
+evens = tree.select { |k, _| k.even? }   # => {2=>"two", 4=>"four"}
+odds  = tree.reject { |k, _| k.even? }   # => {1=>"one", 3=>"three"}
+
+# delete_if / keep_if — 破壊的に変更
+tree.delete_if { |k, _| k > 2 }
+tree.to_a  # => [[1, "one"], [2, "two"]]
+
+# reject! — delete_ifと同様だが、変更がなければnilを返す
+tree.reject! { |_, _| false }  # => nil
+```
+
+`MultiRBTree`では、`delete_if`と`keep_if`は個々の値単位で操作します:
+
+```ruby
+tree = MultiRBTree.new
+tree.insert(1, 'a')
+tree.insert(1, 'b')
+tree.insert(2, 'c')
+
+tree.delete_if { |k, v| k == 1 && v == 'a' }
+tree.to_a  # => [[1, "b"], [2, "c"]]  — 'a'のみ削除された
 ```
 
 ### MultiRBTree 値配列アクセス

data/README.md

@@ -197,10 +197,58 @@ tree.to_a  # => [[1, "one"], [2, "two"]]
 # Convert to Hash
 tree.to_h  # => {1 => "one", 2 => "two"}
 
-# Merge another tree, hash, or enumerable
+# Merge (destructive)
 other = {3 => 'three'}
 tree.merge!(other)
 tree.size  # => 3
+
+# Merge (non-destructive) — returns a new tree
+merged = tree.merge({4 => 'four'})
+
+# Merge with block for duplicate key resolution
+merged = tree.merge({1 => 'ONE'}) { |key, old_val, new_val| old_val }
+
+# Invert keys and values
+tree = RBTree.new({1 => 'a', 2 => 'b', 3 => 'c'})
+tree.invert.to_a  # => [["a", 1], ["b", 2], ["c", 3]]
+```
+
+### Filtering and Copying
+
+> **Note:** `dup`, `select`, `reject`, `delete_if`, `reject!`, `keep_if`, `invert`, and `merge` are convenience methods composed from existing primitives. They provide no speed advantage over manual composition — their value is in readability and API completeness.
+
+Create copies or filter trees using familiar Ruby idioms:
+
+```ruby
+tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
+
+# Deep copy — independent of original
+copy = tree.dup
+copy.delete(1)
+tree.size  # => 4 (unchanged)
+
+# select / reject — return a new tree
+evens = tree.select { |k, _| k.even? }   # => {2=>"two", 4=>"four"}
+odds  = tree.reject { |k, _| k.even? }   # => {1=>"one", 3=>"three"}
+
+# delete_if / keep_if — modify in place
+tree.delete_if { |k, _| k > 2 }
+tree.to_a  # => [[1, "one"], [2, "two"]]
+
+# reject! — like delete_if, but returns nil if nothing changed
+tree.reject! { |_, _| false }  # => nil
+```
+
+For `MultiRBTree`, `delete_if` and `keep_if` operate at individual value granularity:
+
+```ruby
+tree = MultiRBTree.new
+tree.insert(1, 'a')
+tree.insert(1, 'b')
+tree.insert(2, 'c')
+
+tree.delete_if { |k, v| k == 1 && v == 'a' }
+tree.to_a  # => [[1, "b"], [2, "c"]]  — only 'a' was removed
 ```
 
 ### MultiRBTree Value Array Access

data/lib/rbtree/version.rb

@@ -2,5 +2,5 @@
 
 class RBTree
   # The version of the rbtree-ruby gem
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end

data/lib/rbtree.rb

@@ -111,6 +111,16 @@ class RBTree
     end
   end
 
+  # Creates a deep copy of the tree.
+  # Called automatically by `dup` and `clone`.
+  #
+  # @param orig [RBTree] the original tree to copy
+  # @return [void]
+  def initialize_copy(orig)
+    initialize(overwrite: orig.instance_variable_get(:@overwrite))
+    orig.each { |k, v| insert(k, v) }
+  end
+
   # Returns a Hash containing all key-value pairs from the tree.
   #
   # @return [Hash] a new Hash with the tree's contents
@@ -369,16 +379,43 @@ class RBTree
   end
   alias :[]= :insert
   
+  # Returns a new tree containing the merged contents of self and other.
+  #
+  # When a block is given, it is called with (key, old_value, new_value) for
+  # duplicate keys, and the block's return value is used.
+  #
+  # @param other [RBTree, Hash, Enumerable] the source to merge from
+  # @yield [key, old_value, new_value] called for duplicate keys when block given
+  # @return [RBTree] a new tree with merged contents
+  def merge(other, &block)
+    dup.merge!(other, &block)
+  end
+
   # Merges the contents of another tree, hash, or enumerable into this tree.
   #
+  # When a block is given, it is called with (key, old_value, new_value) for
+  # duplicate keys, and the block's return value is used.
+  #
   # @param other [RBTree, Hash, Enumerable] the source to merge from
-  # @param overwrite [Boolean] whether to overwrite existing keys (default: true)
+  # @param overwrite [Boolean] whether to overwrite existing keys (default: true). Ignored if block given.
+  # @yield [key, old_value, new_value] called for duplicate keys when block given
   # @return [RBTree] self
-  def merge!(other, overwrite: true)
+  def merge!(other, overwrite: true, &block)
     if defined?(MultiRBTree) && other.is_a?(MultiRBTree)
       raise ArgumentError, "Cannot merge MultiRBTree into RBTree"
     end
-    insert(other, overwrite: overwrite)
+    if block
+      other_enum = other.is_a?(Hash) || other.is_a?(RBTree) ? other : other.each
+      other_enum.each do |k, v|
+        if has_key?(k)
+          insert_entry(k, block.call(k, value(k), v), overwrite: true)
+        else
+          insert_entry(k, v)
+        end
+      end
+    else
+      insert(other, overwrite: overwrite)
+    end
     self
   end
 
@@ -602,6 +639,72 @@ class RBTree
     self
   end
 
+  # Returns a new tree containing key-value pairs for which the block returns true.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [RBTree, Enumerator] a new tree with selected pairs, or Enumerator if no block
+  def select(&block)
+    return enum_for(__method__) { size } unless block_given?
+    result = self.class.new
+    each { |k, v| result.insert(k, v) if block.call(k, v) }
+    result
+  end
+
+  # Returns a new tree containing key-value pairs for which the block returns false.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [RBTree, Enumerator] a new tree with non-rejected pairs, or Enumerator if no block
+  def reject(&block)
+    return enum_for(__method__) { size } unless block_given?
+    result = self.class.new
+    each { |k, v| result.insert(k, v) unless block.call(k, v) }
+    result
+  end
+
+  # Deletes key-value pairs for which the block returns true. Returns nil if no changes were made.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [RBTree, nil, Enumerator] self if changed, nil if unchanged, or Enumerator if no block
+  def reject!(&block)
+    return enum_for(__method__) { size } unless block_given?
+    size_before = size
+    delete_if(&block)
+    size == size_before ? nil : self
+  end
+
+  # Keeps key-value pairs for which the block returns true, deleting the rest. Modifies the tree in place.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [RBTree, Enumerator] self, or Enumerator if no block
+  def keep_if(&block)
+    return enum_for(__method__) { size } unless block_given?
+    each(safe: true) { |k, v| delete(k) unless block.call(k, v) }
+    self
+  end
+
+  # Deletes key-value pairs for which the block returns true. Modifies the tree in place.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [RBTree, Enumerator] self, or Enumerator if no block
+  def delete_if(&block)
+    return enum_for(__method__) { size } unless block_given?
+    each(safe: true) { |k, v| delete(k) if block.call(k, v) }
+    self
+  end
+
+  # Returns a new tree with keys and values swapped.
+  #
+  # For RBTree, duplicate values result in later keys overwriting earlier ones.
+  # For MultiRBTree, all key-value pairs are preserved.
+  # Values must implement <=> to serve as keys in the new tree.
+  #
+  # @return [RBTree, MultiRBTree] a new tree with keys and values inverted
+  def invert
+    result = self.class.new
+    each { |k, v| result.insert(v, k) }
+    result
+  end
+
   # Returns a string representation of the tree.
   #
   # Shows the first 5 entries and total size. Useful for debugging.
@@ -1516,6 +1619,13 @@ class MultiRBTree < RBTree
   # Returns the number of values stored in the tree.
   # @return [Integer] the number of values in the tree
   def size = @value_count
+
+  # Removes all elements from the tree.
+  # @return [MultiRBTree] self
+  def clear
+    @value_count = 0
+    super
+  end
   
   # Returns the minimum key-value pair without removing it.
   #
@@ -1718,9 +1828,46 @@ class MultiRBTree < RBTree
     [key, val]
   end
 
+  # Keeps key-value pairs for which the block returns true, deleting the rest.
+  # Unlike RBTree, this removes individual values rather than entire keys.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [MultiRBTree, Enumerator] self, or Enumerator if no block
+  def keep_if(&block)
+    return enum_for(__method__) { size } unless block_given?
+    filter_values! { |k, v| block.call(k, v) }
+    self
+  end
+
+  # Deletes key-value pairs for which the block returns true.
+  # Unlike RBTree, this removes individual values rather than entire keys.
+  #
+  # @yield [key, value] each key-value pair
+  # @return [MultiRBTree, Enumerator] self, or Enumerator if no block
+  def delete_if(&block)
+    return enum_for(__method__) { size } unless block_given?
+    filter_values! { |k, v| !block.call(k, v) }
+    self
+  end
+
   # @!visibility private
   private
 
+  # Filters values in-place across all nodes.
+  # Keeps only values for which the block returns true.
+  # Removes nodes whose value arrays become empty.
+  # Updates @value_count accordingly.
+  def filter_values!
+    keys_to_delete = []
+    @hash_index.each do |key, node|
+      before = node.value.size
+      node.value.select! { |v| yield key, v }
+      @value_count -= before - node.value.size
+      keys_to_delete << key if node.value.empty?
+    end
+    keys_to_delete.each { |k| delete_indexed_node(k) }
+  end
+
   # Inserts a value for the given key.
   #
   # If the key already exists, the value is appended to its list.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbtree-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Masahito Suzuki