factbase 0.8.0 → 0.9.1

data/test/factbase/test_query.rb

@@ -4,19 +4,65 @@
 # SPDX-License-Identifier: MIT
 
 require_relative '../test__helper'
+require 'loog'
 require 'time'
 require_relative '../../lib/factbase'
 require_relative '../../lib/factbase/query'
+require_relative '../../lib/factbase/logged'
+require_relative '../../lib/factbase/pre'
+require_relative '../../lib/factbase/inv'
+require_relative '../../lib/factbase/rules'
+require_relative '../../lib/factbase/tallied'
+require_relative '../../lib/factbase/cached/cached_factbase'
+require_relative '../../lib/factbase/indexed/indexed_factbase'
+require_relative '../../lib/factbase/sync/sync_factbase'
 
 # Query test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestQuery < Factbase::Test
+  def test_stories
+    with_factbases do |badge, fb|
+      Dir[File.join(__dir__, '../../fixtures/stories/**/*.yml')].each do |fixture|
+        base = File.basename(fixture)
+        story = YAML.load_file(fixture)
+        2.times do
+          fb.query('(always)').delete!
+          story['facts'].each do |y|
+            f = fb.insert
+            y.each do |k, vv|
+              vv = [vv] unless vv.is_a?(Array)
+              vv.each do |v|
+                f.send(:"#{k}=", v)
+              end
+            end
+          end
+          story['queries'].each do |q|
+            qry = q['query']
+            if q['size']
+              size = q['size']
+              assert_equal(size, fb.query(qry).each.to_a.size, "#{base}: #{qry} at #{badge}")
+              fb.txn do |fbt|
+                assert_equal(size, fbt.query(qry).each.to_a.size, "#{base}: #{qry} at #{badge} (in txn)")
+              end
+            else
+              ret = q['one']
+              assert_equal(ret, fb.query(qry).one, "#{base}: #{qry} at #{badge}")
+              fb.txn do |fbt|
+                assert_equal(ret, fbt.query(qry).one, "#{base}: #{qry} at #{badge} (in txn)")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
   def test_simple_parsing
     maps = []
     maps << { 'foo' => [42] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 42)')
+    q = Factbase::Query.new(maps, '(eq foo 42)', Factbase.new)
     assert_equal(
       1,
       q.each do |f|
@@ -26,12 +72,7 @@ class TestQuery < Factbase::Test
   end
 
   def test_complex_parsing
-    maps = [
-      { 'num' => [42], 'name' => ['Jeff'] },
-      { 'pi' => [3.14], 'num' => [42, 66, 0], 'name' => ['peter'] },
-      { 'time' => [Time.now - 100], 'num' => [0], 'hi' => [4], 'nome' => ['Walter'] }
-    ]
-    {
+    queries = {
       '(eq num 444)' => 0,
       '(eq hi 4)' => 1,
       '(eq time 0)' => 0,
@@ -71,11 +112,18 @@ class TestQuery < Factbase::Test
       '(undef something)' => 3,
       "(or (eq num +66) (lt time #{(Time.now - 200).utc.iso8601}))" => 1,
       '(eq 3 (agg (eq num $num) (count)))' => 1
-    }.each do |q, r|
-      fb = Factbase.new(maps)
-      assert_equal(r, fb.query(q).each.to_a.size, q)
-      fb.txn do |fbt|
-        assert_equal(r, fbt.query(q).each.to_a.size, q)
+    }
+    maps = [
+      { 'num' => [42], 'name' => ['Jeff'] },
+      { 'num' => [42, 66, 0], 'pi' => [3.14], 'name' => ['peter'] },
+      { 'num' => [0], 'time' => [Time.now - 100], 'hi' => [4], 'nome' => ['Walter'] }
+    ]
+    with_factbases(maps) do |badge, fb|
+      queries.each do |q, r|
+        assert_equal(r, fb.query(q).each.to_a.size, "#{q} in #{badge}")
+        fb.txn do |fbt|
+          assert_equal(r, fbt.query(q).each.to_a.size, "#{q} in #{badge} (txn)")
+        end
       end
     end
   end
@@ -84,7 +132,7 @@ class TestQuery < Factbase::Test
     maps = []
     now = Time.now.utc
     maps << { 'foo' => [now] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, "(eq foo #{now.iso8601})")
+    q = Factbase::Query.new(maps, "(eq foo #{now.iso8601})", Factbase.new)
     assert_equal(1, q.each.to_a.size)
   end
 
@@ -94,7 +142,7 @@ class TestQuery < Factbase::Test
       { 'bar' => [4, 5] },
       { 'bar' => [5] }
     ]
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq bar 5)')
+    q = Factbase::Query.new(maps, '(eq bar 5)', Factbase.new)
     assert_equal(2, q.delete!)
     assert_equal(1, maps.size)
   end
@@ -104,18 +152,20 @@ class TestQuery < Factbase::Test
       { 'foo' => [42] },
       { 'bar' => [4, 5] }
     ]
-    {
-      '(agg (exists foo) (first foo))' => [42],
-      '(agg (exists z) (first z))' => nil,
-      '(agg (always) (count))' => 2,
-      '(agg (eq bar $v) (count))' => 1,
-      '(agg (eq z 40) (count))' => 0
-    }.each do |q, expected|
-      result = Factbase::Query.new(Factbase.new, maps, Mutex.new, q).one(v: 4)
-      if expected.nil?
-        assert_nil(result, "#{q} -> nil")
-      else
-        assert_equal(expected, result, "#{q} -> #{expected}")
+    with_factbases(maps) do |badge, fb|
+      {
+        '(agg (exists foo) (first foo))' => [42],
+        '(agg (exists z) (first z))' => nil,
+        '(agg (always) (count))' => 2,
+        '(agg (eq bar $v) (count))' => 1,
+        '(agg (eq z 40) (count))' => 0
+      }.each do |q, expected|
+        result = fb.query(q).one(fb, v: 4)
+        if expected.nil?
+          assert_nil(result, "#{q} -> nil in #{badge}")
+        else
+          assert_equal(expected, result, "#{q} -> #{expected} in #{badge}")
+        end
       end
     end
   end
@@ -126,28 +176,30 @@ class TestQuery < Factbase::Test
       { 'bar' => [4, 5] },
       { 'bar' => [5] }
     ]
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(never)')
-    assert_equal(0, q.delete!)
-    assert_equal(3, maps.size)
+    with_factbases(maps) do |badge, fb|
+      q = fb.query('(never)')
+      assert_equal(0, q.delete!, "#{q} in #{badge}")
+      assert_equal(3, maps.size, "#{q} in #{badge}")
+    end
   end
 
   def test_to_array
     maps = []
     maps << { 'foo' => [42] }
-    assert_equal(1, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 42)').each.to_a.size)
+    assert_equal(1, Factbase::Query.new(maps, '(eq foo 42)', Factbase.new).each.to_a.size)
   end
 
   def test_returns_int
     maps = []
     maps << { 'foo' => [1] }
-    q = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo 1)')
+    q = Factbase::Query.new(maps, '(eq foo 1)', Factbase.new)
     assert_equal(1, q.each(&:to_s))
   end
 
   def test_with_aliases
     maps = []
     maps << { 'foo' => [42] }
-    assert_equal(45, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(as bar (plus foo 3))').each.to_a[0].bar)
+    assert_equal(45, Factbase::Query.new(maps, '(as bar (plus foo 3))', Factbase.new).each.to_a[0].bar)
     assert_equal(1, maps[0].size)
   end
 
@@ -157,22 +209,43 @@ class TestQuery < Factbase::Test
       { 'foo' => [17] }
     ]
     found = 0
-    Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: [42]) do
+    Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: [42]) do
       found += 1
     end
     assert_equal(1, found)
-    assert_equal(1, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: 42).to_a.size)
-    assert_equal(0, Factbase::Query.new(Factbase.new, maps, Mutex.new, '(eq foo $bar)').each(bar: 555).to_a.size)
+    assert_equal(1, Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: 42).to_a.size)
+    assert_equal(0, Factbase::Query.new(maps, '(eq foo $bar)', Factbase.new).each(Factbase.new, bar: 555).to_a.size)
   end
 
   def test_with_nil_alias
     maps = [{ 'foo' => [42] }]
-    assert_nil(Factbase::Query.new(Factbase.new, maps, Mutex.new, '(as bar (plus xxx 3))').each.to_a[0]['bar'])
+    assert_nil(Factbase::Query.new(maps, '(as bar (plus xxx 3))', Factbase.new).each.to_a[0]['bar'])
   end
 
   def test_get_all_properties
     maps = [{ 'foo' => [42] }]
-    f = Factbase::Query.new(Factbase.new, maps, Mutex.new, '(always)').each.to_a[0]
+    f = Factbase::Query.new(maps, '(always)', Factbase.new).each.to_a[0]
     assert_includes(f.all_properties, 'foo')
   end
+
+  private
+
+  def with_factbases(maps = [], &)
+    {
+      'plain' => Factbase.new(maps),
+      'pre+plain' => Factbase::Pre.new(Factbase.new(maps)) { nil },
+      'rules+plain' => Factbase::Rules.new(Factbase.new(maps), '(always)'),
+      'inv+plain' => Factbase::Inv.new(Factbase.new(maps)) { nil },
+      'sync+plain' => Factbase::SyncFactbase.new(Factbase.new(maps)),
+      'tallied+plain' => Factbase::Tallied.new(Factbase.new(maps)),
+      'indexed+plain' => Factbase::IndexedFactbase.new(Factbase.new(maps)),
+      'cached+plain' => Factbase::CachedFactbase.new(Factbase.new(maps)),
+      'logged+plain' => Factbase::Logged.new(Factbase.new(maps), Loog::NULL),
+      'indexed+cached+plain' => Factbase::IndexedFactbase.new(Factbase::CachedFactbase.new(Factbase.new(maps))),
+      'cached+indexed+plain' => Factbase::CachedFactbase.new(Factbase::IndexedFactbase.new(Factbase.new(maps))),
+      'sync+cached+indexed+plain' => Factbase::SyncFactbase.new(
+        Factbase::CachedFactbase.new(Factbase::IndexedFactbase.new(Factbase.new(maps)))
+      )
+    }.each(&)
+  end
 end

data/test/factbase/test_rules.rb

@@ -51,7 +51,7 @@ class TestRules < Factbase::Test
     fb = Factbase::Rules.new(Factbase.new, '(always)')
     f = fb.insert
     f.foo = 42
-    assert_equal(1, fb.query('(agg (eq foo $v) (count))').one(v: 42))
+    assert_equal(1, fb.query('(agg (eq foo $v) (count))').one(Factbase.new, v: 42))
   end
 
   def test_check_only_when_txn_is_closed

data/test/factbase/test_syntax.rb

@@ -18,7 +18,7 @@ class TestSyntax < Factbase::Test
       "(foo 'one two three   ')",
       "(foo 'one two three   ' 'tail tail')"
     ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(Factbase.new, q).to_term.to_s, q)
+      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
     end
   end
 
@@ -28,7 +28,7 @@ class TestSyntax < Factbase::Test
       '(foo (bar (a (b c (f $bar)))))' => true,
       '(foo (bar (a (b c (f bar)))))' => false
     }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(Factbase.new, q).to_term.abstract?)
+      assert_equal(a, Factbase::Syntax.new(q).to_term.abstract?)
     end
   end
 
@@ -38,7 +38,7 @@ class TestSyntax < Factbase::Test
       '(foo "bar")' => true,
       '(agg (always) (max id))' => true
     }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(Factbase.new, q).to_term.static?)
+      assert_equal(a, Factbase::Syntax.new(q).to_term.static?)
     end
   end
 
@@ -53,7 +53,7 @@ class TestSyntax < Factbase::Test
       "(foo 'Hello,\n\nworld!\r\t\n')\n",
       "(or ( a 4) (b 5) (always) (and (always) (c 5) \t\t(r 7 w8s w8is 'Foo')))"
     ].each do |q|
-      refute_nil(Factbase::Syntax.new(Factbase.new, q).to_term)
+      refute_nil(Factbase::Syntax.new(q).to_term)
     end
   end
 
@@ -73,7 +73,7 @@ class TestSyntax < Factbase::Test
       '(eq t 3.0e+21)',
       "(foo (x (f (t (y 42 'Hey you'))) (never) (r 3)) y z)"
     ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(Factbase.new, q).to_term.to_s, q)
+      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
     end
   end
 
@@ -88,7 +88,7 @@ class TestSyntax < Factbase::Test
       '(or (eq bar 888) (eq z 1))' => true,
       "(or (gt bar 100) (eq foo 'Hello, world!'))" => true
     }.each do |k, v|
-      assert_equal(v, Factbase::Syntax.new(Factbase.new, k).to_term.evaluate(m, []), k)
+      assert_equal(v, Factbase::Syntax.new(k).to_term.evaluate(m, [], Factbase.new), k)
     end
   end
 
@@ -113,7 +113,7 @@ class TestSyntax < Factbase::Test
       '"'
     ].each do |q|
       msg = assert_raises(q) do
-        Factbase::Syntax.new(Factbase.new, q).to_term
+        Factbase::Syntax.new(q).to_term
       end.message
       assert_includes(msg, q, msg)
     end
@@ -127,7 +127,7 @@ class TestSyntax < Factbase::Test
         '\'', 'привет'
       ].shuffle.join(' . ')
       assert_raises(Factbase::Syntax::Broken, q) do
-        Factbase::Syntax.new(Factbase.new, q).to_term
+        Factbase::Syntax.new(q).to_term
       end
     end
   end
@@ -138,21 +138,21 @@ class TestSyntax < Factbase::Test
       '(and (foo) (foo))' => '(foo)',
       '(and (foo) (or (and (eq a 1))) (eq a 1) (foo))' => '(and (foo) (eq a 1))'
     }.each do |s, t|
-      assert_equal(t, Factbase::Syntax.new(Factbase.new, s).to_term.to_s)
+      assert_equal(t, Factbase::Syntax.new(s).to_term.to_s)
     end
   end
 
   def test_fails_when_term_is_not_a_class
-    assert_raises(StandardError) { Factbase::Syntax.new(Factbase.new, '(foo 1)', term: 'hello') }
+    assert_raises(StandardError) { Factbase::Syntax.new('(foo 1)', term: 'hello') }
   end
 
   def test_fails_when_term_is_wrong_class
-    assert_raises(StandardError) { Factbase::Syntax.new(Factbase.new, '(bar 1)', term: String).to_term }
+    assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: String).to_term }
   end
 
   def test_fails_when_term_is_incorrectly_defined_class
     assert_includes(
-      assert_raises(StandardError) { Factbase::Syntax.new(Factbase.new, '(bar 1)', term: FakeTerm).to_term }.message,
+      assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: FakeTerm).to_term }.message,
       'wrong number of arguments'
     )
   end

data/test/factbase/test_tee.rb

@@ -14,9 +14,9 @@ require_relative '../../lib/factbase/fact'
 # License:: MIT
 class TestTee < Factbase::Test
   def test_two_facts
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_equal(42, t.foo)
@@ -24,9 +24,9 @@ class TestTee < Factbase::Test
   end
 
   def test_all_properties
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_includes(t.all_properties, 'foo')
@@ -35,18 +35,18 @@ class TestTee < Factbase::Test
 
   def test_recursively
     map = {}
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    prim = Factbase::Fact.new(map)
     prim.foo = 42
-    t = Factbase::Tee.new(nil, { 'bar' => 7 })
+    t = Factbase::Tee.new(Factbase::Fact.new({}), { 'bar' => 7 })
     assert_equal(7, t['$bar'])
     t = Factbase::Tee.new(prim, t)
     assert_equal(7, t['$bar'])
   end
 
   def test_prints_to_string
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_equal('[ foo: [42] ]', t.to_s)

data/test/factbase/test_term.rb

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MIT
 
 require_relative '../test__helper'
+require_relative '../../lib/factbase'
 require_relative '../../lib/factbase/term'
 
 # Term test.
@@ -12,65 +13,73 @@ require_relative '../../lib/factbase/term'
 # License:: MIT
 class TestTerm < Factbase::Test
   def test_false_matching
-    t = Factbase::Term.new(Factbase.new, :never, [])
-    refute(t.evaluate(fact('foo' => [100]), []))
+    t = Factbase::Term.new(:never, [])
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
   end
 
   def test_size_matching
-    t = Factbase::Term.new(Factbase.new, :size, [:foo])
-    assert_equal(3, t.evaluate(fact('foo' => [42, 12, -90]), []))
-    assert_equal(0, t.evaluate(fact('bar' => 100), []))
+    t = Factbase::Term.new(:size, [:foo])
+    assert_equal(3, t.evaluate(fact('foo' => [42, 12, -90]), [], Factbase.new))
+    assert_equal(0, t.evaluate(fact('bar' => 100), [], Factbase.new))
   end
 
   def test_exists_matching
-    t = Factbase::Term.new(Factbase.new, :exists, [:foo])
-    assert(t.evaluate(fact('foo' => [42, 12, -90]), []))
-    refute(t.evaluate(fact('bar' => 100), []))
+    t = Factbase::Term.new(:exists, [:foo])
+    assert(t.evaluate(fact('foo' => [42, 12, -90]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 100), [], Factbase.new))
   end
 
   def test_absent_matching
-    t = Factbase::Term.new(Factbase.new, :absent, [:foo])
-    assert(t.evaluate(fact('z' => [42, 12, -90]), []))
-    refute(t.evaluate(fact('foo' => 100), []))
+    t = Factbase::Term.new(:absent, [:foo])
+    assert(t.evaluate(fact('z' => [42, 12, -90]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
   end
 
   def test_type_matching
-    t = Factbase::Term.new(Factbase.new, :type, [:foo])
-    assert_equal('Integer', t.evaluate(fact('foo' => 42), []))
-    assert_equal('Integer', t.evaluate(fact('foo' => [42]), []))
-    assert_equal('Array', t.evaluate(fact('foo' => [1, 2, 3]), []))
-    assert_equal('String', t.evaluate(fact('foo' => 'Hello, world!'), []))
-    assert_equal('Float', t.evaluate(fact('foo' => 3.14), []))
-    assert_equal('Time', t.evaluate(fact('foo' => Time.now), []))
-    assert_equal('Integer', t.evaluate(fact('foo' => 1_000_000_000_000_000), []))
-    assert_equal('nil', t.evaluate(fact, []))
+    t = Factbase::Term.new(:type, [:foo])
+    assert_equal('Integer', t.evaluate(fact('foo' => 42), [], Factbase.new))
+    assert_equal('Integer', t.evaluate(fact('foo' => [42]), [], Factbase.new))
+    assert_equal('Array', t.evaluate(fact('foo' => [1, 2, 3]), [], Factbase.new))
+    assert_equal('String', t.evaluate(fact('foo' => 'Hello, world!'), [], Factbase.new))
+    assert_equal('Float', t.evaluate(fact('foo' => 3.14), [], Factbase.new))
+    assert_equal('Time', t.evaluate(fact('foo' => Time.now), [], Factbase.new))
+    assert_equal('Integer', t.evaluate(fact('foo' => 1_000_000_000_000_000), [], Factbase.new))
+    assert_equal('nil', t.evaluate(fact, [], Factbase.new))
   end
 
   def test_past
-    t = Factbase::Term.new(Factbase.new, :prev, [:foo])
-    assert_nil(t.evaluate(fact('foo' => 4), []))
-    assert_equal([4], t.evaluate(fact('foo' => 5), []))
+    t = Factbase::Term.new(:prev, [:foo])
+    assert_nil(t.evaluate(fact('foo' => 4), [], Factbase.new))
+    assert_equal([4], t.evaluate(fact('foo' => 5), [], Factbase.new))
   end
 
   def test_at
-    t = Factbase::Term.new(Factbase.new, :at, [1, :foo])
-    assert_nil(t.evaluate(fact('foo' => 4), []))
-    assert_equal(5, t.evaluate(fact('foo' => [4, 5]), []))
+    t = Factbase::Term.new(:at, [1, :foo])
+    assert_nil(t.evaluate(fact('foo' => 4), [], Factbase.new))
+    assert_equal(5, t.evaluate(fact('foo' => [4, 5]), [], Factbase.new))
   end
 
   def test_report_missing_term
-    t = Factbase::Term.new(Factbase.new, :something, [])
+    t = Factbase::Term.new(:something, [])
     msg = assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      t.evaluate(fact, [], Factbase.new)
     end.message
     assert_includes(msg, 'not defined at (something)', msg)
   end
 
   def test_report_other_error
-    t = Factbase::Term.new(Factbase.new, :at, [])
+    t = Factbase::Term.new(:at, [])
     msg = assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      t.evaluate(fact, [], Factbase.new)
     end.message
     assert_includes(msg, 'at (at)', msg)
   end
+
+  def test_redresses_itself
+    t = Factbase::Term.new(:something, [])
+    require_relative '../../lib/factbase/indexed/indexed_term'
+    t.redress!(Factbase::IndexedTerm)
+    require_relative '../../lib/factbase/cached/cached_term'
+    t.redress!(Factbase::CachedTerm)
+  end
 end

data/test/test__helper.rb

@@ -22,7 +22,7 @@ require_relative '../lib/factbase'
 # Default methods for all tests.
 class Factbase::Test < Minitest::Test
   def fact(map = {})
-    require 'factbase/fact'
-    Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    require_relative '../lib/factbase/fact'
+    Factbase::Fact.new(map)
   end
 end

data/test/test_factbase.rb

@@ -41,6 +41,12 @@ class TestFactbase < Factbase::Test
     end
   end
 
+  def test_converts_query_to_term
+    fb = Factbase.new
+    term = fb.to_term('(eq foo 42)')
+    assert_equal('(eq foo 42)', term.to_s)
+  end
+
   def test_simple_setting
     fb = Factbase.new
     fb.insert

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Yegor Bugayenko
 bindir: bin
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backtrace
@@ -162,24 +162,45 @@ files:
 - benchmark/bench_query.rb
 - benchmark/bench_taped.rb
 - factbase.gemspec
+- fixtures/stories/agg.yml
+- fixtures/stories/always.yml
+- fixtures/stories/as.yml
+- fixtures/stories/count.yml
+- fixtures/stories/eq.yml
+- fixtures/stories/gt.yml
+- fixtures/stories/join.yml
+- fixtures/stories/max.yml
+- fixtures/stories/min.yml
+- fixtures/stories/nth.yml
+- fixtures/stories/or.yml
+- fixtures/stories/sprintf.yml
+- fixtures/stories/sum.yml
 - lib/factbase.rb
 - lib/factbase/accum.rb
+- lib/factbase/cached/cached_fact.rb
+- lib/factbase/cached/cached_factbase.rb
+- lib/factbase/cached/cached_query.rb
+- lib/factbase/cached/cached_term.rb
 - lib/factbase/churn.rb
 - lib/factbase/fact.rb
 - lib/factbase/flatten.rb
+- lib/factbase/indexed/indexed_fact.rb
+- lib/factbase/indexed/indexed_factbase.rb
+- lib/factbase/indexed/indexed_query.rb
+- lib/factbase/indexed/indexed_term.rb
 - lib/factbase/inv.rb
 - lib/factbase/light.rb
 - lib/factbase/logged.rb
 - lib/factbase/pre.rb
 - lib/factbase/query.rb
-- lib/factbase/query_once.rb
 - lib/factbase/rules.rb
+- lib/factbase/sync/sync_factbase.rb
+- lib/factbase/sync/sync_query.rb
 - lib/factbase/syntax.rb
 - lib/factbase/tallied.rb
 - lib/factbase/taped.rb
 - lib/factbase/tee.rb
 - lib/factbase/term.rb
-- lib/factbase/term_once.rb
 - lib/factbase/terms/aggregates.rb
 - lib/factbase/terms/aliases.rb
 - lib/factbase/terms/casting.rb
@@ -195,6 +216,10 @@ files:
 - lib/factbase/to_xml.rb
 - lib/factbase/to_yaml.rb
 - renovate.json
+- test/factbase/cached/test_cached_factbase.rb
+- test/factbase/cached/test_cached_query.rb
+- test/factbase/indexed/test_indexed_query.rb
+- test/factbase/sync/test_sync_query.rb
 - test/factbase/terms/test_aggregates.rb
 - test/factbase/terms/test_aliases.rb
 - test/factbase/terms/test_casting.rb

data/lib/factbase/query_once.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../factbase'
-
-# Query with a cache, a decorator of another query.
-#
-# It is NOT thread-safe!
-#
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class Factbase::QueryOnce
-  # Constructor.
-  # @param [Factbase] fb Factbase
-  # @param [Factbase::Query] query Original query
-  # @param [Array<Hash>] maps Where to search
-  def initialize(fb, query, maps)
-    @fb = fb
-    @query = query
-    @maps = maps
-  end
-
-  # Iterate facts one by one.
-  # @param [Hash] params Optional params accessible in the query via the "$" symbol
-  # @yield [Fact] Facts one-by-one
-  # @return [Integer] Total number of facts yielded
-  def each(params = {}, &)
-    unless block_given?
-      return to_enum(__method__, params) if Factbase::Syntax.new(@fb, @query).to_term.abstract?
-      key = [@query.to_s, @maps.object_id]
-      before = @fb.cache[key]
-      @fb.cache[key] = to_enum(__method__, params).to_a if before.nil?
-      return @fb.cache[key]
-    end
-    @query.each(params, &)
-  end
-
-  # Read a single value.
-  # @param [Hash] params Optional params accessible in the query via the "$" symbol
-  # @return The value evaluated
-  def one(params = {})
-    @query.one(params)
-  end
-
-  # Delete all facts that match the query.
-  # @return [Integer] Total number of facts deleted
-  def delete!
-    @fb.cache.clear
-    @query.delete!
-  end
-end