rbtree-ruby 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aa1d883925f6b7f608108f1f916598aa04be013aee415c06dfc7bda35d6986c
-  data.tar.gz: e935f213100c933b42a3cf0d709809d5ca8d536db56d6e27a6b3de9681847ad9
+  metadata.gz: ea4c407bb808b5f0ce61e05d95bdb1b9a7efce1a6db4ef6c5688016d39eb66a1
+  data.tar.gz: 1dec0818d2844494de2daf36cca3b018d28589316b580d71879756e34ca3adb0
 SHA512:
-  metadata.gz: 419f0270137b6a6ae39bd73d5ea0c4cc25ff0769c288619ee795d172e724040c6032c09c952745b9bb871ff082861c00ae879fa6a98a571414bad87c2534cb9a
-  data.tar.gz: e403cc18d16ff9661a341fb326b3aadebc5d1a83b69ed03395b318cf6666d8de9dca24e88da2a9c231395aa7780ce57ed89902717ad1266bd1551e384872719f
+  metadata.gz: 654691a199723dd0b7426fea9165b372f4c71bcdadc8a58a90b76352b8eaade41145270ff6f88ffb37a4a22732a46b636d21515a07d4ae18b061c5d6fb154d53
+  data.tar.gz: 8e619ef4f92f440e92350748bfaadc80dc65f8a1daed06d6df1b73e20c4228ee943677496f56e9a8e413cb7081b8d98e6c7711a0b6ffe50fcbf8ab00bb65ed5a

data/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.2.0] - 2026-01-14
+
+### Added
+- **MultiRBTree**: `nearest(key, last: false)` option to choose first or last value
+
+## [0.1.8] - 2026-01-14
+
+### Changed
+- **Range Query Returns Enumerator**: `lt`, `lte`, `gt`, `gte`, `between` now return an `Enumerator` instead of an `Array` when no block is given
+  - Enables lazy evaluation: `tree.gt(100).lazy.take(5).to_a`
+  - Enables chaining: `tree.lt(50).map { |k, v| k }`
+  - Use `.to_a` to get an Array: `tree.lt(50).to_a`
+  - **Breaking**: Code using direct array access like `tree.lt(50)[0]` must change to `tree.lt(50).first`
+
 ## [0.1.7] - 2026-01-14
 
 ### Added
@@ -107,9 +121,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.2.0]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.2.0
+[0.1.8]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.8
 [0.1.7]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.7
 [0.1.6]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.6
-[0.1.5]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.5
-[0.1.4]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.4
-[0.1.3]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.3
-[0.1.2]: https://github.com/firelzrd/rbtree-ruby/releases/tag/v0.1.2

data/README.ja.md

@@ -0,0 +1,275 @@
+# rbtree-ruby
+
+🌍 *[English](README.md) | [日本語](README.ja.md)*
+
+Red-Black Tree（赤黒木）データ構造のピュアRuby実装です。挿入、削除、検索操作がO(log n)の時間計算量で実行できる、効率的な順序付きキーバリューストレージを提供します。
+
+## 特徴
+
+- **自己平衡二分探索木**: 赤黒木の性質により最適なパフォーマンスを維持
+- **順序付き操作**: 効率的な範囲クエリ、最小/最大値の取得、ソート済みイテレーション
+- **複数値サポート**: `MultiRBTree`クラスで同一キーに複数の値を格納可能
+- **ピュアRuby**: C拡張不要、あらゆるRuby実装で動作
+- **充実したドキュメント**: 使用例付きの包括的なRDocドキュメント
+
+## インストール
+
+Gemfileに以下を追加:
+
+```ruby
+gem 'rbtree-ruby'
+```
+
+実行:
+
+```bash
+bundle install
+```
+
+または直接インストール:
+
+```bash
+gem install rbtree-ruby
+```
+
+## 使い方
+
+### 基本的なRBTree
+
+```ruby
+require 'rbtree'
+
+# 空のツリーを作成
+tree = RBTree.new
+
+# データで初期化
+tree = RBTree.new({3 => 'three', 1 => 'one', 2 => 'two'})
+tree = RBTree[[5, 'five'], [4, 'four']]
+
+# 値の挿入と取得
+tree.insert(10, 'ten')
+tree[20] = 'twenty'
+puts tree[10]  # => "ten"
+
+# ソート順でイテレーション
+tree.each { |key, value| puts "#{key}: #{value}" }
+# 出力:
+# 1: one
+# 2: two
+# 3: three
+# 10: ten
+# 20: twenty
+
+# 最小値と最大値
+tree.min  # => [1, "one"]
+tree.max  # => [20, "twenty"]
+
+# 範囲クエリ（Enumeratorを返す、配列には.to_aを使用）
+tree.lt(10).to_a   # => [[1, "one"], [2, "two"], [3, "three"]]
+tree.gte(10).to_a  # => [[10, "ten"], [20, "twenty"]]
+tree.between(2, 10).to_a  # => [[2, "two"], [3, "three"], [10, "ten"]]
+
+# shiftとpop
+tree.shift  # => [1, "one"] (最小値を削除)
+tree.pop    # => [20, "twenty"] (最大値を削除)
+
+# 削除
+tree.delete(3)  # => "three"
+
+# キーの存在確認
+tree.has_key?(2)  # => true
+tree.size         # => 2
+```
+
+### MultiRBTree（重複キー対応）
+
+```ruby
+require 'rbtree'
+
+tree = MultiRBTree.new
+
+# 同じキーに複数の値を挿入
+tree.insert(1, 'first one')
+tree.insert(1, 'second one')
+tree.insert(1, 'third one')
+tree.insert(2, 'two')
+
+tree.size  # => 4 (キーバリューペアの総数)
+
+# 最初の値を取得
+tree.get(1)      # => "first one"
+tree[1]          # => "first one"
+
+# キーの全ての値を取得
+tree.get_all(1)  # => ["first one", "second one", "third one"]
+
+# 全キーバリューペアをイテレーション
+tree.each { |k, v| puts "#{k}: #{v}" }
+# 出力:
+# 1: first one
+# 1: second one
+# 1: third one
+# 2: two
+
+# 最初の値のみ削除
+tree.delete_one(1)  # => "first one"
+tree.get(1)         # => "second one"
+
+# キーの全ての値を削除
+tree.delete(1)      # 残りの値を全て削除
+```
+
+### 最近傍キー検索
+
+```ruby
+tree = RBTree.new({1 => 'one', 5 => 'five', 10 => 'ten'})
+
+tree.nearest(4)   # => [5, "five"]  (4に最も近いキー)
+tree.nearest(7)   # => [5, "five"]  (同距離の場合は小さいキー)
+tree.nearest(8)   # => [10, "ten"]
+```
+
+### 前後キー検索
+
+```ruby
+tree = RBTree.new({1 => 'one', 3 => 'three', 5 => 'five', 7 => 'seven'})
+
+tree.prev(5)   # => [3, "three"]  (5より小さい最大のキー)
+tree.succ(5)   # => [7, "seven"]  (5より大きい最小のキー)
+
+# キーが存在しなくても動作
+tree.prev(4)   # => [3, "three"]  (4は存在しない、4未満の最大キーを返す)
+tree.succ(4)   # => [5, "five"]   (4は存在しない、4より大きい最小キーを返す)
+
+# 境界ではnilを返す
+tree.prev(1)   # => nil (1より小さいキーなし)
+tree.succ(7)   # => nil (7より大きいキーなし)
+```
+
+### 逆順範囲クエリ
+
+範囲クエリは`Enumerator`を返し（配列には`.to_a`を使用）、`:reverse`オプションをサポート:
+
+```ruby
+tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
+
+tree.lt(3).to_a                    # => [[1, "one"], [2, "two"]]
+tree.lt(3, reverse: true).to_a     # => [[2, "two"], [1, "one"]]
+tree.lt(3).first                   # => [1, "one"] (遅延評価、配列は作成されない)
+
+# 遅延評価
+tree.gt(0).lazy.take(2).to_a  # => [[1, "one"], [2, "two"]] (最初の2件のみ計算)
+```
+
+### MultiRBTree 値配列アクセス
+
+複数の値を持つキーで、どの値にアクセスするか選択:
+
+```ruby
+tree = MultiRBTree.new
+tree.insert(1, 'first')
+tree.insert(1, 'second')
+tree.insert(1, 'third')
+
+# 最初または最後の値にアクセス
+tree.get(1)               # => "first"
+tree.get(1, last: true)   # => "third"
+tree.get_first(1)         # => "first"
+tree.get_last(1)          # => "third"
+
+# どちらの端からも削除可能
+tree.delete_first(1)      # => "first"
+tree.delete_last(1)       # => "third"  
+tree.get(1)               # => "second"
+
+# min/maxの:lastオプション
+tree.insert(2, 'a')
+tree.insert(2, 'b')
+tree.min                  # => [1, "second"] (最小キーの最初の値)
+tree.max(last: true)      # => [2, "b"]      (最大キーの最後の値)
+```
+
+## パフォーマンス
+
+主要な操作は**O(log n)**時間で実行:
+
+- `insert(key, value)` - O(log n)
+- `delete(key)` - O(log n)
+- `get(key)` / `[]` - **O(1)** (ハイブリッドハッシュインデックス)
+- `has_key?` - **O(1)** (ハイブリッドハッシュインデックス)
+- `min` - **O(1)**
+- `max` - O(log n)
+- `shift` / `pop` - O(log n)
+- `prev` / `succ` - O(log n)、O(1)ハッシュチェック付き
+
+全要素のイテレーションはO(n)時間。
+
+### メモリ効率
+
+RBTreeは内部的な**メモリプール**を使用してノードオブジェクトを再利用:
+- 頻繁な挿入・削除時のGC負荷を大幅に削減
+- 100,000回の循環操作ベンチマークで**GC時間0.0秒**を達成
+
+### RBTree vs Hash vs Array
+
+順序付き操作と空間的操作において、RBTreeは単に速いだけでなく、全く異なるクラスの性能を発揮。**50万件**でのベンチマーク:
+
+| 操作 | RBTree | Hash/Array | 高速化 | 理由 |
+|-----|--------|------------|-------|-----|
+| **最近傍検索** | **O(log n)** | O(n) スキャン | **〜8,600倍高速** | 二分探索 vs 全件スキャン |
+| **範囲クエリ** | **O(log n + k)** | O(n) フィルター | **〜540倍高速** | 部分木へ直接ジャンプ vs 全件スキャン |
+| **最小値抽出** | **O(log n)** | O(n) 検索 | **〜160倍高速** | 連続的なリバランス vs 全件スキャン |
+| **ソート済みイテレーション** | **O(n)** | O(n log n) | **無料** | 常にソート済み vs 明示的な`sort` |
+| **キー検索** | **O(1)** | O(1) | **同等** | ハイブリッドハッシュインデックス |
+
+### RBTreeを使うべき場面
+
+✅ **RBTreeが適している場合:**
+- キー順でのイテレーション
+- 高速なmin/max取得
+- 範囲クエリ（`between`, `lt`, `gt`, `lte`, `gte`）
+- 最近傍キー検索
+- 優先度キュー的な動作（キー順でshift/pop）
+
+✅ **Hashが適している場合:**
+- 高速なキーバリュー検索のみ（RBTreeも同等に高速！）
+- 順序付けが不要
+
+## APIドキュメント
+
+完全なRDocドキュメントを生成:
+
+```bash
+rdoc lib/rbtree.rb
+```
+
+`doc/index.html`をブラウザで開いてください。
+
+## 開発
+
+リポジトリをチェックアウト後、`bundle install`で依存関係をインストール:
+
+```bash
+# RDocドキュメント生成
+rake rdoc
+
+# gemのビルド
+rake build
+
+# ローカルインストール
+rake install
+```
+
+## コントリビューション
+
+バグ報告やプルリクエストはGitHubで受け付けています: https://github.com/firelzrd/rbtree-ruby
+
+## ライセンス
+
+[MIT License](https://opensource.org/licenses/MIT)でオープンソースとして公開。
+
+## 作者
+
+Masahito Suzuki (firelzrd@gmail.com)
+
+Copyright © 2026 Masahito Suzuki

data/README.md

@@ -1,5 +1,7 @@
 # rbtree-ruby
 
+🌍 *[English](README.md) | [日本語](README.ja.md)*
+
 A pure Ruby implementation of the Red-Black Tree data structure, providing efficient ordered key-value storage with O(log n) time complexity for insertion, deletion, and lookup operations.
 
 ## Features
@@ -62,10 +64,10 @@ tree.each { |key, value| puts "#{key}: #{value}" }
 tree.min  # => [1, "one"]
 tree.max  # => [20, "twenty"]
 
-# Range queries
-tree.lt(10)   # => [[1, "one"], [2, "two"], [3, "three"]]
-tree.gte(10)  # => [[10, "ten"], [20, "twenty"]]
-tree.between(2, 10)  # => [[2, "two"], [3, "three"], [10, "ten"]]
+# Range queries (return Enumerator, use .to_a for Array)
+tree.lt(10).to_a   # => [[1, "one"], [2, "two"], [3, "three"]]
+tree.gte(10).to_a  # => [[10, "ten"], [20, "twenty"]]
+tree.between(2, 10).to_a  # => [[2, "two"], [3, "three"], [10, "ten"]]
 
 # Shift and pop
 tree.shift  # => [1, "one"] (removes minimum)
@@ -148,15 +150,17 @@ tree.succ(7)   # => nil (no key larger than 7)
 
 ### Reverse Range Queries
 
-All range queries support a `:reverse` option to iterate in descending order:
+All range queries return an `Enumerator` (use `.to_a` for Array) and support a `:reverse` option:
 
 ```ruby
 tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
 
-tree.lt(3)                    # => [[1, "one"], [2, "two"]]
-tree.lt(3, reverse: true)     # => [[2, "two"], [1, "one"]]
+tree.lt(3).to_a                    # => [[1, "one"], [2, "two"]]
+tree.lt(3, reverse: true).to_a     # => [[2, "two"], [1, "one"]]
+tree.lt(3).first                   # => [1, "one"] (lazy, no array created)
 
-tree.between(1, 4, reverse: true)  # => [[4, "four"], [3, "three"], [2, "two"], [1, "one"]]
+# Lazy evaluation
+tree.gt(0).lazy.take(2).to_a  # => [[1, "one"], [2, "two"]] (only computes first 2)
 ```
 
 ### MultiRBTree Value Array Access

data/lib/rbtree/version.rb

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

data/lib/rbtree.rb

@@ -331,28 +331,20 @@ class RBTree
   # @param key [Object] the upper bound (exclusive)
   # @param reverse [Boolean] if true, iterate in descending order (default: false)
   # @yield [key, value] each matching key-value pair (if block given)
-  # @return [Array<Array(Object, Object)>, RBTree] array of [key, value] pairs if no block, self otherwise
+  # @return [Enumerator, RBTree] Enumerator if no block given, self otherwise
   # @example
   #   tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
-  #   tree.lt(3)  # => [[1, "one"], [2, "two"]]
-  #   tree.lt(3, reverse: true)  # => [[2, "two"], [1, "one"]]
+  #   tree.lt(3).to_a  # => [[1, "one"], [2, "two"]]
+  #   tree.lt(3, reverse: true).first  # => [2, "two"]
+  #   tree.lt(3) { |k, v| puts k }  # prints keys, returns self
   def lt(key, reverse: false, &block)
-    if block_given?
-      if reverse
-        traverse_lt_desc(@root, key, &block)
-      else
-        traverse_lt(@root, key, &block)
-      end
-      self
+    return enum_for(:lt, key, reverse: reverse) unless block_given?
+    if reverse
+      traverse_lt_desc(@root, key, &block)
     else
-      res = []
-      if reverse
-        traverse_lt_desc(@root, key) { |k, v| res << [k, v] }
-      else
-        traverse_lt(@root, key) { |k, v| res << [k, v] }
-      end
-      res
+      traverse_lt(@root, key, &block)
     end
+    self
   end
 
   # Retrieves all key-value pairs with keys less than or equal to the specified key.
@@ -360,28 +352,19 @@ class RBTree
   # @param key [Object] the upper bound (inclusive)
   # @param reverse [Boolean] if true, iterate in descending order (default: false)
   # @yield [key, value] each matching key-value pair (if block given)
-  # @return [Array<Array(Object, Object)>, RBTree] array of [key, value] pairs if no block, self otherwise
+  # @return [Enumerator, RBTree] Enumerator if no block given, self otherwise
   # @example
   #   tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
-  #   tree.lte(3)  # => [[1, "one"], [2, "two"], [3, "three"]]
-  #   tree.lte(3, reverse: true)  # => [[3, "three"], [2, "two"], [1, "one"]]
+  #   tree.lte(3).to_a  # => [[1, "one"], [2, "two"], [3, "three"]]
+  #   tree.lte(3, reverse: true).first  # => [3, "three"]
   def lte(key, reverse: false, &block)
-    if block_given?
-      if reverse
-        traverse_lte_desc(@root, key, &block)
-      else
-        traverse_lte(@root, key, &block)
-      end
-      self
+    return enum_for(:lte, key, reverse: reverse) unless block_given?
+    if reverse
+      traverse_lte_desc(@root, key, &block)
     else
-      res = []
-      if reverse
-        traverse_lte_desc(@root, key) { |k, v| res << [k, v] }
-      else
-        traverse_lte(@root, key) { |k, v| res << [k, v] }
-      end
-      res
+      traverse_lte(@root, key, &block)
     end
+    self
   end
 
   # Retrieves all key-value pairs with keys greater than the specified key.
@@ -389,28 +372,19 @@ class RBTree
   # @param key [Object] the lower bound (exclusive)
   # @param reverse [Boolean] if true, iterate in descending order (default: false)
   # @yield [key, value] each matching key-value pair (if block given)
-  # @return [Array<Array(Object, Object)>, RBTree] array of [key, value] pairs if no block, self otherwise
+  # @return [Enumerator, RBTree] Enumerator if no block given, self otherwise
   # @example
   #   tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
-  #   tree.gt(2)  # => [[3, "three"], [4, "four"]]
-  #   tree.gt(2, reverse: true)  # => [[4, "four"], [3, "three"]]
+  #   tree.gt(2).to_a  # => [[3, "three"], [4, "four"]]
+  #   tree.gt(2, reverse: true).first  # => [4, "four"]
   def gt(key, reverse: false, &block)
-    if block_given?
-      if reverse
-        traverse_gt_desc(@root, key, &block)
-      else
-        traverse_gt(@root, key, &block)
-      end
-      self
+    return enum_for(:gt, key, reverse: reverse) unless block_given?
+    if reverse
+      traverse_gt_desc(@root, key, &block)
     else
-      res = []
-      if reverse
-        traverse_gt_desc(@root, key) { |k, v| res << [k, v] }
-      else
-        traverse_gt(@root, key) { |k, v| res << [k, v] }
-      end
-      res
+      traverse_gt(@root, key, &block)
     end
+    self
   end
 
   # Retrieves all key-value pairs with keys greater than or equal to the specified key.
@@ -418,28 +392,19 @@ class RBTree
   # @param key [Object] the lower bound (inclusive)
   # @param reverse [Boolean] if true, iterate in descending order (default: false)
   # @yield [key, value] each matching key-value pair (if block given)
-  # @return [Array<Array(Object, Object)>, RBTree] array of [key, value] pairs if no block, self otherwise
+  # @return [Enumerator, RBTree] Enumerator if no block given, self otherwise
   # @example
   #   tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four'})
-  #   tree.gte(2)  # => [[2, "two"], [3, "three"], [4, "four"]]
-  #   tree.gte(2, reverse: true)  # => [[4, "four"], [3, "three"], [2, "two"]]
+  #   tree.gte(2).to_a  # => [[2, "two"], [3, "three"], [4, "four"]]
+  #   tree.gte(2, reverse: true).first  # => [4, "four"]
   def gte(key, reverse: false, &block)
-    if block_given?
-      if reverse
-        traverse_gte_desc(@root, key, &block)
-      else
-        traverse_gte(@root, key, &block)
-      end
-      self
+    return enum_for(:gte, key, reverse: reverse) unless block_given?
+    if reverse
+      traverse_gte_desc(@root, key, &block)
     else
-      res = []
-      if reverse
-        traverse_gte_desc(@root, key) { |k, v| res << [k, v] }
-      else
-        traverse_gte(@root, key) { |k, v| res << [k, v] }
-      end
-      res
+      traverse_gte(@root, key, &block)
     end
+    self
   end
 
   # Retrieves all key-value pairs with keys within the specified range.
@@ -450,29 +415,19 @@ class RBTree
   # @param include_max [Boolean] whether to include the upper bound (default: true)
   # @param reverse [Boolean] if true, iterate in descending order (default: false)
   # @yield [key, value] each matching key-value pair (if block given)
-  # @return [Array<Array(Object, Object)>, RBTree] array of [key, value] pairs if no block, self otherwise
+  # @return [Enumerator, RBTree] Enumerator if no block given, self otherwise
   # @example
   #   tree = RBTree.new({1 => 'one', 2 => 'two', 3 => 'three', 4 => 'four', 5 => 'five'})
-  #   tree.between(2, 4)  # => [[2, "two"], [3, "three"], [4, "four"]]
-  #   tree.between(2, 4, include_min: false)  # => [[3, "three"], [4, "four"]]
-  #   tree.between(2, 4, reverse: true)  # => [[4, "four"], [3, "three"], [2, "two"]]
+  #   tree.between(2, 4).to_a  # => [[2, "two"], [3, "three"], [4, "four"]]
+  #   tree.between(2, 4, reverse: true).first  # => [4, "four"]
   def between(min, max, include_min: true, include_max: true, reverse: false, &block)
-    if block_given?
-      if reverse
-        traverse_between_desc(@root, min, max, include_min, include_max, &block)
-      else
-        traverse_between(@root, min, max, include_min, include_max, &block)
-      end
-      self
+    return enum_for(:between, min, max, include_min: include_min, include_max: include_max, reverse: reverse) unless block_given?
+    if reverse
+      traverse_between_desc(@root, min, max, include_min, include_max, &block)
     else
-      res = []
-      if reverse
-        traverse_between_desc(@root, min, max, include_min, include_max) { |k, v| res << [k, v] }
-      else
-        traverse_between(@root, min, max, include_min, include_max) { |k, v| res << [k, v] }
-      end
-      res
+      traverse_between(@root, min, max, include_min, include_max, &block)
     end
+    self
   end
 
   # Returns the key-value pair with the key closest to the given key.
@@ -1506,9 +1461,10 @@ class MultiRBTree < RBTree
     [n.key, last ? n.value.last : n.value.first]
   end
 
-  def nearest(key)
+  def nearest(key, last: false)
     n = find_nearest_node(key)
-    n == @nil_node || n.value.empty? ? nil : [n.key, n.value.first]
+    return nil if n == @nil_node || n.value.empty?
+    [n.key, last ? n.value.last : n.value.first]
   end
 
   def prev(key, last: false)

data/rbtree-ruby.gemspec

@@ -8,11 +8,12 @@ Gem::Specification.new do |spec|
   spec.authors = ["Masahito Suzuki"]
   spec.email   = ["firelzrd@gmail.com"]
 
-  spec.summary     = "A pure Ruby implementation of Red-Black Tree with multi-value support"
+  spec.summary     = "A pure Ruby Red-Black Tree with O(1) lookup, range queries, and multi-value support"
   spec.description = <<~DESC
-    RBTree is a pure Ruby implementation of the Red-Black Tree data structure,
-    providing efficient ordered key-value storage with O(log n) operations.
-    Includes MultiRBTree for handling duplicate keys with linked lists.
+    A high-performance pure Ruby Red-Black Tree implementation. Features: O(1) key
+    lookup via hybrid hash index, O(log n) insert/delete, lazy Enumerator-based
+    range queries (lt/gt/between), nearest/prev/succ search, memory-efficient node
+    pooling, and MultiRBTree for duplicate keys with first/last value access.
   DESC
   spec.homepage = "https://github.com/firelzrd/rbtree-ruby"
   spec.license  = "MIT"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbtree-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Masahito Suzuki
@@ -10,9 +10,10 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
-  RBTree is a pure Ruby implementation of the Red-Black Tree data structure,
-  providing efficient ordered key-value storage with O(log n) operations.
-  Includes MultiRBTree for handling duplicate keys with linked lists.
+  A high-performance pure Ruby Red-Black Tree implementation. Features: O(1) key
+  lookup via hybrid hash index, O(log n) insert/delete, lazy Enumerator-based
+  range queries (lt/gt/between), nearest/prev/succ search, memory-efficient node
+  pooling, and MultiRBTree for duplicate keys with first/last value access.
 email:
 - firelzrd@gmail.com
 executables: []
@@ -21,6 +22,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
+- README.ja.md
 - README.md
 - Rakefile
 - lib/rbtree.rb
@@ -49,5 +51,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.3
 specification_version: 4
-summary: A pure Ruby implementation of Red-Black Tree with multi-value support
+summary: A pure Ruby Red-Black Tree with O(1) lookup, range queries, and multi-value
+  support
 test_files: []