factbase 0.14.7 → 0.15.1

data/test/factbase/sync/test_sync_query.rb

@@ -1,30 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-require_relative '../../../lib/factbase/syntax'
-
-# Aggregates test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestAggregates < Factbase::Test
-  def test_aggregation
-    maps = [
-      { 'x' => [1], 'y' => [0], 'z' => [4] },
-      { 'x' => [2], 'y' => [42], 'z' => [3] },
-      { 'x' => [3], 'y' => [42], 'z' => [5] },
-      { 'x' => [4], 'y' => [42], 'z' => [2] },
-      { 'x' => [5], 'y' => [42], 'z' => [1] },
-      { 'x' => [8], 'y' => [0], 'z' => [6] }
-    ]
-    {
-      '(eq x (agg (eq y 42) (min x)))' => '(eq x 2)',
-      '(eq z (agg (eq y 0) (max z)))' => '(eq x 8)',
-      '(eq x (agg (and (eq y 42) (gt z 1)) (max x)))' => '(eq x 4)',
-      '(and (eq x (agg (eq y 42) (min x))) (eq z 3))' => '(eq x 2)',
-      '(eq x (agg (eq y 0) (nth 0 x)))' => '(eq x 1)',
-      '(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(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(r).to_term.evaluate(fact(f), [], Factbase.new))
-    end
-  end
-
-  def test_empty
-    maps = [
-      { 'x' => [1], 'y' => [0], 'z' => [4] },
-      { 'x' => [8], 'y' => [0] }
-    ]
-    {
-      '(empty (eq y 42))' => true,
-      '(empty (eq x 1))' => false
-    }.each do |q, r|
-      t = Factbase::Syntax.new(q).to_term
-      assert_equal(r, t.evaluate(Factbase::Fact.new({}), maps, Factbase.new), q)
-    end
-  end
-
-  def test_empty_with_params
-    maps = [
-      { 'a' => [3], 'b' => [44] },
-      { 'a' => [4], 'b' => [55] }
-    ]
-    t = Factbase::Syntax.new('(empty (eq b $x))').to_term
-    assert(t.evaluate(Factbase::Fact.new({ 'x' => [42] }), maps, Factbase.new))
-    refute(t.evaluate(Factbase::Fact.new({ 'x' => [44] }), maps, Factbase.new))
-  end
-end

data/test/factbase/terms/test_aliases.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require 'loog'
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-require_relative '../../../lib/factbase/syntax'
-require_relative '../../../lib/factbase/accum'
-
-# Aliases test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestAliases < Factbase::Test
-  def test_aliases
-    maps = [
-      { 'x' => [1], 'y' => [0], 't1' => [Time.now], 't2' => [Time.now] },
-      { 'x' => [2], 'y' => [42], 't' => [Time.now] }
-    ]
-    {
-      '(as foo (plus x 1))' => '(exists foo)',
-      '(as foo (plus x y))' => '(gt foo 0)',
-      '(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(q).to_term
-      maps.each do |m|
-        f = Factbase::Accum.new(fact(m), {}, false)
-        next unless t.evaluate(f, maps, Factbase.new)
-        assert(Factbase::Syntax.new(r).to_term.evaluate(f, [], Factbase.new), "#{q} -> #{f}")
-      end
-    end
-  end
-
-  def test_join
-    maps = [
-      { 'x' => 1, 'y' => 0, 'z' => 4 },
-      { 'x' => [2], 'bar' => [44, 55, 66] }
-    ]
-    {
-      '(join "foo_x<=x" (gt x 1))' => '(exists foo_x)',
-      '(join "foo <=bar  " (exists bar))' => '(and (eq foo 44) (eq foo 55))',
-      '(join "uuu" (eq x 1))' => '(absent uuu)',
-      '(join "uuu <= fff" (eq fff 1))' => '(absent uuu)'
-    }.each do |q, r|
-      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, 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
-end

data/test/factbase/terms/test_casting.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Math test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestCasting < Factbase::Test
-  def test_to_str
-    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(:to_integer, [[42, 'hello']])
-    assert_equal('Integer', t.evaluate(fact, [], Factbase.new).class.to_s)
-  end
-
-  def test_to_float
-    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(: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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Debug test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestDebug < Factbase::Test
-  def test_traced
-    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, [], Factbase.new))
-    end
-  end
-
-  def test_traced_raises
-    e = assert_raises(StandardError) { Factbase::Term.new(:traced, ['foo']).evaluate(fact, [], Factbase.new) }
-    assert_match(/A term is expected, but 'foo' provided/, e.message)
-  end
-
-  def test_traced_raises_when_too_many_args
-    e =
-      assert_raises(StandardError) do
-        Factbase::Term.new(
-          :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
-
-  def test_assert_with_true_condition
-    t = Factbase::Term.new(:assert, ['all must be positive', Factbase::Term.new(:gt, [:foo, 0])])
-    assert(t.evaluate(fact('foo' => 5), [], Factbase.new))
-  end
-
-  def test_assert_with_false_condition
-    t = Factbase::Term.new(:assert, ['all must be positive', Factbase::Term.new(:gt, [:foo, 0])])
-    e =
-      assert_raises(RuntimeError) do
-        t.evaluate(fact('foo' => -1), [], Factbase.new)
-      end
-    assert_equal("all must be positive at (assert 'all must be positive' (gt foo 0))", e.message)
-  end
-
-  def test_assert_with_zero_value
-    t = Factbase::Term.new(:assert, ['value must not be zero', Factbase::Term.new(:gt, [:foo, 0])])
-    e =
-      assert_raises(RuntimeError) do
-        t.evaluate(fact('foo' => 0), [], Factbase.new)
-      end
-    assert_equal("value must not be zero at (assert 'value must not be zero' (gt foo 0))", e.message)
-  end
-
-  def test_assert_with_array_true_condition
-    t = Factbase::Term.new(:assert, ['at least one positive', Factbase::Term.new(:gt, [:foo, 0])])
-    assert(t.evaluate(fact('foo' => [1, 2, 3]), [], Factbase.new))
-  end
-
-  def test_assert_with_array_false_condition
-    t = Factbase::Term.new(:assert, ['at least one positive', Factbase::Term.new(:gt, [:foo, 0])])
-    e =
-      assert_raises(RuntimeError) do
-        t.evaluate(fact('foo' => [-1, -2, -3]), [], Factbase.new)
-      end
-    assert_equal("at least one positive at (assert 'at least one positive' (gt foo 0))", e.message)
-  end
-
-  def test_assert_with_mixed_array
-    t = Factbase::Term.new(:assert, ['at least one positive', Factbase::Term.new(:gt, [:foo, 0])])
-    assert(t.evaluate(fact('foo' => [-1, 0, 3]), [], Factbase.new))
-  end
-
-  def test_assert_raises_when_message_not_string
-    e =
-      assert_raises(StandardError) do
-        Factbase::Term.new(:assert, [123, Factbase::Term.new(:gt, [:foo, 0])]).evaluate(fact, [], Factbase.new)
-      end
-    assert_match(/A string is expected as first argument of 'assert', but '123' provided/, e.message)
-  end
-
-  def test_assert_raises_when_second_arg_not_term
-    e =
-      assert_raises(StandardError) do
-        Factbase::Term.new(:assert, %w[message not_a_term]).evaluate(fact, [], Factbase.new)
-      end
-    assert_match(/A term is expected as second argument of 'assert', but 'not_a_term' provided/, e.message)
-  end
-
-  def test_assert_raises_when_too_few_args
-    e =
-      assert_raises(StandardError) do
-        Factbase::Term.new(:assert, ['message']).evaluate(fact, [], Factbase.new)
-      end
-    assert_match(/Too few \(\d+\) operands for 'assert' \(\d+ expected\)/, e.message)
-  end
-
-  def test_assert_raises_when_too_many_args
-    e =
-      assert_raises(StandardError) do
-        Factbase::Term.new(:assert, ['message', Factbase::Term.new(:gt, [:foo, 0]), 'extra']).evaluate(fact, [],
-                                                                                                       Factbase.new)
-      end
-    assert_match(/Too many \(\d+\) operands for 'assert' \(\d+ expected\)/, e.message)
-  end
-end

data/test/factbase/terms/test_defn.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Defn test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestDefn < Factbase::Test
-  def test_defn_simple
-    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(:defn, [:and, 'self.to_s'])
-    assert_raises(StandardError) do
-      t.evaluate(fact, [], Factbase.new)
-    end
-  end
-
-  def test_defn_bad_name_by_mistake
-    t = Factbase::Term.new(:defn, [:to_s, 'self.to_s'])
-    assert_raises(StandardError) do
-      t.evaluate(fact, [], Factbase.new)
-    end
-  end
-
-  def test_defn_bad_name_spelling_by_mistake
-    t = Factbase::Term.new(:defn, [:'some-key', 'self.to_s'])
-    assert_raises(StandardError) do
-      t.evaluate(fact, [], Factbase.new)
-    end
-  end
-
-  def test_undef_simple
-    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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/accum'
-require_relative '../../../lib/factbase/term'
-require_relative '../../../lib/factbase/syntax'
-
-# Logical test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestLogical < Factbase::Test
-  def test_not_matching
-    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(: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(: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(
-      :or,
-      [
-        Factbase::Term.new(:eq, [:foo, 4]),
-        Factbase::Term.new(:eq, [:bar, 5])
-      ]
-    )
-    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(
-      :when,
-      [
-        Factbase::Term.new(:eq, [:foo, 4]),
-        Factbase::Term.new(:eq, [: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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Math test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestMath < Factbase::Test
-  def test_simple
-    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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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

data/test/factbase/terms/test_meta.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Meta test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestMeta < Factbase::Test
-  def test_exists
-    t = Factbase::Term.new(:exists, [:foo])
-    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
-    refute(t.evaluate(fact('bar' => 41), [], Factbase.new))
-  end
-
-  def test_absent
-    t = Factbase::Term.new(:absent, [:foo])
-    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
-    assert(t.evaluate(fact('bar' => 41), [], Factbase.new))
-  end
-
-  def test_size
-    t = Factbase::Term.new(:size, [:foo])
-    assert_equal(1, t.evaluate(fact('foo' => 41), [], Factbase.new))
-    assert_equal(0, t.evaluate(fact('foo' => nil), [], Factbase.new))
-    assert_equal(4, t.evaluate(fact('foo' => [1, 2, 3, 4]), [], Factbase.new))
-    assert_equal(0, t.evaluate(fact('foo' => []), [], Factbase.new))
-    assert_equal(1, t.evaluate(fact('foo' => ''), [], Factbase.new))
-  end
-
-  def test_type
-    t = Factbase::Term.new(:type, [:foo])
-    assert_equal('nil', t.evaluate(fact('foo' => nil), [], Factbase.new))
-    assert_equal('Integer', t.evaluate(fact('foo' => [1]), [], Factbase.new))
-    assert_equal('Array', t.evaluate(fact('foo' => [1, 2]), [], Factbase.new))
-    assert_equal('String', t.evaluate(fact('foo' => 'bar'), [], Factbase.new))
-    assert_equal('Float', t.evaluate(fact('foo' => 2.1), [], Factbase.new))
-    assert_equal('Time', t.evaluate(fact('foo' => Time.now), [], Factbase.new))
-  end
-
-  def test_nil
-    t = Factbase::Term.new(:nil, [:foo])
-    assert(t.evaluate(fact('foo' => nil), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => true), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => 'bar'), [], Factbase.new))
-  end
-
-  def test_many
-    t = Factbase::Term.new(:many, [:foo])
-    refute(t.evaluate(fact('foo' => nil), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => 1), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => '1234'), [], Factbase.new))
-    assert(t.evaluate(fact('foo' => [1, 3, 5]), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
-  end
-
-  def test_one
-    t = Factbase::Term.new(:one, [:foo])
-    assert(t.evaluate(fact('foo' => 1), [], Factbase.new))
-    assert(t.evaluate(fact('foo' => '1234'), [], Factbase.new))
-    assert(t.evaluate(fact('foo' => [1]), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => nil), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => [1, 3, 5]), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => []), [], Factbase.new))
-  end
-end

data/test/factbase/terms/test_ordering.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Ordering test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestOrdering < Factbase::Test
-  def test_prev
-    t = Factbase::Term.new(:prev, [:foo])
-    assert_nil(t.evaluate(fact('foo' => 41), [], Factbase.new))
-    assert_equal([41], t.evaluate(fact('foo' => 5), [], Factbase.new))
-    assert_equal([5], t.evaluate(fact('foo' => 6), [], Factbase.new))
-  end
-
-  def test_unique
-    t = Factbase::Term.new(:unique, [:foo])
-    refute(t.evaluate(fact, [], Factbase.new))
-    assert(t.evaluate(fact('foo' => 41), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => 41), [], Factbase.new))
-    assert(t.evaluate(fact('foo' => 1), [], Factbase.new))
-  end
-end

data/test/factbase/terms/test_strings.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../../test__helper'
-require_relative '../../../lib/factbase/term'
-
-# Strings test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestStrings < Factbase::Test
-  def test_regexp_matching
-    t = Factbase::Term.new(:matches, [:foo, '[a-z]+'])
-    assert(t.evaluate(fact('foo' => 'hello'), [], Factbase.new))
-    assert(t.evaluate(fact('foo' => 'hello 42'), [], Factbase.new))
-    refute(t.evaluate(fact('foo' => 42), [], Factbase.new))
-  end
-
-  def test_concat
-    t = Factbase::Term.new(:concat, [42, 'hi', 3.14, :hey, Time.now])
-    s = t.evaluate(fact, [], Factbase.new)
-    assert(s.start_with?('42hi3.14'))
-  end
-
-  def test_concat_empty
-    t = Factbase::Term.new(:concat, [])
-    assert_equal('', t.evaluate(fact, [], Factbase.new))
-  end
-
-  def test_sprintf
-    t = Factbase::Term.new(:sprintf, ['hi, %s!', 'Jeff'])
-    assert_equal('hi, Jeff!', t.evaluate(fact, [], Factbase.new))
-  end
-end