factbase 0.7.5 → 0.9.0

data/test/factbase/indexed/test_indexed_query.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+require_relative '../../test__helper'
+require_relative '../../../lib/factbase'
+require_relative '../../../lib/factbase/cached/cached_factbase'
+require_relative '../../../lib/factbase/indexed/indexed_factbase'
+
+# Query test.
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
+# License:: MIT
+class TestIndexedQuery < Factbase::Test
+  def test_queries_many_times
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    total = 5
+    total.times { fb.insert }
+    total.times do
+      assert_equal(5, fb.query('(always)').each.to_a.size)
+    end
+  end
+
+  def test_finds_by_eq
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert
+    3.times do
+      assert_equal(1, fb.query('(eq foo 42)').each.to_a.size)
+    end
+  end
+
+  def test_finds_by_eq_with_symbol
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    f = fb.insert
+    f.num = 256
+    f.num = 42
+    fb.insert.num = 42
+    fb.insert.num = 55
+    fb.insert
+    fb.insert
+    3.times do
+      assert_equal(1, fb.query('(eq 1 (agg (eq num $num) (count)))').each.to_a.size)
+    end
+  end
+
+  def test_finds_by_eq_with_array
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    f = fb.insert
+    f.foo = 33
+    f.foo = 42
+    f.foo = 1
+    3.times do
+      assert_equal(1, fb.query('(eq foo 42)').each.to_a.size)
+    end
+  end
+
+  def test_finds_by_eq_with_agg
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.foo = 33
+    fb.insert
+    3.times do
+      assert_equal(1, fb.query('(eq foo (agg (exists foo) (max foo)))').each.to_a.size)
+    end
+  end
+
+  def test_finds_max_value
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.foo = 33
+    fb.insert
+    3.times do
+      assert_equal(42, fb.query('(agg (exists foo) (max foo))').one)
+    end
+  end
+
+  def test_finds_by_eq_with_formula
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert
+    3.times do
+      assert_equal(1, fb.query('(eq foo (plus 40 2))').each.to_a.size)
+    end
+  end
+
+  def test_finds_by_eq_in_txn
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert
+    3.times do
+      fb.txn { |fbt| assert_equal(1, fbt.query('(eq foo 42)').each.to_a.size) }
+    end
+  end
+
+  def test_finds_with_conjunction
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.bar = 33
+    3.times do
+      assert_equal(2, fb.query('(or (exists foo) (exists bar))').each.to_a.size)
+    end
+  end
+
+  def test_finds_with_disjunction
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.bar = 33
+    f = fb.insert
+    f.foo = 42
+    f.bar = 33
+    3.times do
+      assert_equal(1, fb.query('(and (exists foo) (exists bar))').each.to_a.size)
+    end
+  end
+
+  def test_finds_with_inversion
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.bar = 33
+    3.times do
+      assert_equal(1, fb.query('(not (exists foo))').each.to_a.size)
+    end
+  end
+
+  def test_finds_with_disjunction_in_txn
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 42
+    fb.insert.bar = 33
+    f = fb.insert
+    f.foo = 42
+    f.bar = 33
+    3.times do
+      fb.txn { |fbt| assert_equal(1, fbt.query('(and (exists foo) (exists bar))').each.to_a.size) }
+    end
+  end
+
+  def test_attaches_alias
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    total = 10
+    total.times do |i|
+      f = fb.insert
+      f.foo = rand(0..10)
+      f.bar = rand(0..10)
+      f.xyz = i
+    end
+    3.times do
+      assert_equal(total, fb.query('(as boom (agg (eq foo $bar) (min xyz)))').each.to_a.size)
+    end
+  end
+
+  def test_joins_too
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    total = 10_000
+    total.times do |i|
+      f = fb.insert
+      f.who = i
+    end
+    total.times do |i|
+      f = fb.insert
+      f.friend = i
+    end
+    3.times do
+      assert_equal(total, fb.query('(and (exists who) (join "f<=friend" (eq friend $who)))').each.to_a.size)
+    end
+  end
+
+  def test_deletes_too
+    fb = Factbase::IndexedFactbase.new(Factbase.new)
+    fb.insert.foo = 1
+    fb.query('(eq foo 1)').delete!
+    assert_equal(0, fb.query('(always)').each.to_a.size)
+  end
+end

data/test/factbase/sync/test_sync_query.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+require_relative '../../test__helper'
+require_relative '../../../lib/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 TestSyncQuery < Factbase::Test
+  def test_queries_many_times
+    fb = Factbase::SyncFactbase.new(Factbase.new)
+    total = 5
+    total.times { fb.insert }
+    total.times do
+      assert_equal(5, fb.query('(always)').each.to_a.size)
+    end
+  end
+
+  def test_deletes_too
+    fb = Factbase::SyncFactbase.new(Factbase.new)
+    fb.insert.foo = 1
+    fb.query('(eq foo 1)').delete!
+    assert_equal(0, fb.query('(always)').each.to_a.size)
+  end
+end

data/test/factbase/terms/test_aggregates.rb

@@ -30,10 +30,10 @@ class TestAggregates < Factbase::Test
       '(eq x (agg (eq y 0) (first x)))' => '(eq x 1)',
       '(agg (eq foo 42) (always))' => '(eq x 1)'
     }.each do |q, r|
-      t = Factbase::Syntax.new(Factbase.new, q).to_term
-      f = maps.find { |m| t.evaluate(fact(m), maps) }
+      t = Factbase::Syntax.new(q).to_term
+      f = maps.find { |m| t.evaluate(fact(m), maps, Factbase.new) }
       refute_nil(f, "nothing found by: #{q}")
-      assert(Factbase::Syntax.new(Factbase.new, r).to_term.evaluate(fact(f), []))
+      assert(Factbase::Syntax.new(r).to_term.evaluate(fact(f), [], Factbase.new))
     end
   end
 
@@ -46,8 +46,8 @@ class TestAggregates < Factbase::Test
       '(empty (eq y 42))' => true,
       '(empty (eq x 1))' => false
     }.each do |q, r|
-      t = Factbase::Syntax.new(Factbase.new, q).to_term
-      assert_equal(r, t.evaluate(nil, maps), q)
+      t = Factbase::Syntax.new(q).to_term
+      assert_equal(r, t.evaluate(Factbase::Fact.new({}), maps, Factbase.new), q)
     end
   end
 end

data/test/factbase/terms/test_aliases.rb

@@ -24,11 +24,11 @@ class TestAliases < Factbase::Test
       '(as foo (plus bar 1))' => '(absent foo)',
       '(as foo (minus t1 t2))' => '(when (exists foo) (eq "Float" (type foo)))'
     }.each do |q, r|
-      t = Factbase::Syntax.new(Factbase.new, q).to_term
+      t = Factbase::Syntax.new(q).to_term
       maps.each do |m|
         f = Factbase::Accum.new(fact(m), {}, false)
-        next unless t.evaluate(f, maps)
-        assert(Factbase::Syntax.new(Factbase.new, r).to_term.evaluate(f, []), "#{q} -> #{f}")
+        next unless t.evaluate(f, maps, Factbase.new)
+        assert(Factbase::Syntax.new(r).to_term.evaluate(f, [], Factbase.new), "#{q} -> #{f}")
       end
     end
   end
@@ -44,13 +44,13 @@ class TestAliases < Factbase::Test
       '(join "uuu" (eq x 1))' => '(absent uuu)',
       '(join "uuu <= fff" (eq fff 1))' => '(absent uuu)'
     }.each do |q, r|
-      t = Factbase::Syntax.new(Factbase.new, q).to_term
+      t = Factbase::Syntax.new(q).to_term
       maps.each do |m|
         f = Factbase::Accum.new(fact(m), {}, false)
         require_relative '../../../lib/factbase/logged'
-        f = Factbase::Logged::Fact.new(f, Loog::NULL)
-        next unless t.evaluate(f, maps)
-        assert(Factbase::Syntax.new(Factbase.new, r).to_term.evaluate(f, []), "#{q} -> #{f} doesn't match #{r}")
+        f = Factbase::Logged::Fact.new(f, log: Loog::NULL)
+        next unless t.evaluate(f, maps, Factbase.new)
+        assert(Factbase::Syntax.new(r).to_term.evaluate(f, [], Factbase.new), "#{q} -> #{f} doesn't match #{r}")
       end
     end
   end

data/test/factbase/terms/test_casting.rb

@@ -12,22 +12,22 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestCasting < Factbase::Test
   def test_to_str
-    t = Factbase::Term.new(Factbase.new, :to_string, [Time.now])
-    assert_equal('String', t.evaluate(fact, []).class.to_s)
+    t = Factbase::Term.new(:to_string, [Time.now])
+    assert_equal('String', t.evaluate(fact, [], Factbase.new).class.to_s)
   end
 
   def test_to_integer
-    t = Factbase::Term.new(Factbase.new, :to_integer, [[42, 'hello']])
-    assert_equal('Integer', t.evaluate(fact, []).class.to_s)
+    t = Factbase::Term.new(:to_integer, [[42, 'hello']])
+    assert_equal('Integer', t.evaluate(fact, [], Factbase.new).class.to_s)
   end
 
   def test_to_float
-    t = Factbase::Term.new(Factbase.new, :to_float, [[3.14, 'hello']])
-    assert_equal('Float', t.evaluate(fact, []).class.to_s)
+    t = Factbase::Term.new(:to_float, [[3.14, 'hello']])
+    assert_equal('Float', t.evaluate(fact, [], Factbase.new).class.to_s)
   end
 
   def test_to_time
-    t = Factbase::Term.new(Factbase.new, :to_time, [%w[2023-01-01 hello]])
-    assert_equal('Time', t.evaluate(fact, []).class.to_s)
+    t = Factbase::Term.new(:to_time, [%w[2023-01-01 hello]])
+    assert_equal('Time', t.evaluate(fact, [], Factbase.new).class.to_s)
   end
 end

data/test/factbase/terms/test_debug.rb

@@ -12,14 +12,14 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestDebug < Factbase::Test
   def test_traced
-    t = Factbase::Term.new(Factbase.new, :traced, [Factbase::Term.new(Factbase.new, :defn, [:test_debug, 'self.to_s'])])
+    t = Factbase::Term.new(:traced, [Factbase::Term.new(:defn, [:test_debug, 'self.to_s'])])
     assert_output("(traced (defn test_debug 'self.to_s')) -> true\n") do
-      assert(t.evaluate(fact, []))
+      assert(t.evaluate(fact, [], Factbase.new))
     end
   end
 
   def test_traced_raises
-    e = assert_raises(StandardError) { Factbase::Term.new(Factbase.new, :traced, ['foo']).evaluate(fact, []) }
+    e = assert_raises(StandardError) { Factbase::Term.new(:traced, ['foo']).evaluate(fact, [], Factbase.new) }
     assert_match(/A term expected, but 'foo' provided/, e.message)
   end
 
@@ -27,9 +27,9 @@ class TestDebug < Factbase::Test
     e =
       assert_raises(StandardError) do
         Factbase::Term.new(
-          Factbase.new, :traced,
-          [Factbase::Term.new(Factbase.new, :defn, [:debug, 'self.to_s']), 'something']
-        ).evaluate(fact, [])
+          :traced,
+          [Factbase::Term.new(:defn, [:debug, 'self.to_s']), 'something']
+        ).evaluate(fact, [], Factbase.new)
       end
     assert_match(/Too many \(\d+\) operands for 'traced' \(\d+ expected\)/, e.message)
   end

data/test/factbase/terms/test_defn.rb

@@ -12,37 +12,37 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestDefn < Factbase::Test
   def test_defn_simple
-    t = Factbase::Term.new(Factbase.new, :defn, [:foo, 'self.to_s'])
-    assert(t.evaluate(fact('foo' => 4), []))
-    t1 = Factbase::Term.new(Factbase.new, :foo, ['hello, world!'])
-    assert_equal('(foo \'hello, world!\')', t1.evaluate(fact, []))
+    t = Factbase::Term.new(:defn, [:foo, 'self.to_s'])
+    assert(t.evaluate(fact('foo' => 4), [], Factbase.new))
+    t1 = Factbase::Term.new(:foo, ['hello, world!'])
+    assert_equal('(foo \'hello, world!\')', t1.evaluate(fact, [], Factbase.new))
   end
 
   def test_defn_again_by_mistake
-    t = Factbase::Term.new(Factbase.new, :defn, [:and, 'self.to_s'])
+    t = Factbase::Term.new(:defn, [:and, 'self.to_s'])
     assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      t.evaluate(fact, [], Factbase.new)
     end
   end
 
   def test_defn_bad_name_by_mistake
-    t = Factbase::Term.new(Factbase.new, :defn, [:to_s, 'self.to_s'])
+    t = Factbase::Term.new(:defn, [:to_s, 'self.to_s'])
     assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      t.evaluate(fact, [], Factbase.new)
     end
   end
 
   def test_defn_bad_name_spelling_by_mistake
-    t = Factbase::Term.new(Factbase.new, :defn, [:'some-key', 'self.to_s'])
+    t = Factbase::Term.new(:defn, [:'some-key', 'self.to_s'])
     assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      t.evaluate(fact, [], Factbase.new)
     end
   end
 
   def test_undef_simple
-    t = Factbase::Term.new(Factbase.new, :defn, [:hello, 'self.to_s'])
-    assert(t.evaluate(fact, []))
-    t = Factbase::Term.new(Factbase.new, :undef, [:hello])
-    assert(t.evaluate(fact, []))
+    t = Factbase::Term.new(:defn, [:hello, 'self.to_s'])
+    assert(t.evaluate(fact, [], Factbase.new))
+    t = Factbase::Term.new(:undef, [:hello])
+    assert(t.evaluate(fact, [], Factbase.new))
   end
 end

data/test/factbase/terms/test_logical.rb

@@ -12,46 +12,44 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestLogical < Factbase::Test
   def test_not_matching
-    t = Factbase::Term.new(Factbase.new, :not, [Factbase::Term.new(Factbase.new, :always, [])])
-    refute(t.evaluate(fact('foo' => [100]), []))
+    t = Factbase::Term.new(:not, [Factbase::Term.new(:always, [])])
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
   end
 
   def test_not_eq_matching
-    t = Factbase::Term.new(Factbase.new, :not, [Factbase::Term.new(Factbase.new, :eq, [:foo, 100])])
-    assert(t.evaluate(fact('foo' => [42, 12, -90]), []))
-    refute(t.evaluate(fact('foo' => 100), []))
+    t = Factbase::Term.new(:not, [Factbase::Term.new(:eq, [:foo, 100])])
+    assert(t.evaluate(fact('foo' => [42, 12, -90]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
   end
 
   def test_either
-    t = Factbase::Term.new(Factbase.new, :either, [Factbase::Term.new(Factbase.new, :at, [5, :foo]), 42])
-    assert_equal([42], t.evaluate(fact('foo' => 4), []))
+    t = Factbase::Term.new(:either, [Factbase::Term.new(:at, [5, :foo]), 42])
+    assert_equal([42], t.evaluate(fact('foo' => 4), [], Factbase.new))
   end
 
   def test_or_matching
     t = Factbase::Term.new(
-      Factbase.new,
       :or,
       [
-        Factbase::Term.new(Factbase.new, :eq, [:foo, 4]),
-        Factbase::Term.new(Factbase.new, :eq, [:bar, 5])
+        Factbase::Term.new(:eq, [:foo, 4]),
+        Factbase::Term.new(:eq, [:bar, 5])
       ]
     )
-    assert(t.evaluate(fact('foo' => [4]), []))
-    assert(t.evaluate(fact('bar' => [5]), []))
-    refute(t.evaluate(fact('bar' => [42]), []))
+    assert(t.evaluate(fact('foo' => [4]), [], Factbase.new))
+    assert(t.evaluate(fact('bar' => [5]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => [42]), [], Factbase.new))
   end
 
   def test_when_matching
     t = Factbase::Term.new(
-      Factbase.new,
       :when,
       [
-        Factbase::Term.new(Factbase.new, :eq, [:foo, 4]),
-        Factbase::Term.new(Factbase.new, :eq, [:bar, 5])
+        Factbase::Term.new(:eq, [:foo, 4]),
+        Factbase::Term.new(:eq, [:bar, 5])
       ]
     )
-    assert(t.evaluate(fact('foo' => 4, 'bar' => 5), []))
-    refute(t.evaluate(fact('foo' => 4), []))
-    assert(t.evaluate(fact('foo' => 5, 'bar' => 5), []))
+    assert(t.evaluate(fact('foo' => 4, 'bar' => 5), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 4), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 5, 'bar' => 5), [], Factbase.new))
   end
 end

data/test/factbase/terms/test_math.rb

@@ -12,109 +12,111 @@ require_relative '../../../lib/factbase/term'
 # License:: MIT
 class TestMath < Factbase::Test
   def test_simple
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [42]), []))
-    refute(t.evaluate(fact('foo' => 'Hello!'), []))
-    refute(t.evaluate(fact('bar' => ['Hello!']), []))
+    t = Factbase::Term.new(:eq, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [42]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 'Hello!'), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => ['Hello!']), [], Factbase.new))
   end
 
   def test_zero
-    t = Factbase::Term.new(Factbase.new, :zero, [:foo])
-    assert(t.evaluate(fact('foo' => [0]), []))
-    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 0, 9, 'fdsf']), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => []), []))
-    refute(t.evaluate(fact('bar' => []), []))
+    t = Factbase::Term.new(:zero, [:foo])
+    assert(t.evaluate(fact('foo' => [0]), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 0, 9, 'fdsf']), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => []), [], Factbase.new))
   end
 
   def test_eq
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 42), []))
-    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 42, 9, 'fdsf']), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => []), []))
-    refute(t.evaluate(fact('bar' => []), []))
+    t = Factbase::Term.new(:eq, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [10, 5, 6, -8, 'hey', 42, 9, 'fdsf']), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => []), [], Factbase.new))
   end
 
   def test_eq_time
     now = Time.now
-    t = Factbase::Term.new(Factbase.new, :eq, [:foo, Time.parse(now.iso8601)])
-    assert(t.evaluate(fact('foo' => now), []))
-    assert(t.evaluate(fact('foo' => [now, Time.now]), []))
+    t = Factbase::Term.new(:eq, [:foo, Time.parse(now.iso8601)])
+    assert(t.evaluate(fact('foo' => now), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => [now, Time.now]), [], Factbase.new))
   end
 
   def test_lt
-    t = Factbase::Term.new(Factbase.new, :lt, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [10]), []))
-    refute(t.evaluate(fact('foo' => [100]), []))
-    refute(t.evaluate(fact('foo' => 100), []))
-    refute(t.evaluate(fact('bar' => 100), []))
+    t = Factbase::Term.new(:lt, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [10]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 100), [], Factbase.new))
   end
 
   def test_gte
-    t = Factbase::Term.new(Factbase.new, :gte, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 100), []))
-    assert(t.evaluate(fact('foo' => 42), []))
-    refute(t.evaluate(fact('foo' => 41), []))
+    t = Factbase::Term.new(:gte, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
   end
 
   def test_lte
-    t = Factbase::Term.new(Factbase.new, :lte, [:foo, 42])
-    assert(t.evaluate(fact('foo' => 41), []))
-    assert(t.evaluate(fact('foo' => 42), []))
-    refute(t.evaluate(fact('foo' => 100), []))
+    t = Factbase::Term.new(:lte, [:foo, 42])
+    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 42), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 100), [], Factbase.new))
   end
 
   def test_gt
-    t = Factbase::Term.new(Factbase.new, :gt, [:foo, 42])
-    assert(t.evaluate(fact('foo' => [100]), []))
-    assert(t.evaluate(fact('foo' => 100), []))
-    refute(t.evaluate(fact('foo' => [10]), []))
-    refute(t.evaluate(fact('foo' => 10), []))
-    refute(t.evaluate(fact('bar' => 10), []))
+    t = Factbase::Term.new(:gt, [:foo, 42])
+    assert(t.evaluate(fact('foo' => [100]), [], Factbase.new))
+    assert(t.evaluate(fact('foo' => 100), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [10]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => 10), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => 10), [], Factbase.new))
   end
 
   def test_lt_time
-    t = Factbase::Term.new(Factbase.new, :lt, [:foo, Time.now])
-    assert(t.evaluate(fact('foo' => [Time.now - 100]), []))
-    refute(t.evaluate(fact('foo' => [Time.now + 100]), []))
-    refute(t.evaluate(fact('bar' => [100]), []))
+    t = Factbase::Term.new(:lt, [:foo, Time.now])
+    assert(t.evaluate(fact('foo' => [Time.now - 100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [Time.now + 100]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => [100]), [], Factbase.new))
   end
 
   def test_gt_time
-    t = Factbase::Term.new(Factbase.new, :gt, [:foo, Time.now])
-    assert(t.evaluate(fact('foo' => [Time.now + 100]), []))
-    refute(t.evaluate(fact('foo' => [Time.now - 100]), []))
-    refute(t.evaluate(fact('bar' => [100]), []))
+    t = Factbase::Term.new(:gt, [:foo, Time.now])
+    assert(t.evaluate(fact('foo' => [Time.now + 100]), [], Factbase.new))
+    refute(t.evaluate(fact('foo' => [Time.now - 100]), [], Factbase.new))
+    refute(t.evaluate(fact('bar' => [100]), [], Factbase.new))
   end
 
   def test_plus
-    t = Factbase::Term.new(Factbase.new, :plus, [:foo, 42])
-    assert_equal(46, t.evaluate(fact('foo' => 4), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:plus, [:foo, 42])
+    assert_equal(46, t.evaluate(fact('foo' => 4), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_plus_time
-    t = Factbase::Term.new(Factbase.new, :plus, [:foo, '12 days'])
-    assert_equal(Time.parse('2024-01-13'), t.evaluate(fact('foo' => Time.parse('2024-01-01')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:plus, [:foo, '12 days'])
+    assert_equal(Time.parse('2024-01-13'), t.evaluate(fact('foo' => Time.parse('2024-01-01')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, 42])
-    assert_equal(58, t.evaluate(fact('foo' => 100), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, 42])
+    assert_equal(58, t.evaluate(fact('foo' => 100), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus_time
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, '4 hours'])
-    assert_equal(Time.parse('2024-01-01T06:04'), t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, '4 hours'])
+    assert_equal(Time.parse('2024-01-01T06:04'),
+                 t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 
   def test_minus_time_singular
-    t = Factbase::Term.new(Factbase.new, :minus, [:foo, '1 hour'])
-    assert_equal(Time.parse('2024-01-01T09:04'), t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), []))
-    assert_nil(t.evaluate(fact, []))
+    t = Factbase::Term.new(:minus, [:foo, '1 hour'])
+    assert_equal(Time.parse('2024-01-01T09:04'),
+                 t.evaluate(fact('foo' => Time.parse('2024-01-01T10:04')), [], Factbase.new))
+    assert_nil(t.evaluate(fact, [], Factbase.new))
   end
 end