factbase 0.4.0 → 0.5.1

data/test/factbase/terms/test_defn.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -25,41 +25,41 @@ require_relative '../../../lib/factbase/term'
 
 # Defn test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestDefn < Minitest::Test
   def test_defn_simple
-    t = Factbase::Term.new(:defn, [:foo, 'self.to_s'])
-    assert_equal(true, t.evaluate(fact('foo' => 4), []))
-    t1 = Factbase::Term.new(:foo, ['hello, world!'])
+    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, []))
   end
 
   def test_defn_again_by_mistake
-    t = Factbase::Term.new(:defn, [:and, 'self.to_s'])
-    assert_raises do
+    t = Factbase::Term.new(Factbase.new, :defn, [:and, 'self.to_s'])
+    assert_raises(StandardError) do
       t.evaluate(fact, [])
     end
   end
 
   def test_defn_bad_name_by_mistake
-    t = Factbase::Term.new(:defn, [:to_s, 'self.to_s'])
-    assert_raises do
+    t = Factbase::Term.new(Factbase.new, :defn, [:to_s, 'self.to_s'])
+    assert_raises(StandardError) do
       t.evaluate(fact, [])
     end
   end
 
   def test_defn_bad_name_spelling_by_mistake
-    t = Factbase::Term.new(:defn, [:'some-key', 'self.to_s'])
-    assert_raises do
+    t = Factbase::Term.new(Factbase.new, :defn, [:'some-key', 'self.to_s'])
+    assert_raises(StandardError) do
       t.evaluate(fact, [])
     end
   end
 
   def test_undef_simple
-    t = Factbase::Term.new(:defn, [:hello, 'self.to_s'])
-    assert_equal(true, t.evaluate(fact, []))
-    t = Factbase::Term.new(:undef, [:hello])
-    assert_equal(true, t.evaluate(fact, []))
+    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, []))
   end
 end

data/test/factbase/terms/test_logical.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -25,48 +25,50 @@ require_relative '../../../lib/factbase/term'
 
 # Logical test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestLogical < Minitest::Test
   def test_not_matching
-    t = Factbase::Term.new(:not, [Factbase::Term.new(:always, [])])
-    assert(!t.evaluate(fact('foo' => [100]), []))
+    t = Factbase::Term.new(Factbase.new, :not, [Factbase::Term.new(Factbase.new, :always, [])])
+    refute(t.evaluate(fact('foo' => [100]), []))
   end
 
   def test_not_eq_matching
-    t = Factbase::Term.new(:not, [Factbase::Term.new(:eq, [:foo, 100])])
+    t = Factbase::Term.new(Factbase.new, :not, [Factbase::Term.new(Factbase.new, :eq, [:foo, 100])])
     assert(t.evaluate(fact('foo' => [42, 12, -90]), []))
-    assert(!t.evaluate(fact('foo' => 100), []))
+    refute(t.evaluate(fact('foo' => 100), []))
   end
 
   def test_either
-    t = Factbase::Term.new(:either, [Factbase::Term.new(:at, [5, :foo]), 42])
+    t = Factbase::Term.new(Factbase.new, :either, [Factbase::Term.new(Factbase.new, :at, [5, :foo]), 42])
     assert_equal([42], t.evaluate(fact('foo' => 4), []))
   end
 
   def test_or_matching
     t = Factbase::Term.new(
+      Factbase.new,
       :or,
       [
-        Factbase::Term.new(:eq, [:foo, 4]),
-        Factbase::Term.new(:eq, [:bar, 5])
+        Factbase::Term.new(Factbase.new, :eq, [:foo, 4]),
+        Factbase::Term.new(Factbase.new, :eq, [:bar, 5])
       ]
     )
     assert(t.evaluate(fact('foo' => [4]), []))
     assert(t.evaluate(fact('bar' => [5]), []))
-    assert(!t.evaluate(fact('bar' => [42]), []))
+    refute(t.evaluate(fact('bar' => [42]), []))
   end
 
   def test_when_matching
     t = Factbase::Term.new(
+      Factbase.new,
       :when,
       [
-        Factbase::Term.new(:eq, [:foo, 4]),
-        Factbase::Term.new(:eq, [:bar, 5])
+        Factbase::Term.new(Factbase.new, :eq, [:foo, 4]),
+        Factbase::Term.new(Factbase.new, :eq, [:bar, 5])
       ]
     )
     assert(t.evaluate(fact('foo' => 4, 'bar' => 5), []))
-    assert(!t.evaluate(fact('foo' => 4), []))
+    refute(t.evaluate(fact('foo' => 4), []))
     assert(t.evaluate(fact('foo' => 5, 'bar' => 5), []))
   end
 end

data/test/factbase/terms/test_math.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -26,113 +26,113 @@ require_relative '../../../lib/factbase/term'
 
 # Math test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestMath < Minitest::Test
   def test_simple
-    t = Factbase::Term.new(:eq, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :eq, [:foo, 42])
     assert(t.evaluate(fact('foo' => [42]), []))
-    assert(!t.evaluate(fact('foo' => 'Hello!'), []))
-    assert(!t.evaluate(fact('bar' => ['Hello!']), []))
+    refute(t.evaluate(fact('foo' => 'Hello!'), []))
+    refute(t.evaluate(fact('bar' => ['Hello!']), []))
   end
 
   def test_zero
-    t = Factbase::Term.new(:zero, [:foo])
+    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']), []))
-    assert(!t.evaluate(fact('foo' => [100]), []))
-    assert(!t.evaluate(fact('foo' => []), []))
-    assert(!t.evaluate(fact('bar' => []), []))
+    refute(t.evaluate(fact('foo' => [100]), []))
+    refute(t.evaluate(fact('foo' => []), []))
+    refute(t.evaluate(fact('bar' => []), []))
   end
 
   def test_eq
-    t = Factbase::Term.new(:eq, [:foo, 42])
+    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']), []))
-    assert(!t.evaluate(fact('foo' => [100]), []))
-    assert(!t.evaluate(fact('foo' => []), []))
-    assert(!t.evaluate(fact('bar' => []), []))
+    refute(t.evaluate(fact('foo' => [100]), []))
+    refute(t.evaluate(fact('foo' => []), []))
+    refute(t.evaluate(fact('bar' => []), []))
   end
 
   def test_eq_time
     now = Time.now
-    t = Factbase::Term.new(:eq, [:foo, Time.parse(now.iso8601)])
+    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]), []))
   end
 
   def test_lt
-    t = Factbase::Term.new(:lt, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :lt, [:foo, 42])
     assert(t.evaluate(fact('foo' => [10]), []))
-    assert(!t.evaluate(fact('foo' => [100]), []))
-    assert(!t.evaluate(fact('foo' => 100), []))
-    assert(!t.evaluate(fact('bar' => 100), []))
+    refute(t.evaluate(fact('foo' => [100]), []))
+    refute(t.evaluate(fact('foo' => 100), []))
+    refute(t.evaluate(fact('bar' => 100), []))
   end
 
   def test_gte
-    t = Factbase::Term.new(:gte, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :gte, [:foo, 42])
     assert(t.evaluate(fact('foo' => 100), []))
     assert(t.evaluate(fact('foo' => 42), []))
-    assert(!t.evaluate(fact('foo' => 41), []))
+    refute(t.evaluate(fact('foo' => 41), []))
   end
 
   def test_lte
-    t = Factbase::Term.new(:lte, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :lte, [:foo, 42])
     assert(t.evaluate(fact('foo' => 41), []))
     assert(t.evaluate(fact('foo' => 42), []))
-    assert(!t.evaluate(fact('foo' => 100), []))
+    refute(t.evaluate(fact('foo' => 100), []))
   end
 
   def test_gt
-    t = Factbase::Term.new(:gt, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :gt, [:foo, 42])
     assert(t.evaluate(fact('foo' => [100]), []))
     assert(t.evaluate(fact('foo' => 100), []))
-    assert(!t.evaluate(fact('foo' => [10]), []))
-    assert(!t.evaluate(fact('foo' => 10), []))
-    assert(!t.evaluate(fact('bar' => 10), []))
+    refute(t.evaluate(fact('foo' => [10]), []))
+    refute(t.evaluate(fact('foo' => 10), []))
+    refute(t.evaluate(fact('bar' => 10), []))
   end
 
   def test_lt_time
-    t = Factbase::Term.new(:lt, [:foo, Time.now])
+    t = Factbase::Term.new(Factbase.new, :lt, [:foo, Time.now])
     assert(t.evaluate(fact('foo' => [Time.now - 100]), []))
-    assert(!t.evaluate(fact('foo' => [Time.now + 100]), []))
-    assert(!t.evaluate(fact('bar' => [100]), []))
+    refute(t.evaluate(fact('foo' => [Time.now + 100]), []))
+    refute(t.evaluate(fact('bar' => [100]), []))
   end
 
   def test_gt_time
-    t = Factbase::Term.new(:gt, [:foo, Time.now])
+    t = Factbase::Term.new(Factbase.new, :gt, [:foo, Time.now])
     assert(t.evaluate(fact('foo' => [Time.now + 100]), []))
-    assert(!t.evaluate(fact('foo' => [Time.now - 100]), []))
-    assert(!t.evaluate(fact('bar' => [100]), []))
+    refute(t.evaluate(fact('foo' => [Time.now - 100]), []))
+    refute(t.evaluate(fact('bar' => [100]), []))
   end
 
   def test_plus
-    t = Factbase::Term.new(:plus, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :plus, [:foo, 42])
     assert_equal(46, t.evaluate(fact('foo' => 4), []))
-    assert(t.evaluate(fact, []).nil?)
+    assert_nil(t.evaluate(fact, []))
   end
 
   def test_plus_time
-    t = Factbase::Term.new(:plus, [:foo, '12 days'])
+    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(t.evaluate(fact, []).nil?)
+    assert_nil(t.evaluate(fact, []))
   end
 
   def test_minus
-    t = Factbase::Term.new(:minus, [:foo, 42])
+    t = Factbase::Term.new(Factbase.new, :minus, [:foo, 42])
     assert_equal(58, t.evaluate(fact('foo' => 100), []))
-    assert(t.evaluate(fact, []).nil?)
+    assert_nil(t.evaluate(fact, []))
   end
 
   def test_minus_time
-    t = Factbase::Term.new(:minus, [:foo, '4 hours'])
+    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(t.evaluate(fact, []).nil?)
+    assert_nil(t.evaluate(fact, []))
   end
 
   def test_minus_time_singular
-    t = Factbase::Term.new(:minus, [:foo, '1 hour'])
+    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(t.evaluate(fact, []).nil?)
+    assert_nil(t.evaluate(fact, []))
   end
 end

data/test/factbase/terms/test_meta.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2024-2025 Yegor Bugayenko
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'minitest/autorun'
+require_relative '../../../lib/factbase/term'
+
+# Meta test.
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
+# License:: MIT
+class TestMeta < Minitest::Test
+  def test_exists
+    t = Factbase::Term.new(Factbase.new, :exists, [:foo])
+    assert(t.evaluate(fact('foo' => 41), []))
+    refute(t.evaluate(fact('bar' => 41), []))
+  end
+
+  def test_absent
+    t = Factbase::Term.new(Factbase.new, :absent, [:foo])
+    refute(t.evaluate(fact('foo' => 41), []))
+    assert(t.evaluate(fact('bar' => 41), []))
+  end
+
+  def test_size
+    t = Factbase::Term.new(Factbase.new, :size, [:foo])
+    assert_equal(1, t.evaluate(fact('foo' => 41), []))
+    assert_equal(0, t.evaluate(fact('foo' => nil), []))
+    assert_equal(4, t.evaluate(fact('foo' => [1, 2, 3, 4]), []))
+    assert_equal(0, t.evaluate(fact('foo' => []), []))
+    assert_equal(1, t.evaluate(fact('foo' => ''), []))
+  end
+
+  def test_type
+    t = Factbase::Term.new(Factbase.new, :type, [:foo])
+    assert_equal('nil', t.evaluate(fact('foo' => nil), []))
+    assert_equal('Integer', t.evaluate(fact('foo' => [1]), []))
+    assert_equal('Array', t.evaluate(fact('foo' => [1, 2]), []))
+    assert_equal('String', t.evaluate(fact('foo' => 'bar'), []))
+    assert_equal('Float', t.evaluate(fact('foo' => 2.1), []))
+    assert_equal('Time', t.evaluate(fact('foo' => Time.now), []))
+  end
+
+  def test_nil
+    t = Factbase::Term.new(Factbase.new, :nil, [:foo])
+    assert(t.evaluate(fact('foo' => nil), []))
+    refute(t.evaluate(fact('foo' => true), []))
+    refute(t.evaluate(fact('foo' => 'bar'), []))
+  end
+
+  def test_many
+    t = Factbase::Term.new(Factbase.new, :many, [:foo])
+    refute(t.evaluate(fact('foo' => nil), []))
+    refute(t.evaluate(fact('foo' => 1), []))
+    refute(t.evaluate(fact('foo' => '1234'), []))
+    assert(t.evaluate(fact('foo' => [1, 3, 5]), []))
+    refute(t.evaluate(fact('foo' => []), []))
+  end
+
+  def test_one
+    t = Factbase::Term.new(Factbase.new, :one, [:foo])
+    assert(t.evaluate(fact('foo' => 1), []))
+    assert(t.evaluate(fact('foo' => '1234'), []))
+    assert(t.evaluate(fact('foo' => [1]), []))
+    refute(t.evaluate(fact('foo' => nil), []))
+    refute(t.evaluate(fact('foo' => [1, 3, 5]), []))
+    refute(t.evaluate(fact('foo' => []), []))
+  end
+end

data/test/factbase/terms/test_ordering.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2024-2025 Yegor Bugayenko
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'minitest/autorun'
+require_relative '../../../lib/factbase/term'
+
+# Ordering test.
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
+# License:: MIT
+class TestOrdering < Minitest::Test
+  def test_prev
+    t = Factbase::Term.new(Factbase.new, :prev, [:foo])
+    assert_nil(t.evaluate(fact('foo' => 41), []))
+    assert_equal([41], t.evaluate(fact('foo' => 5), []))
+    assert_equal([5], t.evaluate(fact('foo' => 6), []))
+  end
+
+  def test_unique
+    t = Factbase::Term.new(Factbase.new, :unique, [:foo])
+    refute(t.evaluate(fact, []))
+    assert(t.evaluate(fact('foo' => 41), []))
+    refute(t.evaluate(fact('foo' => 41), []))
+    assert(t.evaluate(fact('foo' => 1), []))
+  end
+end

data/test/factbase/terms/test_strings.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -25,29 +25,29 @@ require_relative '../../../lib/factbase/term'
 
 # Strings test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestStrings < Minitest::Test
   def test_regexp_matching
-    t = Factbase::Term.new(:matches, [:foo, '[a-z]+'])
+    t = Factbase::Term.new(Factbase.new, :matches, [:foo, '[a-z]+'])
     assert(t.evaluate(fact('foo' => 'hello'), []))
     assert(t.evaluate(fact('foo' => 'hello 42'), []))
-    assert(!t.evaluate(fact('foo' => 42), []))
+    refute(t.evaluate(fact('foo' => 42), []))
   end
 
   def test_concat
-    t = Factbase::Term.new(:concat, [42, 'hi', 3.14, :hey, Time.now])
+    t = Factbase::Term.new(Factbase.new, :concat, [42, 'hi', 3.14, :hey, Time.now])
     s = t.evaluate(fact, [])
-    assert(s.start_with?('42hi3.14'), s)
+    assert(s.start_with?('42hi3.14'))
   end
 
   def test_concat_empty
-    t = Factbase::Term.new(:concat, [])
+    t = Factbase::Term.new(Factbase.new, :concat, [])
     assert_equal('', t.evaluate(fact, []))
   end
 
   def test_sprintf
-    t = Factbase::Term.new(:sprintf, ['hi, %s!', 'Jeff'])
+    t = Factbase::Term.new(Factbase.new, :sprintf, ['hi, %s!', 'Jeff'])
     assert_equal('hi, Jeff!', t.evaluate(fact, []))
   end
 end

data/test/factbase/terms/test_system.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -26,24 +26,24 @@ require_relative '../../../lib/factbase/term'
 
 # System test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestSystem < Minitest::Test
   def test_env
     ENV.store('FOO', 'bar')
-    t = Factbase::Term.new(:env, ['FOO', ''])
+    t = Factbase::Term.new(Factbase.new, :env, ['FOO', ''])
     assert_equal('bar', t.evaluate(fact, []))
   end
 
   def test_default
     ENV.delete('FOO')
-    t = Factbase::Term.new(:env, ['FOO', 'мой друг'])
+    t = Factbase::Term.new(Factbase.new, :env, ['FOO', 'мой друг'])
     assert_equal('мой друг', t.evaluate(fact, []))
   end
 
   def test_when_default_is_absent
     ENV.delete('FOO')
-    t = Factbase::Term.new(:env, ['FOO'])
-    assert_raises { t.evaluate(fact, []) }
+    t = Factbase::Term.new(Factbase.new, :env, ['FOO'])
+    assert_raises(StandardError) { t.evaluate(fact, []) }
   end
 end

data/test/factbase/test_accum.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) 2024 Yegor Bugayenko
+# Copyright (c) 2024-2025 Yegor Bugayenko
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the 'Software'), to deal
@@ -27,23 +27,23 @@ require_relative '../../lib/factbase/fact'
 
 # Accum test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestAccum < Minitest::Test
   def test_holds_props
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     props = {}
     a = Factbase::Accum.new(f, props, false)
     a.foo = 42
-    assert_raises { f.foo }
+    assert_raises(StandardError) { f.foo }
     assert_equal(42, a.foo)
     assert_equal([42], props['foo'])
   end
 
   def test_passes_props
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     props = {}
     a = Factbase::Accum.new(f, props, true)
     a.foo = 42
@@ -54,7 +54,7 @@ class TestAccum < Minitest::Test
 
   def test_appends_props
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     f.foo = 42
     props = {}
     a = Factbase::Accum.new(f, props, false)
@@ -63,14 +63,14 @@ class TestAccum < Minitest::Test
   end
 
   def test_empties
-    f = Factbase::Fact.new(Mutex.new, {})
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
     a = Factbase::Accum.new(f, {}, false)
-    assert(a['foo'].nil?)
+    assert_nil(a['foo'])
   end
 
   def test_prints_to_string
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     props = {}
     a = Factbase::Accum.new(f, props, true)
     a.foo = 42