factbase 0.19.6 → 0.19.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99e8fdb60e5fb1e8083b76db845cfad8a7b6be35700c543819ce631f8ac3ca19
-  data.tar.gz: 1fd106429c8a3aa39e56683060b5e61395e705abe336290da63fb1a35e748ec5
+  metadata.gz: 6c38336019e70a00d0845dfdbcc4a0fb033a4be8c3fd0ff8595c3de8bdc25cc1
+  data.tar.gz: 55b820f5d37a074a1a5f7ca2f9dafeb8d5180cdfd52ee354a855e2c402398d7d
 SHA512:
-  metadata.gz: e03d29fb285a301e48723690f3bdad751a0bc229bd559d901e22fdb196a4e263d5b75bbc6fef2da5480f07f1a4d22d510e630f7f7a7af8988d2b981d6a4b0b10
-  data.tar.gz: c41be62abd514f4ea0fde5e47fba206f27a8bd89a82a17e03c55a3908e5d9c98e909eca6bb571e183f8c2f11421617f0a20b31db132c1107a91eea0fb12cb0c1
+  metadata.gz: 5a018f96e8929e0a3a7946ad4b25cfdaf042c968cad1e0689d484235ab9aaa3b29b3a17557673e9c8b7ba32226a2746a7b0f1fa5ea1e27700aa96cfa18fa7580
+  data.tar.gz: a1dc92d273a4a6a6a870dd050a20fd23e2d06175861a2c094a45c68a80deaee479adb98ab027df1bee7791eb48e03bf520523be999ab49b88b2d4a57e0f29ddd

data/Gemfile.lock

@@ -34,7 +34,7 @@ GEM
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
-    loog (0.7.2)
+    loog (0.8.0)
       ellipsized
       logger (~> 1.0)
     minitest (6.0.1)
@@ -62,7 +62,7 @@ GEM
     psych (5.3.1)
       date
       stringio
-    qbash (0.7.2)
+    qbash (0.8.0)
       backtrace (> 0)
       elapsed (> 0)
       loog (> 0)
@@ -76,7 +76,7 @@ GEM
       tsort
     regexp_parser (2.11.3)
     rexml (3.4.4)
-    rubocop (1.84.1)
+    rubocop (1.84.2)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)

data/README.md

@@ -227,52 +227,89 @@ This is the result of the benchmark:
 ```text
                                                                        
 query all facts from an empty factbase                             0.00
-insert 20000 facts                                                 0.67
+insert 20000 facts                                                 0.63
 export 20000 facts                                                 0.02
-import 410821 bytes (20000 facts)                                  0.01
-insert 10 facts                                                    0.04
-query 10 times w/txn                                               2.36
-query 10 times w/o txn                                             0.07
-modify 10 attrs w/txn                                              1.71
-delete 10 facts w/txn                                              3.38
-build index on 5000 facts                                          0.05
-export 5000 facts with index                                       0.05
+import 411003 bytes (20000 facts)                                  0.01
+insert 10 facts                                                    0.03
+query 10 times w/txn                                               2.03
+query 10 times w/o txn                                             0.13
+modify 10 attrs w/txn                                              1.51
+delete 10 facts w/txn                                              2.97
+build index on 5000 facts                                          0.03
+export 5000 facts with index                                       0.04
 import 5000 facts with persisted index                             0.03
-query 5000 facts using persisted index                             0.10
-export 5000 facts without index                                    0.00
+query 5000 facts using persisted index                             0.07
+export 5000 facts without index                                    0.01
 import 5000 facts without index                                    0.01
-query 5000 facts building index on-the-fly                         0.09
-(and (eq what 'issue-was-closed') (exists... -> 200                1.11
+query 5000 facts building index on-the-fly                         0.07
+query 15k facts  sel: 20%  card: 10  absent plain                  0.61
+query 15k facts  sel: 20%  card: 10  absent indexed(cold)          0.16
+query 15k facts  sel: 20%  card: 10  absent indexed(warm)          0.13
+query 15k facts  sel: 20%  card: 10  exists plain                  0.56
+query 15k facts  sel: 20%  card: 10  exists indexed(cold)          0.14
+query 15k facts  sel: 20%  card: 10  exists indexed(warm)          0.13
+query 15k facts  sel: 20%  card: 10  eq plain                      0.83
+query 15k facts  sel: 20%  card: 10  eq indexed(cold)              0.22
+query 15k facts  sel: 20%  card: 10  eq indexed(warm)              0.24
+query 15k facts  sel: 20%  card: 10  not plain                     1.11
+query 15k facts  sel: 20%  card: 10  not indexed(cold)             0.50
+query 15k facts  sel: 20%  card: 10  not indexed(warm)             0.43
+query 15k facts  sel: 20%  card: 10  gt plain                      0.84
+query 15k facts  sel: 20%  card: 10  gt indexed(cold)              0.26
+query 15k facts  sel: 20%  card: 10  gt indexed(warm)              0.19
+query 15k facts  sel: 20%  card: 10  lt plain                      0.84
+query 15k facts  sel: 20%  card: 10  lt indexed(cold)              0.27
+query 15k facts  sel: 20%  card: 10  lt indexed(warm)              0.20
+query 15k facts  sel: 20%  card: 10  and eq plain                  1.39
+query 15k facts  sel: 20%  card: 10  and eq indexed(cold)          0.85
+query 15k facts  sel: 20%  card: 10  and eq indexed(warm)          0.46
+query 15k facts  sel: 20%  card: 10  and complex plain             1.32
+query 15k facts  sel: 20%  card: 10  and complex indexed(cold)     0.48
+query 15k facts  sel: 20%  card: 10  and complex indexed(warm)     0.43
+query 15k facts  sel: 20%  card: 10  one plain                     0.72
+query 15k facts  sel: 20%  card: 10  one indexed(cold)             0.19
+query 15k facts  sel: 20%  card: 10  one indexed(warm)             0.15
+query 15k facts  sel: 20%  card: 10  or plain                      2.02
+query 15k facts  sel: 20%  card: 10  or indexed(cold)              0.42
+query 15k facts  sel: 20%  card: 10  or indexed(warm)              0.36
+query 15k facts  sel: 20%  card: 10  unique plain                  1.86
+query 15k facts  sel: 20%  card: 10  unique indexed(cold)          0.61
+query 15k facts  sel: 20%  card: 10  unique indexed(warm)          0.37
+(and (eq what 'issue-was-closed') (exists... -> 200                1.04
 (and (eq what 'issue-was-closed') (exists... -> 200/txn            1.23
-(and (eq what 'issue-was-closed') (exists... -> zero               1.18
-(and (eq what 'issue-was-closed') (exists... -> zero/txn           1.30
-transaction rollback on factbase with 100000 facts                 0.28
-(gt time '2024-03-23T03:21:43Z')                                   0.37
-(gt cost 50)                                                       0.18
+(and (eq what 'issue-was-closed') (exists... -> zero               1.06
+(and (eq what 'issue-was-closed') (exists... -> zero/txn           1.23
+transaction rollback on factbase with 100000 facts                 0.26
+(gt time '2024-03-23T03:21:43Z')                                   0.22
+(gt cost 50)                                                       0.10
 (eq title 'Object Thinking 5000')                                  0.03
-(and (eq foo 42.998) (or (gt bar 200) (absent z...                 0.03
-(and (exists foo) (not (exists blue)))                             1.73
-(eq id (agg (always) (max id)))                                    2.77
-(join "c<=cost,b<=bar" (eq id (agg (always) (ma...                 4.70
-(and (eq what "foo") (join "w<=what" (and (eq i...                 7.58
-delete!                                                            0.51
-(and (eq issue *) (eq repository *) (eq what '*') (eq where '*'))  0.43
+(and (eq foo 42.998) (or (gt bar 200) (absent z...                 0.02
+(and (exists foo) (not (exists blue)))                             1.12
+(eq id (agg (always) (max id)))                                    2.76
+(join "c<=cost,b<=bar" (eq id (agg (always) (ma...                 4.58
+(and (eq what "foo") (join "w<=what" (and (eq i...                 7.26
+delete!                                                            0.42
+(and (eq issue *) (eq repository *) (eq what '*') (eq where '*'))  0.38
 Taped.append() x50000                                              0.02
-Taped.each() x125                                                  1.15
-Taped.delete_if() x375                                             0.97
-50000 facts: read-only txn (no copy needed)                        5.30
-50000 facts: rollback txn (no copy needed)                         5.16
-50000 facts: insert in txn (copy triggered)                        3.23
-50000 facts: modify in txn (copy triggered)                       34.56
-100000 facts: read-only txn (no copy needed)                      12.28
-100000 facts: rollback txn (no copy needed)                       12.19
-100000 facts: insert in txn (copy triggered)                       6.57
-100000 facts: modify in txn (copy triggered)                      70.11
+Taped.each() x125                                                  1.08
+Taped.delete_if() x375                                             0.86
+50000 facts: plain read (no txn)                                   4.06
+50000 facts: read-only txn (no copy)                               4.85
+50000 facts: plain insert (no txn)                                 0.00
+50000 facts: insert in txn (copy triggered)                        3.31
+50000 facts: plain modify (no txn)                                28.21
+50000 facts: modify in txn (copy triggered)                       35.14
+100000 facts: plain read (no txn)                                  8.06
+100000 facts: read-only txn (no copy)                              9.94
+100000 facts: plain insert (no txn)                                0.00
+100000 facts: insert in txn (copy triggered)                       6.68
+100000 facts: plain modify (no txn)                               56.21
+100000 facts: modify in txn (copy triggered)                      70.09
 ```
 
 The results were calculated in [this GHA job][benchmark-gha]
-on 2026-02-04 at 05:19,
+on 2026-02-17 at 18:48,
 on Linux with 4 CPUs.
 <!-- benchmark_end -->
 
-[benchmark-gha]: https://github.com/yegor256/factbase/actions/runs/21659492807
+[benchmark-gha]: https://github.com/yegor256/factbase/actions/runs/22111136309

data/lib/factbase/indexed/indexed_absent.rb

@@ -11,25 +11,21 @@ class Factbase::IndexedAbsent
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    prop = @term.operands[0].to_s
+    key = [maps.object_id, prop, @term.op]
+    @idx[key] ||= { facts: [], count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: [], indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        entry[:facts] << m if m[prop].nil?
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    if maps.respond_to?(:ensure_copied!)
-      maps & entry[:facts]
-    else
-      (maps & []) | entry[:facts]
+    _feed(maps.to_a, entry, prop)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |f|
+      entry[:facts] << f if f[prop].nil?
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_and.rb

@@ -43,12 +43,7 @@ class Factbase::IndexedAnd
         end
       )
       j = tuples.flat_map { |t| entry[:index][t] || [] }.uniq(&:object_id)
-      r =
-        if maps.respond_to?(:inserted)
-          maps & j
-        else
-          j
-        end
+      r = maps.respond_to?(:repack) ? maps.repack(j) : j
     else
       @term.operands.each do |o|
         n = o.predict(maps, fb, params)
@@ -56,7 +51,8 @@ class Factbase::IndexedAnd
         if r.nil?
           r = n
         elsif n.size < r.size * 8 # to skip some obvious matchings
-          r &= n.to_a
+          ids = n.to_set(&:object_id)
+          r = r.select { |f| ids.include?(f.object_id) }
         end
         break if r.size < maps.size / 32 # it's already small enough
         break if r.size < 128 # it's obviously already small enough

data/lib/factbase/indexed/indexed_eq.rb

@@ -11,37 +11,18 @@ class Factbase::IndexedEq
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
+    first_operand = @term.operands[0]
+    second_operand = @term.operands[1]
+    return unless first_operand.is_a?(Symbol) && _scalar?(second_operand)
+    first_operand = first_operand.to_s
+    key = [maps.object_id, first_operand, @term.op]
+    @idx[key] ||= { facts: {}, count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { index: {}, indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        m[prop]&.each do |v|
-          entry[:index][v] ||= []
-          entry[:index][v] << m
-        end
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    vv =
-      if @term.operands[1].is_a?(Symbol)
-        params[@term.operands[1].to_s] || []
-      else
-        [@term.operands[1]]
-      end
-    j = vv.flat_map { |v| entry[:index][v] || [] }.uniq(&:object_id)
-    if maps.respond_to?(:inserted)
-      maps & j
-    else
-      j
-    end
+    _feed(maps.to_a, entry, first_operand)
+    keys = _resolve(second_operand, params)
+    matches = keys.flat_map { |k| entry[:facts][k] || [] }
+    matches = matches.uniq(&:object_id) if keys.size > 1
+    maps.respond_to?(:repack) ? maps.repack(matches) : matches
   end
 
   private
@@ -49,4 +30,20 @@ class Factbase::IndexedEq
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, operand)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |m|
+      m[operand]&.each do |v|
+        entry[:facts][v] ||= []
+        entry[:facts][v] << m
+      end
+    end
+    entry[:count] = facts.size
+  end
+
+  def _resolve(operand, params)
+    return Array(operand) unless operand.is_a?(Symbol)
+    params[operand.to_s] || []
+  end
 end

data/lib/factbase/indexed/indexed_exists.rb

@@ -20,14 +20,13 @@ class Factbase::IndexedExists
     key = [maps.object_id, operand, @term.op]
     @idx[key] = { facts: [], count: 0 } if @idx[key].nil?
     entry = @idx[key]
-    feed(maps.to_a, entry, operand)
-    return maps.repack(entry[:facts]) if maps.respond_to?(:repack)
-    entry[:facts]
+    _feed(maps.to_a, entry, operand)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
   end
 
   private
 
-  def feed(facts, entry, operand)
+  def _feed(facts, entry, operand)
     facts[entry[:count]..].each do |m|
       entry[:facts] << m unless m[operand].nil?
     end

data/lib/factbase/indexed/indexed_gt.rb

@@ -11,36 +11,17 @@ class Factbase::IndexedGt
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
-    prop = @term.operands.first.to_s
-    cache_key = [maps.object_id, @term.operands.first, :sorted]
-    entry = @idx[cache_key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { sorted: [], indexed_count: 0 }
-      @idx[cache_key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      maps_array[entry[:indexed_count]..].each do |m|
-        values = m[prop]
-        next if values.nil?
-        values.each do |v|
-          entry[:sorted] << [v, m]
-        end
-      end
-      entry[:sorted].sort_by! { |pair| pair[0] }
-      entry[:indexed_count] = maps_array.size
-    end
-    threshold = @term.operands[1].is_a?(Symbol) ? params[@term.operands[1].to_s]&.first : @term.operands[1]
-    return nil if threshold.nil?
-    i = entry[:sorted].bsearch_index { |pair| pair[0] > threshold } || entry[:sorted].size
-    result = entry[:sorted][i..].map { |pair| pair[1] }.uniq
-    if maps.respond_to?(:ensure_copied!)
-      maps & result
-    else
-      (maps & []) | result
-    end
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
   end
 
   private
@@ -48,4 +29,21 @@ class Factbase::IndexedGt
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v > target }
+    return [] if idx.nil?
+    entry[:facts][idx..].map { |_, f| f }.uniq(&:object_id)
+  end
 end

data/lib/factbase/indexed/indexed_lt.rb

@@ -11,41 +11,17 @@ class Factbase::IndexedLt
   end
 
   def predict(maps, _fb, params)
-    return nil if @idx.nil?
-    return unless @term.operands.first.is_a?(Symbol) && _scalar?(@term.operands[1])
-    prop = @term.operands.first.to_s
-    cache_key = [maps.object_id, @term.operands.first, :sorted]
-    entry = @idx[cache_key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { sorted: [], indexed_count: 0 }
-      @idx[cache_key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      new_pairs = []
-      maps_array[entry[:indexed_count]..].each do |m|
-        values = m[prop]
-        next if values.nil?
-        values.each do |v|
-          new_pairs << [v, m]
-        end
-      end
-      unless new_pairs.empty?
-        entry[:sorted].concat(new_pairs)
-        entry[:sorted].sort_by! { |pair| pair[0] }
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-
-    threshold = @term.operands[1].is_a?(Symbol) ? params[@term.operands[1].to_s]&.first : @term.operands[1]
-    return nil if threshold.nil?
-    i = entry[:sorted].bsearch_index { |pair| pair[0] >= threshold } || entry[:sorted].size
-    result = entry[:sorted][0...i].map { |pair| pair[1] }.uniq
-    if maps.respond_to?(:ensure_copied!)
-      maps & result
-    else
-      (maps & []) | result
-    end
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
   end
 
   private
@@ -53,4 +29,21 @@ class Factbase::IndexedLt
   def _scalar?(item)
     item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
   end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v >= target }
+    res = idx.nil? ? entry[:facts] : entry[:facts][0...idx]
+    res.map { |_, f| f }.uniq(&:object_id)
+  end
 end

data/lib/factbase/indexed/indexed_not.rb

@@ -11,33 +11,30 @@ class Factbase::IndexedNot
   end
 
   def predict(maps, fb, params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    sub = @term.operands.first
+    key = [maps.object_id, sub, @term.op]
+    @idx[key] ||= { facts: nil, count: 0, yes_set: nil }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: nil, indexed_count: 0, yes_set: nil }
-      @idx[key] = entry
+    _feed(maps.to_a, entry) do
+      sub.predict(maps, fb, params)
     end
-    if entry[:indexed_count] < maps_array.size
-      yes = @term.operands.first.predict(maps, fb, params)
-      if yes.nil?
-        entry[:facts] = nil
-        entry[:yes_set] = nil
-      else
-        yes_set = yes.to_a.to_set
-        entry[:yes_set] = yes_set
-        entry[:facts] = maps_array.reject { |m| yes_set.include?(m) }
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    r = entry[:facts]
-    if r.nil?
-      nil
-    elsif maps.respond_to?(:ensure_copied!)
-      maps & r
+    return nil if entry[:facts].nil?
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry)
+    return unless entry[:count] < facts.size
+    yes = yield
+    if yes.nil?
+      entry[:facts] = nil
+      entry[:yes_set] = nil
     else
-      (maps & []) | r
+      yes_set = yes.to_a.to_set
+      entry[:yes_set] = yes_set
+      entry[:facts] = facts.reject { |m| yes_set.include?(m) }
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_one.rb

@@ -11,25 +11,21 @@ class Factbase::IndexedOne
   end
 
   def predict(maps, _fb, _params)
-    return nil if @idx.nil?
-    key = [maps.object_id, @term.operands.first, @term.op]
+    prop = @term.operands.first.to_s
+    key = [maps.object_id, prop, @term.op]
+    @idx[key] ||= { facts: [], count: 0 }
     entry = @idx[key]
-    maps_array = maps.to_a
-    if entry.nil?
-      entry = { facts: [], indexed_count: 0 }
-      @idx[key] = entry
-    end
-    if entry[:indexed_count] < maps_array.size
-      prop = @term.operands.first.to_s
-      maps_array[entry[:indexed_count]..].each do |m|
-        entry[:facts] << m if !m[prop].nil? && m[prop].size == 1
-      end
-      entry[:indexed_count] = maps_array.size
-    end
-    if maps.respond_to?(:ensure_copied!)
-      maps & entry[:facts]
-    else
-      (maps & []) | entry[:facts]
+    _feed(maps.to_a, entry, prop)
+    maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
+  end
+
+  private
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |f|
+      entry[:facts] << f if !f[prop].nil? && f[prop].size == 1
     end
+    entry[:count] = facts.size
   end
 end

data/lib/factbase/indexed/indexed_unique.rb

@@ -33,12 +33,8 @@ class Factbase::IndexedUnique
     idx_key = [maps.object_id, @term.op.to_s, bucket_key]
     entry = (@idx[idx_key] ||= { buckets: {}, count: 0 })
     feed(maps.to_a, entry, operands, bucket_key)
-    bucket = entry[:buckets][bucket_key]
-    if maps.respond_to?(:ensure_copied!)
-      maps & (bucket[:facts] || [])
-    else
-      (maps & []) | (bucket[:facts] || [])
-    end
+    matches = entry[:buckets][bucket_key][:facts]
+    maps.respond_to?(:repack) ? maps.repack(matches) : matches
   end
 
   private

data/lib/factbase/lazy_taped_array.rb

@@ -7,10 +7,6 @@ require_relative '../factbase'
 
 class Factbase::LazyTaped
   # Decorator of Array that triggers copy-on-write.
-  # @todo #424:30min Add dedicated unit tests for LazyTapedArray class.
-  #  Currently this class is tested indirectly through LazyTaped tests.
-  #  We should add explicit tests for all public methods including each, [],
-  #  to_a, any?, <<, and uniq! to ensure proper copy-on-write behavior.
   class LazyTapedArray
     # Creates a new lazy array wrapper.
     # @param origin [Array] The original array to wrap

data/lib/factbase/lazy_taped_hash.rb

@@ -8,10 +8,6 @@ require_relative 'lazy_taped_array'
 
 class Factbase::LazyTaped
   # Decorator of Hash that triggers copy-on-write.
-  # @todo #424:30min Add dedicated unit tests for LazyTapedHash class.
-  #  Currently this class is tested indirectly through LazyTaped tests.
-  #  We should add explicit tests for all public methods including keys, map,
-  #  bracket access, bracket assignment, and the copy-on-write behavior.
   class LazyTapedHash
     # Creates a new LazyTapedHash decorator.
     # @param origin [Hash] The original hash being wrapped (not yet copied)

data/lib/factbase/version.rb

@@ -9,5 +9,5 @@
 # License:: MIT
 class Factbase
   # Current version of the gem (changed by .rultor.yml on every release)
-  VERSION = '0.19.6' unless const_defined?(:VERSION)
+  VERSION = '0.19.7' unless const_defined?(:VERSION)
 end

data/lib/fuzz.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Fuzzing generator for Factbase.
+#
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Author:: Philip Belousov (belousovfilip@gmail.com)
+# Copyright:: Copyright (c) 2024-2026 Yegor Bugayenko
+# License:: MIT
+class Factbase::Fuzz
+  LABELS = ['bug', 'enhancement', 'documentation', 'duplicate', 'question', 'good first issue', 'help wanted'].freeze
+  AUTHORS = ['Noah Williams', 'Mason Jones', 'Rocket Man 🚀', 'Иван Иванович', '黒さん', 'Σωκράτης', 'المنطق سي'].freeze
+  TITLES = ['Clean Code', 'Adding more elegance', 'Удаление статики', 'Re de Müller-Lyer', '纯代码', '✨✨✨'].freeze
+  MESSAGES = [
+    'Good point, thanks',
+    'This is not an object, it is a data holder!',
+    'Why is this method static? Please refactor.',
+    'I dont like this name. It is not a noun.',
+    'Please add a unit test for this change.',
+    'NULL is evil, never use it here.',
+    'Pure elegance! Very object-oriented.',
+    'Finally, a clean decorator! Good job.',
+    'Exquisite! No getters, no setters, just behavior.',
+    'This PR makes me happy. It is very elegant.',
+    'Исправь кодировку!',
+    'デザインが悪い (Poor design)',
+    'C’est magnifique! ',
+    'Λογική χωρίς ',
+    'المنطق سيء للغاية',
+    'Este código no es elegante',
+    '❤️❤️❤️'
+  ].freeze
+
+  def initialize
+    @next_num = 0
+    @max_comments = 10
+    raise 'Not enough messages for fuzzing' if MESSAGES.size < @max_comments
+  end
+
+  def self.make(count = 1000)
+    raise "Count must be positive: #{count}" if count.negative?
+    fb = Factbase.new
+    Factbase::Fuzz.new.feed(fb, count)
+    fb
+  end
+
+  def feed(fb, count = 1)
+    raise "Count must be positive: #{count}" if count.negative?
+    count.times do
+      pull_request(fb, @next_num += 1)
+    end
+  end
+
+  private
+
+  def pull_request(fb, idx)
+    f = fb.insert
+    f.number = idx
+    f.ready = rand(2)
+    f.cost = rand(1..32)
+    f.kind = 'pull_request'
+    f.author = AUTHORS.sample
+    f.diff_size = rand(10..5000)
+    f.state = %w[open merged closed].sample
+    f.title = "#{TITLES.sample} in #{LABELS.sample}"
+    f.test_coverage = rand(0.0..100.0).round(2)
+    f.created_at = Time.now - rand(1..(60 * 60 * 24 * 180))
+    MESSAGES.sample(idx % (@max_comments + 1)).each do |comment|
+      f.comments = comment
+    end
+    f
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.19.6
+  version: 0.19.7
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -271,6 +271,7 @@ files:
 - lib/factbase/to_xml.rb
 - lib/factbase/to_yaml.rb
 - lib/factbase/version.rb
+- lib/fuzz.rb
 homepage: https://github.com/yegor256/factbase.rb
 licenses:
 - MIT