factbase 0.4.0 → 0.5.0

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

data/test/factbase/test_fact.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,12 +26,12 @@ require_relative '../../lib/factbase/fact'
 
 # Fact test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestFact < Minitest::Test
   def test_injects_data_correctly
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     f.foo = 1
     f.bar = 2
     f.bar = 3
@@ -42,7 +42,7 @@ class TestFact < Minitest::Test
 
   def test_simple_resetting
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     f.foo = 42
     assert_equal(42, f.foo, f.to_s)
     f.foo = 256
@@ -52,7 +52,7 @@ class TestFact < Minitest::Test
 
   def test_keeps_values_unique
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     f.foo = 42
     f.foo = 'Hello'
     assert_equal(2, map['foo'].size)
@@ -61,50 +61,50 @@ class TestFact < Minitest::Test
   end
 
   def test_fails_when_empty
-    f = Factbase::Fact.new(Mutex.new, {})
-    assert_raises do
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    assert_raises(StandardError) do
       f.something
     end
   end
 
   def test_fails_when_setting_nil
-    f = Factbase::Fact.new(Mutex.new, {})
-    assert_raises do
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    assert_raises(StandardError) do
       f.foo = nil
     end
   end
 
   def test_fails_when_setting_empty
-    f = Factbase::Fact.new(Mutex.new, {})
-    assert_raises do
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    assert_raises(StandardError) do
       f.foo = ''
     end
   end
 
   def test_fails_when_not_found
-    f = Factbase::Fact.new(Mutex.new, {})
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
     f.first = 42
-    assert_raises do
+    assert_raises(StandardError) do
       f.second
     end
   end
 
   def test_set_by_name
-    f = Factbase::Fact.new(Mutex.new, {})
-    f.send('_foo_bar=', 42)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    f.send(:_foo_bar=, 42)
     assert_equal(42, f._foo_bar, f.to_s)
   end
 
   def test_set_twice_same_value
     map = {}
-    f = Factbase::Fact.new(Mutex.new, map)
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, map)
     f.foo = 42
     f.foo = 42
     assert_equal([42], map['foo'])
   end
 
   def test_time_in_utc
-    f = Factbase::Fact.new(Mutex.new, {})
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
     t = Time.now
     f.foo = t
     assert_equal(t.utc, f.foo)
@@ -112,14 +112,14 @@ class TestFact < Minitest::Test
   end
 
   def test_some_names_are_prohibited
-    f = Factbase::Fact.new(Mutex.new, {})
-    assert_raises { f.to_s = 42 }
-    assert_raises { f.class = 42 }
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    assert_raises(StandardError) { f.to_s = 42 }
+    assert_raises(StandardError) { f.class = 42 }
   end
 
   def test_get_all_properties
-    f = Factbase::Fact.new(Mutex.new, {})
+    f = Factbase::Fact.new(Factbase.new, Mutex.new, {})
     f.foo = 42
-    assert(f.all_properties.include?('foo'))
+    assert_includes(f.all_properties, 'foo')
   end
 end

data/test/factbase/test_flatten.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,20 +26,20 @@ require_relative '../../lib/factbase/flatten'
 
 # Test.
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024 Yegor Bugayenko
+# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
 # License:: MIT
 class TestFlatten < Minitest::Test
   def test_mapping
     maps = [{ 'b' => [42], 'i' => 1 }, { 'a' => 33, 'i' => 0 }, { 'c' => %w[hey you], 'i' => 2 }]
     to = Factbase::Flatten.new(maps, 'i').it
-    assert(33, to[0]['a'])
-    assert(42, to[1]['b'])
-    assert(2, to[2]['c'].size)
+    assert_equal(33, to[0]['a'])
+    assert_equal(42, to[1]['b'])
+    assert_equal(2, to[2]['c'].size)
   end
 
   def test_without_sorter
     maps = [{ 'b' => [42], 'i' => [44] }, { 'a' => 33 }]
     to = Factbase::Flatten.new(maps, 'i').it
-    assert(33, to[0]['a'])
+    assert_equal(33, to[0]['a'])
   end
 end